http://www.fing.edu.uy/inco/proyectos/butia/mediawiki/api.php?action=feedcontributions&feedformat=atom&user=Gonzalo.mercadanteProyecto Butiá - Contribuciones del usuario [es]2026-04-05T19:03:46ZContribuciones del usuarioMediaWiki 1.26.2http://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7357Java2015-06-29T22:11:36Z<p>Gonzalo.mercadante: /* Importando el jar y utilizando las funciones */</p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder comprender correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
==Desarrollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distintas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego su traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el servidor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctions robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
try {<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
for(int i=0; i<4; i++){<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);<br />
sleep(10); // Calibrar<br />
<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
</source><br />
<br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
<br />
//Codigo seguidor de lineas.<br />
<br />
boolean run = true;<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.<br />
<br />
<br />
<br />
==Anexo==<br />
<br />
===Actas===<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7351Java2015-06-29T21:30:46Z<p>Gonzalo.mercadante: /* Investigación */</p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder comprender correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
==Desarrollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distintas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego su traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el servidor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
try {<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
for(int i=0; i<4; i++){<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);<br />
sleep(10); // Calibrar<br />
<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
</source><br />
<br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
<br />
//Codigo seguidor de lineas.<br />
<br />
boolean run = true;<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.<br />
<br />
<br />
<br />
==Anexo==<br />
<br />
===Actas===<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7350Java2015-06-29T21:17:05Z<p>Gonzalo.mercadante: /* Desarrollo */</p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarrollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distintas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego su traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el servidor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
try {<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
for(int i=0; i<4; i++){<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);<br />
sleep(10); // Calibrar<br />
<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
</source><br />
<br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
<br />
//Codigo seguidor de lineas.<br />
<br />
boolean run = true;<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.<br />
<br />
<br />
<br />
==Anexo==<br />
<br />
===Actas===<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7302Java2015-06-29T17:38:28Z<p>Gonzalo.mercadante: /* Utilizando el cliente java desde la consola */</p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarrollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego su traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el servidor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
try {<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
for(int i=0; i<4; i++){<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);<br />
sleep(10); // Calibrar<br />
<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
</source><br />
<br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
<br />
//Codigo seguidor de lineas.<br />
<br />
boolean run = true;<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.<br />
<br />
<br />
<br />
==Anexo==<br />
<br />
===Actas===<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7301Java2015-06-29T17:32:24Z<p>Gonzalo.mercadante: /* Desarollo */</p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarrollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego su traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
try {<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
for(int i=0; i<4; i++){<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);<br />
sleep(10); // Calibrar<br />
<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
</source><br />
<br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
<br />
//Codigo seguidor de lineas.<br />
<br />
boolean run = true;<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.<br />
<br />
<br />
<br />
==Anexo==<br />
<br />
===Actas===<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7297Java2015-06-29T17:11:56Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego su traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
try {<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
for(int i=0; i<4; i++){<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);<br />
sleep(10); // Calibrar<br />
<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
</source><br />
<br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
<br />
//Codigo seguidor de lineas.<br />
<br />
boolean run = true;<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.<br />
<br />
<br />
<br />
==Anexo==<br />
<br />
===Actas===<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7283Java2015-06-28T17:59:28Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego su traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
try {<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
for(int i=0; i<4; i++){<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);<br />
sleep(10); // Calibrar<br />
<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
</source><br />
<br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
<br />
//Codigo seguidor de lineas.<br />
<br />
boolean run = true;<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7282Java2015-06-28T17:46:45Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
try {<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
for(int i=0; i<4; i++){<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);<br />
sleep(10); // Calibrar<br />
<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
</source><br />
<br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
<br />
//Codigo seguidor de lineas.<br />
<br />
boolean run = true;<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7281Java2015-06-28T17:44:31Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
try {<br />
<br />
for(int i=0; i<4; i++){<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);<br />
sleep(10); // Calibrar<br />
<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
</source><br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
<br />
//Codigo seguidor de lineas.<br />
<br />
boolean run = true;<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7280Java2015-06-28T17:39:58Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
</source><br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions(); // POr defecto servidor en localhost, puerto 2009.<br />
<br />
//Codigo seguidor de lineas.<br />
<br />
boolean run = true;<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7279Java2015-06-28T17:35:12Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
</source><br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions();<br />
boolean run = true;<br />
<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7278Java2015-06-28T17:34:41Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
== Ejemplos básicos ==<br />
<br />
=== Realizando un cuadrado ===<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
<source><br />
<br />
=== Seguidor de líneas ===<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions();<br />
boolean run = true;<br />
<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7277Java2015-06-28T17:33:49Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
=== Ejemplos básicos ===<br />
<br />
== Realizando un cuadrado ==<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
<source><br />
<br />
== Seguidor de líneas ==<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions();<br />
boolean run = true;<br />
<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
</source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7276Java2015-06-28T17:31:45Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto del serividor, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
=== Ejemplos básicos ===<br />
<br />
== Realizando un cuadrado ==<br />
<br />
A continuación se muestra el código necesario para realizar un cuadrado con la API.<br />
<br />
<source lang="java"><br />
<br />
<source><br />
<br />
== Seguidor de líneas ==<br />
<br />
A continuación se muestra el código necesario para realizar un seguidor de líneas con la API .<br />
<br />
<source lang="java"><br />
<br />
import functions.ButiaFunctions;<br />
<br />
ButiaFunctions robot = new ButiaFunctions();<br />
boolean run = true;<br />
<br />
while (run){<br />
try {<br />
while (robot.getGrey(1, 0)<31000 && robot.getGrey(4, 0)<25000){ // Calibrar.<br />
robot.set2MotorSpeed(0, 400, 0, 400, 0);<br />
sleep(100);<br />
<br />
}<br />
while(robot.getGrey(1, 0)>=31000){ // Si es negro<br />
robot.set2MotorSpeed(0, 400, 1, 400, 0);//giro a la derecha<br />
sleep(10);<br />
}<br />
<br />
while(robot.getGrey(4, 0)>=25000){ // Si es negro<br />
robot.set2MotorSpeed(1, 400, 0, 400, 0);//giro a la izquierda<br />
sleep(10);<br />
}<br />
<br />
} catch (InterruptedException ex) {<br />
Logger.getLogger(javabot_client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
<br />
<source><br />
<br />
[https://www.youtube.com/watch?v=IIIS_nr5jaU Aquí] se muestra un video del paso a paso para realizar el seguidor de líneas en NetBeans, mostrando cuáles son las importaciones que hay que hacer para utilizar la API.<br />
<br />
[https://www.youtube.com/watch?v=MtHbW-hjnZY Aquí] se muestra un video del seguidor de líneas realizado en el video anterior con la API Java.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7275Java2015-06-28T17:18:42Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez levantado el cliente, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
'''Opción 1:'''<br />
<br />
Se especifica el cliente con el que se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
'''Opción 2:'''<br />
Si no se especifica el cliente, se asume que por defecto el servidor está en localhost:2009. Para utilizar las funciones hacer:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
Y luego por ejemplo: <br />
<br />
robot.getButton(port, board)<br />
<br />
<br />
=== Ejemplos básicos ===</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7274Java2015-06-28T16:47:40Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez corriendo, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, luego de creado el proyecto en java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functions.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
Opción 1:<br />
<br />
Se especifica el cliente, para de esta forma especificar con qué cliente se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions(cliente);<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
Opción 2:<br />
No se especifica el cliente, y se asume que por defecto el servidor está en localhost:2009</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7273Java2015-06-28T16:45:46Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez corriendo, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===<br />
<br />
Si se quiere realizar un programa y utilizar la API en Java, luego de creado el proyecto en java, se debe importar la librería javabot_robedu.jar en el proyecto.<br />
Las importaciones que pueden necesitarse son:<br />
<br />
import functons.ButiaFunctions;<br />
import javabot_client.javabot_client;<br />
<br />
<br />
Para poder utilizar las funciones, hay 2 formas de hacerlo:<br />
<br />
Opción 1:<br />
<br />
Se especifica el cliente, para de esta forma especificar con qué cliente se acceden a la funciones para manejar el robot. Al cliente puede pasarse el host y puerto, o por defecto utilizar localhost y puerto 2009. A continuación se muestran los constructores para el cliente:<br />
<br />
<br />
javabot_client cliente = new javabot_client(); // Por defecto localhost:2009.<br />
javabot_client cliente = new javabot_client(host, puerto); // Especificando el host y puerto del servidor.<br />
<br />
Luego, para utilizar la funciones debe hacerse:<br />
<br />
ButiaFunctiones robot = new ButiaFunctions();<br />
<br />
A continuación se muestran algunas de las funciones sobre los sensores:<br />
<br />
robot.getButton(port, board) // obtiene el valor del sensor botón conectado en el puerto port<br />
robot.getDistance(port, board) // obtiene el valor del sensor de distancia conectado en el puerto port<br />
robot.getGray(port, board) // obtiene el valor del sensor de grises conectado en el puerto port<br />
robot.getLight(port, board) // obtiene el valor del sensor de luz conectado en el puerto port<br />
<br />
<br />
<br />
Opción 2:<br />
No se especifica el cliente, y se asume que por defecto el servidor está en localhost:2009</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7272Java2015-06-28T16:27:53Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez corriendo, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7271Java2015-06-28T16:27:07Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez corriendo, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
Por defecto, se asume que el serivdor está en el host = localhost y puerto = 2009. Si se desea especificar otro host o puerto, puede ejecutarse de la siguiente manera:<br />
<br />
java -jar javabot_robedu.jar localhost puerto<br />
<br />
<br />
<br />
=== Importando el jar y utilizando las funciones ===</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7270Java2015-06-28T16:21:31Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.<br />
<br />
<br />
=== Utilizando el cliente java desde la consola ===<br />
<br />
Una vez que se tiene corriendo el servidor, se puede ejecutar el cliente desde la consola de la siguiente forma:<br />
<br />
java -jar javabot_robedu.jar<br />
<br />
Una vez corriendo, pueden ingresarse los diferentes comandos para comunicarse con el serivdor y manejar el robot.<br />
#[https://www.youtube.com/watch?v=_7E9b8iP8CI Aquí] puede verse un video ejemplo, donde se manejan los motores de butiá mediante el cliente java.<br />
<br />
=== Importando el jar y utilizando las funciones ===</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7269Java2015-06-28T16:05:24Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
'''Cliente Python:'''<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
'''Cliente Java:'''<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source><br />
<br />
<br />
==¿Cómo utilizar la API en Java?==<br />
<br />
=== Antes de empezar ===<br />
<br />
En el caso de usar [[pyBot]] se debe ejecutar:<br />
<br />
python pybot_server.py<br />
<br />
Para habilitar el DEBUG:<br />
<br />
python pybot_server.py DEBUG<br />
<br />
Luego de iniciado el servidor, podemos conectarnos desde el cliente javabot_robedu.jar.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7268Java2015-06-28T15:59:46Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
Cliente Python:<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
Cliente Java:<br />
<source lang="java"><br />
<br />
public String doCommand(String msg) {<br />
/* Executes a command in butia.@param msg message to be executed*/<br />
msg = msg + '\n';<br />
String ret = "";<br />
try {<br />
this.lock.acquire();<br />
DataOutputStream outToServer = new DataOutputStream(client.getOutputStream());<br />
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(client.getInputStream()));<br />
outToServer.write(msg.getBytes());<br />
outToServer.flush();<br />
<br />
char[] respuesta = new char[1024];<br />
inFromServer.read(respuesta);<br />
ret = String.valueOf(respuesta);<br />
<br />
} catch (Exception e) {<br />
ret = "" + ERROR;<br />
process_error(e);<br />
}<br />
this.lock.release();<br />
return ret;<br />
}<br />
</source></div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7267Java2015-06-28T15:57:35Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.<br />
<br />
A continuación se muestra un ejemplo de una función en Python y luego se traducción en Java. Esta función realiza la comunicación con el servidor, ejecutando un comando desde el cliente:<br />
<br />
Cliente Python:<br />
<source lang="python"><br />
<br />
def _doCommand(self, msg, ret_type = str):<br />
"""<br />
Executes a command in butia.<br />
@param msg message to be executed<br />
"""<br />
msg = msg + '\n'<br />
ret = ERROR<br />
self._lock.acquire()<br />
try: <br />
self._client.send(msg)<br />
ret = self._client.recv(1024)<br />
ret = ret[:-1]<br />
except Exception, e:<br />
self._process_error(e)<br />
try:<br />
ret = ret_type(ret)<br />
except:<br />
ret = ERROR<br />
self._lock.release()<br />
return ret<br />
</source><br />
<br />
Cliente Java:<br />
<source lang="java"><br />
</source></div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7266Java2015-06-28T15:54:27Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
<br />
==Investigación==<br />
<br />
Antes de comenzar con la implementación de la API en Java se investigaron algunas cosas que se debían utilizar.<br />
Por un lado se realizó un estudio básico del lenguaje Python para poder entender la sintáxis de dicho lenguaje. Esto era necesario para poder compreder correctamente el comportamiento de las funciones que se debían traducir.<br />
Por otro lado se estudió el manejo básico de sockects, necesario para que el cliente (Java) se comunicara con el servidor (Python).<br />
<br />
<br />
==Desarollo==<br />
<br />
Primero se analizaron los archivos en Python, para luego comenzar a traducir las funciones al lenguaje Java. Durante la implementación, se trató en todo momento que el código fuera lo más similar posible al código en Python. Algunas cosas no fueron posibles realizarlas de forma similar dada las diferencias en los lenguajes. Un ejemplo de esto es la sintáxis utilizada en Python para establecer los parámetros de una función, donde se pueden definir parámetros opcionales. En Java, se debe sobrescribir la función para las distantas cantidades de parámetros que se requieran.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7265Java2015-06-28T15:43:57Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizar el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
==Desarollo==</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7264Java2015-06-28T15:43:21Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizara el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
==Desarollo==</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Java&diff=7263Java2015-06-28T15:43:01Z<p>Gonzalo.mercadante: </p>
<hr />
<div>Realización de una API en JAVA para manejar el robot butiá en ese lenguaje. Se presentan además ejemplos básicos.<br />
<br />
==Integrantes==<br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<br />
<br />
==Tutor==<br />
*Federico Andrade<br />
<br />
==Objetivo==<br />
<br />
Dada la gran comunidad de programadores Java, puede ser de interés para muchos manejar el robot mediante dicho lenguaje. Por esta razón, el objetivo del trabajo fue traducir al lenguaje Java las funciones necesarias para el manejo del robot butiá. Dichas funciones se encuentran implementadas en el lenguaje Python actualmente.<br />
Además se implementaron ejemplos básicos de manejo del robot para mostrar cómo utilizar la nueva API.<br />
<br />
<br />
==Actas==<br />
<br />
===3 de junio de 2015===<br />
* Fueron planteadas las principales características del proyecto.<br />
* Se habló sobre cuáles eran los archivos de la API en Python que se necesitaban traducir. Se recomendó analizara el archivo functions.py. Luego de analizado este archivo, se decidió que los archivos a traducir eran 2: <br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/functions.py functions.py]<br />
#[http://sourceforge.net/p/butia/code/ci/master/tree/turtlebots/pybot/pybot_client.py pybot_client.py]<br />
<br />
=== 24 de junio de 2015 ===<br />
* Se probaron los ejemplos realizados.<br />
* Se establecieron las pautas para la entrega y presentación.<br />
<br />
==Desarollo==</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Los_supersonicos&diff=6951Los supersonicos2015-04-26T23:31:59Z<p>Gonzalo.mercadante: </p>
<hr />
<div>===Integrantes===<br />
<b>Butiá</b><br />
*Santiago Behak<br />
*Gonzalo Mercadante<br />
*Fernanda Toledo<br />
<b>Lego</b><br />
*Camila Serena<br />
*Josefina Fasoli<br />
*Gonzalo Herrera<br />
===El trabajo realizado por cada sub-equipo y las decisiones tomadas.===<br />
<b>Butiá</b><br />
<br />
Con el kit butiá se pretendía resolver los problemas asociados a la traslación del robot. Lo primero que se realizó fue el seguidor de líneas, para que el robot pudiera seguir el camino correctamente. Además se agregó un sensor de distancia en uno de los laterales, para detectar las casas. <br />
Una vez detectada una casa, el siguiente problema a enfrentar fue girar el robot y avanzar hasta poder detectar al gato. Para esto se hizo girar el butiá y se utilizó un sensor de distancia del kit Lego (por ser más preciso), para poder detectar el momento en el cual el robot se encontrara a la distancia deseada para que el Lego pudiera agarrar al gato. A partir de ese momento se le pasaba el control al kit Lego.<br />
Luego de agarrado el gato, el siguiente problema a enfrentar por el kit butiá era girar hasta encontrar la casa. Tanto para detectar el gato como para detectar la casa, se tomó la decisión de ir girando hasta encontrar el elemento (gato o casa) y luego ir acercandose tratando de alinearse al elemento. Este fue uno de los grandes problemas que se tuvo, dada la gran presición que se debía tener.<br />
Por último, el butiá debía tener la capacidad de poder volver a la línea y seguir el camino.<br />
<br />
<br />
<b>Lego</b><br />
<br />
Con el kit lego se pretendía resolver el problema de salvar al gato y poder devolverlo a su hogar. Para esto nuestro equipo armo una garra, que a su vez tenía la movilidad de subir y bajar, lo que permitía agarrar al gato desde arriba y tenes menos probabilidades de tirar el árbol con la garra. La garra fue lograda con un motor lego y un sistema de engranajes. Una de las paletas de la garra sigue el mismo giro que el motor y la otra el giro contrario gracias al uso de engranajes, lo que genera el cerrar o abrir de la garra. <br />
<br />
===Aspectos de integración de los equipos.===<br />
En esta parte, ambos equipos tuvimos que coordinar ambos kits para cumplir el objetivo. En nuestro caso el mayor desafío se presento al tener que posicionar la garra exactamente encima del gato para poder salvarlo exitosamente.<br />
===Código desarrollado.===<br />
[[Archivo:DesafioButia.png]]<br />
===Material multimedia.===<br />
<b>Por partes</b><br/><br />
[[Archivo:BrazoLego1.jpg]]<br/><br />
[[Archivo:BrazoLego2.jpg]]<br/><br />
====Video====<br />
https://youtu.be/krWncvX1u9I<br/><br />
<b>Ya todo integrado</b><br/><br />
[[Archivo:RobotSupersonicos.jpg]]</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6815Grupo 72015-04-18T13:57:29Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego. Esto posiblemente se deba a que los sensores de distancia del kit Lego utilizan ultrasonido, mientras que los del kit Butiá utilizan infrarrojo.<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
<br />
* '''Movimiento:''' El manejo del movimiento en ambos kits es diferente, por lo tanto dependiendo de qué tipo de movimiento se pretenda, puede convenir utilizar uno o el otro. Butiá es más fácil de manejar si se quiere un movimiento simple pero lego permite un mejor manejo mediante la potencia y las rotaciones.<br />
<br/><br />
* '''Distancia:''' Como se mencionó anteriormente, Lego utiliza ultrasonido mientras que butiá utiliza infrarrojo, por lo tanto esto puede llevar a que dependiendo de ciertas condiciones, uno de los dos funciones mejor que el otro. Por ejemplo, en el caso del sensor de ultrasonido de Lego, no influyen ni los materiales ni los colores para sensar la distancia. Esto puede considerarse una ventaja sobre butiá.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6814Grupo 72015-04-18T13:57:01Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego. Esto posiblemente se deba a que los sensores de distancia del kit Lego utilizan ultrasonido, mientras que los del kit Butiá utilizan infrarrojo.<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
<br />
* '''Movimiento:''' El manejo del movimiento en ambos kits es diferente, por lo tanto dependiendo de qué tipo de movimiento se pretenda, puede convenir utilizar uno o el otro. Butiá es más fácil de manejar si se quiere un movimiento simple pero lego permite un mejor manejo mediante la potencia y las rotaciones.<br />
<br/><br />
* '''Distancia:''' Como se mencionó anteriormente, Lego utiliza ultrasonido mientras que butiá utiliza infrarrojo, por lo tanto esto puede llevar a que dependiendo de ciertas condiciones, uno de los dos funciones mejor que el otro. Por ejemplo, en el caso del sensor de ultrasonido de Lego, no influyen ni los materiales ni los colores para sensar la distancia. Esto puede considerarse una ventaja sobre butiá.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6813Grupo 72015-04-18T13:54:48Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego. Esto posiblemente se deba a que los sensores de distancia del kit Lego utilizan ultrasonido, mientras que los del kit Butiá utilizan infrarrojo.<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
<br />
* '''Movimiento:''' El manejo del movimiento en ambos kits es diferente, por lo tanto dependiendo de qué tipo de movimiento se pretenda, puede convenir utilizar uno o el otro. Butiá es más fácil de manejar si se quiere un movimiento simple pero lego permite un mejor manejo mediante la potencia y las rotaciones.<br />
<br/><br />
* '''Distancia:''' Como se mencionó anteriormente, Lego utiliza ultrasonido mientras que butiá utiliza infrarrojo, por lo tanto esto puede llevar a que dependiendo de ciertas condiciones, uno de los dos funciones mejor que el otro. Por ejemplo, en el caso del sensor de ultrasonido de Lego, no influyen ni los materiales ni los colores para sensar la distancia. Esto puede considerarse una ventaja sobre butiá.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6812Grupo 72015-04-18T13:53:56Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego. Esto posiblemente se deba a que los sensores de distancia del kit Lego utilizan ultrasonido, mientras que los del kit Butiá utilizan infrarrojo.<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
<br />
* '''Movimiento:''' El manejo del movimiento en ambos kits es diferente, por lo tanto dependiendo de qué tipo de movimiento se pretenda, puede convenir utilizar uno o el otro. Butiá es más fácil de manejar si se quiere un movimiento simple pero lego permite un mejor manejo mediante la potencia y las rotaciones.<br />
<br/><br />
* '''Medir distancia:''' Como se mencionó anteriormente, Lego utiliza ultrasonido mientras que butiá utiliza infrarrojo, por lo tanto esto puede llevar a que dependiendo de ciertas condiciones, uno de los dos funciones mejor que el otro. Por ejemplo, en el caso del sensor de ultrasonido de Lego, no influyen ni los materiales ni los colores para sensar la distancia. Esto puede considerarse una ventaja sobre butiá.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6811Grupo 72015-04-18T13:53:20Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego. Esto posiblemente se deba a que los sensores de distancia del kit Lego utilizan ultrasonido, mientras que los del kit Butiá utilizan infrarrojo.<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
<br />
* '''Movimiento:''' El manejo del movimiento en ambos kits es diferente, por lo tanto dependiendo de qué tipo de movimiento se pretenda, puede convenir utilizar uno o el otro. Butiá es más fácil de manejar si se quiere un movimiento simple pero lego permite un mejor manejo mediante la potencia y las rotaciones.<br />
<br/><br />
* '''Senso distancia:''' Como se mencionó anteriormente, Lego utiliza ultrasonido mientras que butiá utiliza infrarrojo, por lo tanto esto puede llevar a que dependiendo de ciertas condiciones, uno de los dos funciones mejor que el otro. Por ejemplo, en el caso del sensor de ultrasonido de Lego, no influyen ni los materiales ni los colores para sensar la distancia. Esto puede considerarse una ventaja sobre butiá.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6810Grupo 72015-04-18T13:51:48Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego. Esto posiblemente se deba a que los sensores de distancia del kit Lego utilizan ultrasonido, mientras que los del kit Butiá utilizan infrarrojo.<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
<br />
* '''Movimiento:''' El manejo del movimiento en ambos kits es diferente, por lo tanto dependiendo de qué tipo de movimiento se pretenda, puede convenir utilizar uno o el otro. Butiá es más fácil de manejar si se quiere un movimiento simple pero lego permite un mejor manejo mediante la potencia y las rotaciones.<br />
<br/><br />
* '''Distancia:''' Como se mencionó anteriormente, Lego utiliza ultrasonido mientras que butiá utiliza infrarrojo, por lo tanto esto puede llevar a que dependiendo de ciertas condiciones, uno de los dos funciones mejor que el otro. Por ejemplo, en el caso del sensor de ultrasonido de Lego, no influyen ni los materiales ni los colores para sensar la distancia. Esto puede considerarse una ventaja sobre butiá.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6809Grupo 72015-04-18T13:50:55Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego. Esto posiblemente se deba a que los sensores de distancia del kit Lego utilizan ultrasonido, mientras que los del kit Butiá utilizan infrarrojo.<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br/><br />
* '''Movimiento:''' El manejo del movimiento en ambos kits es diferente, por lo tanto dependiendo de qué tipo de movimiento se pretenda, puede convenir utilizar uno o el otro. Butiá es más fácil de manejar si se quiere un movimiento simple pero lego permite un mejor manejo mediante la potencia y las rotaciones.<br />
<br/><br />
* '''Distancia:''' Como se mencionó anteriormente, Lego utiliza ultrasonido mientras que butiá utiliza infrarrojo, por lo tanto esto puede llevar a que dependiendo de ciertas condiciones, uno de los dos funciones mejor que el otro.<br />
Por ejemplo, en el caso del sensor de ultrasonido de Lego, no influyen ni los materiales ni los colores para sensar la distancia. Esto puede considerarse una ventaja sobre butiá.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6808Grupo 72015-04-18T13:50:30Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego. Esto posiblemente se deba a que los sensores de distancia del kit Lego utilizan ultrasonido, mientras que los del kit Butiá utilizan infrarrojo.<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br/><br />
* Movimiento: El manejo del movimiento en ambos kits es diferente, por lo tanto dependiendo de qué tipo de movimiento se pretenda, puede convenir utilizar uno o el otro. Butiá es más fácil de manejar si se quiere un movimiento simple pero lego permite un mejor manejo mediante la potencia y las rotaciones.<br />
<br/><br />
* Distancia: Como se mencionó anteriormente, Lego utiliza ultrasonido mientras que butiá utiliza infrarrojo, por lo tanto esto puede llevar a que dependiendo de ciertas condiciones, uno de los dos funciones mejor que el otro.<br />
Por ejemplo, en el caso del sensor de ultrasonido de Lego, no influyen ni los materiales ni los colores para sensar la distancia. Esto puede considerarse una ventaja sobre butiá.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6807Grupo 72015-04-18T13:49:01Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego. Esto posiblemente se deba a que los sensores de distancia del kit Lego utilizan ultrasonido, mientras que los del kit Butiá utilizan infrarrojo.<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
* Movimiento: El manejo del movimiento en ambos kits es diferente, por lo tanto dependiendo de qué tipo de movimiento se pretenda, puede convenir utilizar uno o el otro.<br />
<br />
* Distancia: Como se mencionó anteriormente, Lego utiliza ultrasonido mientras que butiá utiliza infrarrojo, por lo tanto esto puede llevar a que dependiendo de ciertas condiciones, uno de los dos funciones mejor que el otro.<br />
Por ejemplo, en el caso del sensor de ultrasonido de Lego, no influyen ni los materiales ni los colores para sensar la distancia. Esto puede considerarse una ventaja sobre butiá.</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6806Grupo 72015-04-18T13:35:33Z<p>Gonzalo.mercadante: /* Generales */</p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego. Esto posiblemente se deba a que los sensores de distancia del kit Lego utilizan ultrasonido, mientras que los del kit Butiá utilizan infrarrojo.<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6805Grupo 72015-04-18T13:30:39Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
*Luego de realizadas las pruebas, se pudo ver que para algunos sensores el kit Lego era más preciso. En el caso de butia, para una misma situación, los valores obtenidos podían llegar a variar bastante. Un ejemplo de esto es el sensor de distancia, que colocado a una misma distancia, se obtenían valores que variaban más que en el caso Lego.<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6804Grupo 72015-04-18T13:25:58Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6803Grupo 72015-04-18T13:25:13Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6802Grupo 72015-04-18T13:24:45Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
====Botón====<br />
{| class="wikitable"<br />
! Sensor distancia<br />
! Sensor luz<br />
! Sension presión (botón)<br />
! Sensor sonido<br />
<br />
|-<br />
|Escala 0 - 100 aprox.||0 - 100 aprox.|| Valores: 0 o 1 || 0 -100 aprox.<br />
|-<br />
|Suelto||0<br />
|}<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6801Grupo 72015-04-18T13:22:51Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
====Botón====<br />
{| class="wikitable"<br />
! Sensor distancia<br />
! Sensor luz<br />
! Sension presión (botón)<br />
! Sensor sonido<br />
<br />
|-<br />
|Apretado||1<br />
|-<br />
|Suelto||0<br />
|}<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6800Grupo 72015-04-18T13:21:39Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
====Botón====<br />
{| class="wikitable"<br />
! Estado<br />
! Valor<br />
<br />
|-<br />
|Apretado||1<br />
|-<br />
|Suelto||0<br />
|}<br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6799Grupo 72015-04-18T13:20:04Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6798Grupo 72015-04-18T13:19:40Z<p>Gonzalo.mercadante: /* Kit Lego: */</p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6797Grupo 72015-04-18T13:19:06Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
===Kit Butia:===<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
<br />
===Kit Lego:===<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6796Grupo 72015-04-18T13:18:30Z<p>Gonzalo.mercadante: /* Actuadores utilizados y pruebas */</p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
'''Kit butia'''<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
<br />
'''Kit lego'''<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6795Grupo 72015-04-18T13:18:09Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
'''Kit butia'''<br />
En el kit butiá se puede controlar la velocidad de los motores, y se puede indicar hacia dónde debe ser el movimiento.<br />
<br />
<br />
'''Kit lego'''<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. En este kit el motor se pude controlar especificando potencia y cantidad de rotaciones.<br />
<br />
Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadantehttp://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php?title=Grupo_7&diff=6794Grupo 72015-04-18T13:13:26Z<p>Gonzalo.mercadante: </p>
<hr />
<div>__TOC__<br />
<br />
== Integrantes ==<br />
<br />
* Santiago Behak<br />
* Gonzalo Mercadante<br />
* Fernanda Toledo<br />
<br />
<br />
==Desarrollo de la actividad==<br />
<br />
Para poder apreciar las desviaciones de cada uno de los sensores se trabajó con cada uno de los kits y se tomaron varias veces las mismas mediciones para poder ver que tan grande era la desviación.<br />
Para tomar las medidas se utilizó turtlebots, y para cada sensor se realizó un pequeño programa que permitiera tomar las medidas.<br />
<br />
<br />
==Sensores utilizados y pruebas==<br />
<br />
===Kit Lego:===<br />
*<i>Sensor de distancia: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de luz: Escala 0 - 100 aprox.</i><br />
*<i>Sensor de presión(botón): Valores: 0 o 1.</i><br />
*<i>Sensor de sonido: Escala: 0 -100 aprox.</i><br />
<br />
<br />
===Kit Butiá:===<br />
*<i>Sensor de presión(botón): Valores 0 o 1.</i><br />
*<i>Sensor de luz: Escala: 0 - 65535</i><br />
*<i>Sensor de distancia: Escala: 0 - 65535.</i><br />
Existe una distancia mínima en la cual si el sensor se acerca más al material entonces este deja de proporcionar valores correctos. La mínima distancia obtenida en el laboratorio fue 24785.<br />
*<i>Sensor escala de grices: Escala: 0 - 65535</i><br />
<br/><br />
<br/><br />
<br />
==Actuadores utilizados y pruebas==<br />
<br />
<br />
En el kit butiá se puede controlar la velocidad de los motores mientras que en el lego se puede controlar la potencia y la cantidad de rotaciones.<br />
<br />
La potencia en el kit lego puede variar entre los valores -127 y 127. Además se observó que en ambos motores hay un valor mínimo a partir del cual para valores inferiores entonces el motor no se mueve.<br />
<br />
<br />
==Conclusiones==<br />
<br />
===Generales===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos<br />
<br />
<br />
===Comparación de los dos Kits (Ventajas y Desventajas de cada uno)===<br />
<br />
*Se plantea la investigación varios kits robóticos para hacer un revelamiento de los actuadores que incorpora.<br />
*Uno de los actuadores a incorporar será el motor pasos a paso y para comenzar a trabajar en este tipo de motores debemos discutir varios puntos por lo cual decidimos</div>Gonzalo.mercadante