http://164.73.124.35/inco/proyectos/butia/mediawiki/api.php?action=feedcontributions&feedformat=atom&user=Nvazquez Proyecto Butiá - Contribuciones del usuario [es] 2026-04-05T23:52:55Z Contribuciones del usuario MediaWiki 1.26.2 http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7679 Monitor 2015-09-10T23:07:37Z <p>Nvazquez: /* TurtleBots */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Gonzalo Crovetto [mailto:crovetto.gonzalo@gmail.com crovetto.gonzalo@gmail.com] <br /> * Federico Mujica [mailto:federicomujica1@gmail.com federicomujica1@gmail.com]<br /> * Nicolás Vázquez [mailto:nicovazquez90@gmail.com nicovazquez90@gmail.com] <br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera [mailto:gtejera@fing.edu.uy gtejera@fing.edu.uy]<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos .<br /> === '''Objetivos''' ===<br /> <br /> Nos planteamos los siguientes objetivos:<br /> * Brindar nuevas funcionalidades a Turtlebots para poder reconocer más intuitivamente los posibles problemas que puedan estar sucediendo.<br /> <br /> * Lograr que los nuevos usuarios puedan reconocer fácilmente dichos problemas, haciendo que su período de aprendizaje sea más ameno y menos frustrante.<br /> <br /> * Dejar el camino abierto a la implementación de nuevas funcionalidades que permitan el monitoreo no solo de errores, sino de determinados comportamientos que puedan ser de interés para el usuario<br /> <br /> ¿Cómo lograrlo?<br /> * Encontrando los errores que se manifiestan con normalidad.<br /> * Identificando cada uno de dichos errores y agrupándolos para darles un significado distinto que el usuario pueda comprender.<br /> * Modificando la visualización de los componentes de acuerdo al error identificado.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''MonitorElem''' ====<br /> Cada instancia de MonitorElem contiene los contadores de errores y las operaciones de monitoreo, las cuales son invocadas desde MonitorButia según el sensor que esté conectado<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> ==== '''Identificación de errores''' ====<br /> A partir de la investigación del sistema previa al desarrollo, fuimos observando que podemos detectar ciertos tipos de errores, de forma de tener una idea más precisa de que tipo de falla es la que se obtiene, ya que cuando había algún fallo de cualquier tipo siempre se devolvía la constante -1. Por lo tanto incluímos:<br /> * ERROR_BOARD_DISCONECTED = -100 (este error se genera cuando la placa no esta conectada)<br /> * ERROR_MODULE_NOT_PRESENT = -101 (este error se genera cuando el modulo al que se quiere acceder no esta disponible)<br /> * ERROR_EXCEPTION = -102 (este tipo de error lo incluimos para aquellos casos donde puede darse un fallo impredecible)<br /> <br /> Para poder hacer uso de estos tipos de errores, tuvimos que modificar la funcion call_module de usb4butia.py<br /> &lt;source lang=&quot;python&quot;&gt;<br /> from plugins.butia.monitor import ERROR_BOARD_DISCONECTED<br /> from plugins.butia.monitor import ERROR_MODULE_NOT_PRESENT<br /> from plugins.butia.monitor import ERROR_EXCEPTION<br /> <br /> #....<br /> <br /> def callModule(self, modulename, board_number, number, function, params = [], ret_type = int):<br /> &quot;&quot;&quot;<br /> Call one function: function for module: modulename in board: board_name<br /> with handler: number (only if the module is pnp, else, the parameter is<br /> None) with parameteres: params<br /> &quot;&quot;&quot;<br /> try:<br /> number = int(number)<br /> board_number = int(board_number)<br /> if len(self._bb) &lt; (board_number + 1):<br /> return ERROR_BOARD_DISCONECTED<br /> board = self._bb[board_number]<br /> if board.devices.has_key(number) and (board.devices[number].name == modulename):<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> else:<br /> number = self._open_or_validate(modulename, board) #Trata de obtener el modulo<br /> if number == ERROR:<br /> return ERROR_MODULE_NOT_PRESENT<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> except Exception, err:<br /> if hasattr(err, 'errno'):<br /> if (err.errno == 5) or (err.errno == 19):<br /> self.closeB(board)<br /> self._debug('ERROR:usb4butia:callModule', err)<br /> return ERROR_EXCEPTION #Aca exploto<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> <br /> Entradas:<br /> * set_new_devices : lista de sensores conectados<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_new_devices:<br /> ** Se pone el pone el atributo inuse en True y se inicializan todos los contadores en 0 para la instancia de MonitorElem correspondiente al sensor<br /> <br /> ===== '''desactivateMonitor''' =====<br /> <br /> Entradas:<br /> * set_old_devices : lista de sensores que estaban conectados antes del llamado<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_old_devices:<br /> ** Se pone el pone el atributo inuse en False para la instancia de MonitorElem correspondiente al sensor. Los contadores permanecen iguales.<br /> <br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores<br /> <br /> === '''TurtleBots''' ===<br /> <br /> A nivel de TurtleBots agregamos una nueva paleta para poder utilizar bloques de monitoreo<br /> [[Archivo:MonitorTurtleBots.png]]<br /> <br /> Actualmente, el bloque resetMonitorButia está en funcionamiento y llama a la función reset de MonitorButia.<br /> <br /> ==== '''Trabajo a futuro''' ====<br /> Como trabajo a futuro nos plantemos los siguientes desafíos:<br /> * Agregar un bloque que reciba como entrada un sensor y devuelva el porcentaje de errores que tuvo el sensor con respecto al total de operaciones, estos deberían ser: FALLO BAJO, FALLO MEDIO, FALLO ALTO (que ya se encuentran disponibles en la paleta con un color correspondiente según el grado de error)<br /> * Con el punto anterior se busca permitir que el usuario pueda diseñar su programa de forma que se pueda detectar cómo actuar según el comportamiento de los sensores</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7678 Monitor 2015-09-10T23:06:54Z <p>Nvazquez: /* TurtleBots */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Gonzalo Crovetto [mailto:crovetto.gonzalo@gmail.com crovetto.gonzalo@gmail.com] <br /> * Federico Mujica [mailto:federicomujica1@gmail.com federicomujica1@gmail.com]<br /> * Nicolás Vázquez [mailto:nicovazquez90@gmail.com nicovazquez90@gmail.com] <br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera [mailto:gtejera@fing.edu.uy gtejera@fing.edu.uy]<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos .<br /> === '''Objetivos''' ===<br /> <br /> Nos planteamos los siguientes objetivos:<br /> * Brindar nuevas funcionalidades a Turtlebots para poder reconocer más intuitivamente los posibles problemas que puedan estar sucediendo.<br /> <br /> * Lograr que los nuevos usuarios puedan reconocer fácilmente dichos problemas, haciendo que su período de aprendizaje sea más ameno y menos frustrante.<br /> <br /> * Dejar el camino abierto a la implementación de nuevas funcionalidades que permitan el monitoreo no solo de errores, sino de determinados comportamientos que puedan ser de interés para el usuario<br /> <br /> ¿Cómo lograrlo?<br /> * Encontrando los errores que se manifiestan con normalidad.<br /> * Identificando cada uno de dichos errores y agrupándolos para darles un significado distinto que el usuario pueda comprender.<br /> * Modificando la visualización de los componentes de acuerdo al error identificado.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''MonitorElem''' ====<br /> Cada instancia de MonitorElem contiene los contadores de errores y las operaciones de monitoreo, las cuales son invocadas desde MonitorButia según el sensor que esté conectado<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> ==== '''Identificación de errores''' ====<br /> A partir de la investigación del sistema previa al desarrollo, fuimos observando que podemos detectar ciertos tipos de errores, de forma de tener una idea más precisa de que tipo de falla es la que se obtiene, ya que cuando había algún fallo de cualquier tipo siempre se devolvía la constante -1. Por lo tanto incluímos:<br /> * ERROR_BOARD_DISCONECTED = -100 (este error se genera cuando la placa no esta conectada)<br /> * ERROR_MODULE_NOT_PRESENT = -101 (este error se genera cuando el modulo al que se quiere acceder no esta disponible)<br /> * ERROR_EXCEPTION = -102 (este tipo de error lo incluimos para aquellos casos donde puede darse un fallo impredecible)<br /> <br /> Para poder hacer uso de estos tipos de errores, tuvimos que modificar la funcion call_module de usb4butia.py<br /> &lt;source lang=&quot;python&quot;&gt;<br /> from plugins.butia.monitor import ERROR_BOARD_DISCONECTED<br /> from plugins.butia.monitor import ERROR_MODULE_NOT_PRESENT<br /> from plugins.butia.monitor import ERROR_EXCEPTION<br /> <br /> #....<br /> <br /> def callModule(self, modulename, board_number, number, function, params = [], ret_type = int):<br /> &quot;&quot;&quot;<br /> Call one function: function for module: modulename in board: board_name<br /> with handler: number (only if the module is pnp, else, the parameter is<br /> None) with parameteres: params<br /> &quot;&quot;&quot;<br /> try:<br /> number = int(number)<br /> board_number = int(board_number)<br /> if len(self._bb) &lt; (board_number + 1):<br /> return ERROR_BOARD_DISCONECTED<br /> board = self._bb[board_number]<br /> if board.devices.has_key(number) and (board.devices[number].name == modulename):<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> else:<br /> number = self._open_or_validate(modulename, board) #Trata de obtener el modulo<br /> if number == ERROR:<br /> return ERROR_MODULE_NOT_PRESENT<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> except Exception, err:<br /> if hasattr(err, 'errno'):<br /> if (err.errno == 5) or (err.errno == 19):<br /> self.closeB(board)<br /> self._debug('ERROR:usb4butia:callModule', err)<br /> return ERROR_EXCEPTION #Aca exploto<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> <br /> Entradas:<br /> * set_new_devices : lista de sensores conectados<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_new_devices:<br /> ** Se pone el pone el atributo inuse en True y se inicializan todos los contadores en 0 para la instancia de MonitorElem correspondiente al sensor<br /> <br /> ===== '''desactivateMonitor''' =====<br /> <br /> Entradas:<br /> * set_old_devices : lista de sensores que estaban conectados antes del llamado<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_old_devices:<br /> ** Se pone el pone el atributo inuse en False para la instancia de MonitorElem correspondiente al sensor. Los contadores permanecen iguales.<br /> <br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores<br /> <br /> === '''TurtleBots''' ===<br /> <br /> A nivel de TurtleBots agregamos una nueva paleta para poder utilizar bloques de monitoreo<br /> [[Archivo:MonitorTurtleBots.png]]<br /> <br /> Actualmente, el bloque resetMonitorButia está en funcionamiento y llama a la función reset de MonitorButia, su comportamiento está explicado más arriba.<br /> <br /> ==== '''Trabajo a futuro''' ====<br /> Como trabajo a futuro nos plantemos los siguientes desafíos:<br /> * Agregar un bloque que reciba como entrada un sensor y devuelva el porcentaje de errores que tuvo el sensor con respecto al total de operaciones, estos deberían ser: FALLO BAJO, FALLO MEDIO, FALLO ALTO (que ya se encuentran disponibles en la paleta con un color correspondiente según el grado de error)<br /> * Con el punto anterior se busca permitir que el usuario pueda diseñar su programa de forma que se pueda detectar cómo actuar según el comportamiento de los sensores</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7677 Monitor 2015-09-10T23:05:18Z <p>Nvazquez: /* TurtleBots */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Gonzalo Crovetto [mailto:crovetto.gonzalo@gmail.com crovetto.gonzalo@gmail.com] <br /> * Federico Mujica [mailto:federicomujica1@gmail.com federicomujica1@gmail.com]<br /> * Nicolás Vázquez [mailto:nicovazquez90@gmail.com nicovazquez90@gmail.com] <br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera [mailto:gtejera@fing.edu.uy gtejera@fing.edu.uy]<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos .<br /> === '''Objetivos''' ===<br /> <br /> Nos planteamos los siguientes objetivos:<br /> * Brindar nuevas funcionalidades a Turtlebots para poder reconocer más intuitivamente los posibles problemas que puedan estar sucediendo.<br /> <br /> * Lograr que los nuevos usuarios puedan reconocer fácilmente dichos problemas, haciendo que su período de aprendizaje sea más ameno y menos frustrante.<br /> <br /> * Dejar el camino abierto a la implementación de nuevas funcionalidades que permitan el monitoreo no solo de errores, sino de determinados comportamientos que puedan ser de interés para el usuario<br /> <br /> ¿Cómo lograrlo?<br /> * Encontrando los errores que se manifiestan con normalidad.<br /> * Identificando cada uno de dichos errores y agrupándolos para darles un significado distinto que el usuario pueda comprender.<br /> * Modificando la visualización de los componentes de acuerdo al error identificado.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''MonitorElem''' ====<br /> Cada instancia de MonitorElem contiene los contadores de errores y las operaciones de monitoreo, las cuales son invocadas desde MonitorButia según el sensor que esté conectado<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> ==== '''Identificación de errores''' ====<br /> A partir de la investigación del sistema previa al desarrollo, fuimos observando que podemos detectar ciertos tipos de errores, de forma de tener una idea más precisa de que tipo de falla es la que se obtiene, ya que cuando había algún fallo de cualquier tipo siempre se devolvía la constante -1. Por lo tanto incluímos:<br /> * ERROR_BOARD_DISCONECTED = -100 (este error se genera cuando la placa no esta conectada)<br /> * ERROR_MODULE_NOT_PRESENT = -101 (este error se genera cuando el modulo al que se quiere acceder no esta disponible)<br /> * ERROR_EXCEPTION = -102 (este tipo de error lo incluimos para aquellos casos donde puede darse un fallo impredecible)<br /> <br /> Para poder hacer uso de estos tipos de errores, tuvimos que modificar la funcion call_module de usb4butia.py<br /> &lt;source lang=&quot;python&quot;&gt;<br /> from plugins.butia.monitor import ERROR_BOARD_DISCONECTED<br /> from plugins.butia.monitor import ERROR_MODULE_NOT_PRESENT<br /> from plugins.butia.monitor import ERROR_EXCEPTION<br /> <br /> #....<br /> <br /> def callModule(self, modulename, board_number, number, function, params = [], ret_type = int):<br /> &quot;&quot;&quot;<br /> Call one function: function for module: modulename in board: board_name<br /> with handler: number (only if the module is pnp, else, the parameter is<br /> None) with parameteres: params<br /> &quot;&quot;&quot;<br /> try:<br /> number = int(number)<br /> board_number = int(board_number)<br /> if len(self._bb) &lt; (board_number + 1):<br /> return ERROR_BOARD_DISCONECTED<br /> board = self._bb[board_number]<br /> if board.devices.has_key(number) and (board.devices[number].name == modulename):<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> else:<br /> number = self._open_or_validate(modulename, board) #Trata de obtener el modulo<br /> if number == ERROR:<br /> return ERROR_MODULE_NOT_PRESENT<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> except Exception, err:<br /> if hasattr(err, 'errno'):<br /> if (err.errno == 5) or (err.errno == 19):<br /> self.closeB(board)<br /> self._debug('ERROR:usb4butia:callModule', err)<br /> return ERROR_EXCEPTION #Aca exploto<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> <br /> Entradas:<br /> * set_new_devices : lista de sensores conectados<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_new_devices:<br /> ** Se pone el pone el atributo inuse en True y se inicializan todos los contadores en 0 para la instancia de MonitorElem correspondiente al sensor<br /> <br /> ===== '''desactivateMonitor''' =====<br /> <br /> Entradas:<br /> * set_old_devices : lista de sensores que estaban conectados antes del llamado<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_old_devices:<br /> ** Se pone el pone el atributo inuse en False para la instancia de MonitorElem correspondiente al sensor. Los contadores permanecen iguales.<br /> <br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores<br /> <br /> === '''TurtleBots''' ===<br /> <br /> A nivel de TurtleBots agregamos una nueva paleta para poder utilizar bloques de monitoreo<br /> [[Archivo:monitor.png]]<br /> <br /> Actualmente, el bloque resetMonitorButia está en funcionamiento y llama a la función reset de MonitorButia, su comportamiento está explicado más arriba.<br /> <br /> ==== '''Trabajo a futuro''' ====<br /> Como trabajo a futuro nos plantemos los siguientes desafíos:<br /> * Agregar un bloque que reciba como entrada un sensor y devuelva el porcentaje de errores que tuvo el sensor con respecto al total de operaciones, estos deberían ser: FALLO BAJO, FALLO MEDIO, FALLO ALTO (que ya se encuentran disponibles en la paleta con un color correspondiente según el grado de error)<br /> * Con el punto anterior se busca permitir que el usuario pueda diseñar su programa de forma que se pueda detectar cómo actuar según el comportamiento de los sensores</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7676 Monitor 2015-09-10T22:56:18Z <p>Nvazquez: /* TurtleBots */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Gonzalo Crovetto [mailto:crovetto.gonzalo@gmail.com crovetto.gonzalo@gmail.com] <br /> * Federico Mujica [mailto:federicomujica1@gmail.com federicomujica1@gmail.com]<br /> * Nicolás Vázquez [mailto:nicovazquez90@gmail.com nicovazquez90@gmail.com] <br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera [mailto:gtejera@fing.edu.uy gtejera@fing.edu.uy]<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos .<br /> === '''Objetivos''' ===<br /> <br /> Nos planteamos los siguientes objetivos:<br /> * Brindar nuevas funcionalidades a Turtlebots para poder reconocer más intuitivamente los posibles problemas que puedan estar sucediendo.<br /> <br /> * Lograr que los nuevos usuarios puedan reconocer fácilmente dichos problemas, haciendo que su período de aprendizaje sea más ameno y menos frustrante.<br /> <br /> * Dejar el camino abierto a la implementación de nuevas funcionalidades que permitan el monitoreo no solo de errores, sino de determinados comportamientos que puedan ser de interés para el usuario<br /> <br /> ¿Cómo lograrlo?<br /> * Encontrando los errores que se manifiestan con normalidad.<br /> * Identificando cada uno de dichos errores y agrupándolos para darles un significado distinto que el usuario pueda comprender.<br /> * Modificando la visualización de los componentes de acuerdo al error identificado.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''MonitorElem''' ====<br /> Cada instancia de MonitorElem contiene los contadores de errores y las operaciones de monitoreo, las cuales son invocadas desde MonitorButia según el sensor que esté conectado<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> ==== '''Identificación de errores''' ====<br /> A partir de la investigación del sistema previa al desarrollo, fuimos observando que podemos detectar ciertos tipos de errores, de forma de tener una idea más precisa de que tipo de falla es la que se obtiene, ya que cuando había algún fallo de cualquier tipo siempre se devolvía la constante -1. Por lo tanto incluímos:<br /> * ERROR_BOARD_DISCONECTED = -100 (este error se genera cuando la placa no esta conectada)<br /> * ERROR_MODULE_NOT_PRESENT = -101 (este error se genera cuando el modulo al que se quiere acceder no esta disponible)<br /> * ERROR_EXCEPTION = -102 (este tipo de error lo incluimos para aquellos casos donde puede darse un fallo impredecible)<br /> <br /> Para poder hacer uso de estos tipos de errores, tuvimos que modificar la funcion call_module de usb4butia.py<br /> &lt;source lang=&quot;python&quot;&gt;<br /> from plugins.butia.monitor import ERROR_BOARD_DISCONECTED<br /> from plugins.butia.monitor import ERROR_MODULE_NOT_PRESENT<br /> from plugins.butia.monitor import ERROR_EXCEPTION<br /> <br /> #....<br /> <br /> def callModule(self, modulename, board_number, number, function, params = [], ret_type = int):<br /> &quot;&quot;&quot;<br /> Call one function: function for module: modulename in board: board_name<br /> with handler: number (only if the module is pnp, else, the parameter is<br /> None) with parameteres: params<br /> &quot;&quot;&quot;<br /> try:<br /> number = int(number)<br /> board_number = int(board_number)<br /> if len(self._bb) &lt; (board_number + 1):<br /> return ERROR_BOARD_DISCONECTED<br /> board = self._bb[board_number]<br /> if board.devices.has_key(number) and (board.devices[number].name == modulename):<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> else:<br /> number = self._open_or_validate(modulename, board) #Trata de obtener el modulo<br /> if number == ERROR:<br /> return ERROR_MODULE_NOT_PRESENT<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> except Exception, err:<br /> if hasattr(err, 'errno'):<br /> if (err.errno == 5) or (err.errno == 19):<br /> self.closeB(board)<br /> self._debug('ERROR:usb4butia:callModule', err)<br /> return ERROR_EXCEPTION #Aca exploto<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> <br /> Entradas:<br /> * set_new_devices : lista de sensores conectados<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_new_devices:<br /> ** Se pone el pone el atributo inuse en True y se inicializan todos los contadores en 0 para la instancia de MonitorElem correspondiente al sensor<br /> <br /> ===== '''desactivateMonitor''' =====<br /> <br /> Entradas:<br /> * set_old_devices : lista de sensores que estaban conectados antes del llamado<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_old_devices:<br /> ** Se pone el pone el atributo inuse en False para la instancia de MonitorElem correspondiente al sensor. Los contadores permanecen iguales.<br /> <br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores<br /> <br /> === '''TurtleBots''' ===<br /> <br /> A nivel de TurtleBots agregamos una nueva paleta para poder utilizar bloques de monitoreo<br /> [[Archivo:MonitorTurtleBots.png]]<br /> <br /> Actualmente, el bloque resetMonitorButia es el que</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Archivo:MonitorTurtleBots.png&diff=7675 Archivo:MonitorTurtleBots.png 2015-09-10T22:56:05Z <p>Nvazquez: subió una nueva versión de «Archivo:MonitorTurtleBots.png»</p> <hr /> <div></div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7674 Monitor 2015-09-10T22:51:29Z <p>Nvazquez: /* Desarrollo */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Gonzalo Crovetto [mailto:crovetto.gonzalo@gmail.com crovetto.gonzalo@gmail.com] <br /> * Federico Mujica [mailto:federicomujica1@gmail.com federicomujica1@gmail.com]<br /> * Nicolás Vázquez [mailto:nicovazquez90@gmail.com nicovazquez90@gmail.com] <br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera [mailto:gtejera@fing.edu.uy gtejera@fing.edu.uy]<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos .<br /> === '''Objetivos''' ===<br /> <br /> Nos planteamos los siguientes objetivos:<br /> * Brindar nuevas funcionalidades a Turtlebots para poder reconocer más intuitivamente los posibles problemas que puedan estar sucediendo.<br /> <br /> * Lograr que los nuevos usuarios puedan reconocer fácilmente dichos problemas, haciendo que su período de aprendizaje sea más ameno y menos frustrante.<br /> <br /> * Dejar el camino abierto a la implementación de nuevas funcionalidades que permitan el monitoreo no solo de errores, sino de determinados comportamientos que puedan ser de interés para el usuario<br /> <br /> ¿Cómo lograrlo?<br /> * Encontrando los errores que se manifiestan con normalidad.<br /> * Identificando cada uno de dichos errores y agrupándolos para darles un significado distinto que el usuario pueda comprender.<br /> * Modificando la visualización de los componentes de acuerdo al error identificado.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''MonitorElem''' ====<br /> Cada instancia de MonitorElem contiene los contadores de errores y las operaciones de monitoreo, las cuales son invocadas desde MonitorButia según el sensor que esté conectado<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> ==== '''Identificación de errores''' ====<br /> A partir de la investigación del sistema previa al desarrollo, fuimos observando que podemos detectar ciertos tipos de errores, de forma de tener una idea más precisa de que tipo de falla es la que se obtiene, ya que cuando había algún fallo de cualquier tipo siempre se devolvía la constante -1. Por lo tanto incluímos:<br /> * ERROR_BOARD_DISCONECTED = -100 (este error se genera cuando la placa no esta conectada)<br /> * ERROR_MODULE_NOT_PRESENT = -101 (este error se genera cuando el modulo al que se quiere acceder no esta disponible)<br /> * ERROR_EXCEPTION = -102 (este tipo de error lo incluimos para aquellos casos donde puede darse un fallo impredecible)<br /> <br /> Para poder hacer uso de estos tipos de errores, tuvimos que modificar la funcion call_module de usb4butia.py<br /> &lt;source lang=&quot;python&quot;&gt;<br /> from plugins.butia.monitor import ERROR_BOARD_DISCONECTED<br /> from plugins.butia.monitor import ERROR_MODULE_NOT_PRESENT<br /> from plugins.butia.monitor import ERROR_EXCEPTION<br /> <br /> #....<br /> <br /> def callModule(self, modulename, board_number, number, function, params = [], ret_type = int):<br /> &quot;&quot;&quot;<br /> Call one function: function for module: modulename in board: board_name<br /> with handler: number (only if the module is pnp, else, the parameter is<br /> None) with parameteres: params<br /> &quot;&quot;&quot;<br /> try:<br /> number = int(number)<br /> board_number = int(board_number)<br /> if len(self._bb) &lt; (board_number + 1):<br /> return ERROR_BOARD_DISCONECTED<br /> board = self._bb[board_number]<br /> if board.devices.has_key(number) and (board.devices[number].name == modulename):<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> else:<br /> number = self._open_or_validate(modulename, board) #Trata de obtener el modulo<br /> if number == ERROR:<br /> return ERROR_MODULE_NOT_PRESENT<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> except Exception, err:<br /> if hasattr(err, 'errno'):<br /> if (err.errno == 5) or (err.errno == 19):<br /> self.closeB(board)<br /> self._debug('ERROR:usb4butia:callModule', err)<br /> return ERROR_EXCEPTION #Aca exploto<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> <br /> Entradas:<br /> * set_new_devices : lista de sensores conectados<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_new_devices:<br /> ** Se pone el pone el atributo inuse en True y se inicializan todos los contadores en 0 para la instancia de MonitorElem correspondiente al sensor<br /> <br /> ===== '''desactivateMonitor''' =====<br /> <br /> Entradas:<br /> * set_old_devices : lista de sensores que estaban conectados antes del llamado<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_old_devices:<br /> ** Se pone el pone el atributo inuse en False para la instancia de MonitorElem correspondiente al sensor. Los contadores permanecen iguales.<br /> <br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores<br /> <br /> === '''TurtleBots''' ===<br /> <br /> A nivel de TurtleBots agregamos una nueva paleta para poder utilizar bloques de monitoreo<br /> [[Archivo:MonitorTurtleBots.png]]</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Archivo:MonitorTurtleBots.png&diff=7673 Archivo:MonitorTurtleBots.png 2015-09-10T22:49:15Z <p>Nvazquez: </p> <hr /> <div></div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7672 Monitor 2015-09-10T22:30:52Z <p>Nvazquez: </p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Gonzalo Crovetto [mailto:crovetto.gonzalo@gmail.com crovetto.gonzalo@gmail.com] <br /> * Federico Mujica [mailto:federicomujica1@gmail.com federicomujica1@gmail.com]<br /> * Nicolás Vázquez [mailto:nicovazquez90@gmail.com nicovazquez90@gmail.com] <br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera [mailto:gtejera@fing.edu.uy gtejera@fing.edu.uy]<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos .<br /> === '''Objetivos''' ===<br /> <br /> Nos planteamos los siguientes objetivos:<br /> * Brindar nuevas funcionalidades a Turtlebots para poder reconocer más intuitivamente los posibles problemas que puedan estar sucediendo.<br /> <br /> * Lograr que los nuevos usuarios puedan reconocer fácilmente dichos problemas, haciendo que su período de aprendizaje sea más ameno y menos frustrante.<br /> <br /> * Dejar el camino abierto a la implementación de nuevas funcionalidades que permitan el monitoreo no solo de errores, sino de determinados comportamientos que puedan ser de interés para el usuario<br /> <br /> ¿Cómo lograrlo?<br /> * Encontrando los errores que se manifiestan con normalidad.<br /> * Identificando cada uno de dichos errores y agrupándolos para darles un significado distinto que el usuario pueda comprender.<br /> * Modificando la visualización de los componentes de acuerdo al error identificado.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''MonitorElem''' ====<br /> Cada instancia de MonitorElem contiene los contadores de errores y las operaciones de monitoreo, las cuales son invocadas desde MonitorButia según el sensor que esté conectado<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> ==== '''Identificación de errores''' ====<br /> A partir de la investigación del sistema previa al desarrollo, fuimos observando que podemos detectar ciertos tipos de errores, de forma de tener una idea más precisa de que tipo de falla es la que se obtiene, ya que cuando había algún fallo de cualquier tipo siempre se devolvía la constante -1. Por lo tanto incluímos:<br /> * ERROR_BOARD_DISCONECTED = -100 (este error se genera cuando la placa no esta conectada)<br /> * ERROR_MODULE_NOT_PRESENT = -101 (este error se genera cuando el modulo al que se quiere acceder no esta disponible)<br /> * ERROR_EXCEPTION = -102 (este tipo de error lo incluimos para aquellos casos donde puede darse un fallo impredecible)<br /> <br /> Para poder hacer uso de estos tipos de errores, tuvimos que modificar la funcion call_module de usb4butia.py<br /> &lt;source lang=&quot;python&quot;&gt;<br /> from plugins.butia.monitor import ERROR_BOARD_DISCONECTED<br /> from plugins.butia.monitor import ERROR_MODULE_NOT_PRESENT<br /> from plugins.butia.monitor import ERROR_EXCEPTION<br /> <br /> #....<br /> <br /> def callModule(self, modulename, board_number, number, function, params = [], ret_type = int):<br /> &quot;&quot;&quot;<br /> Call one function: function for module: modulename in board: board_name<br /> with handler: number (only if the module is pnp, else, the parameter is<br /> None) with parameteres: params<br /> &quot;&quot;&quot;<br /> try:<br /> number = int(number)<br /> board_number = int(board_number)<br /> if len(self._bb) &lt; (board_number + 1):<br /> return ERROR_BOARD_DISCONECTED<br /> board = self._bb[board_number]<br /> if board.devices.has_key(number) and (board.devices[number].name == modulename):<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> else:<br /> number = self._open_or_validate(modulename, board) #Trata de obtener el modulo<br /> if number == ERROR:<br /> return ERROR_MODULE_NOT_PRESENT<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> except Exception, err:<br /> if hasattr(err, 'errno'):<br /> if (err.errno == 5) or (err.errno == 19):<br /> self.closeB(board)<br /> self._debug('ERROR:usb4butia:callModule', err)<br /> return ERROR_EXCEPTION #Aca exploto<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> <br /> Entradas:<br /> * set_new_devices : lista de sensores conectados<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_new_devices:<br /> ** Se pone el pone el atributo inuse en True y se inicializan todos los contadores en 0 para la instancia de MonitorElem correspondiente al sensor<br /> <br /> ===== '''desactivateMonitor''' =====<br /> <br /> Entradas:<br /> * set_old_devices : lista de sensores que estaban conectados antes del llamado<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_old_devices:<br /> ** Se pone el pone el atributo inuse en False para la instancia de MonitorElem correspondiente al sensor. Los contadores permanecen iguales.<br /> <br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7671 Monitor 2015-09-10T22:14:42Z <p>Nvazquez: /* Desarrollo */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''MonitorElem''' ====<br /> Cada instancia de MonitorElem contiene los contadores de errores y las operaciones de monitoreo, las cuales son invocadas desde MonitorButia según el sensor que esté conectado<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> ==== '''Identificación de errores''' ====<br /> A partir de la investigación del sistema previa al desarrollo, fuimos observando que podemos detectar ciertos tipos de errores, de forma de tener una idea más precisa de que tipo de falla es la que se obtiene, ya que cuando había algún fallo de cualquier tipo siempre se devolvía la constante -1. Por lo tanto incluímos:<br /> * ERROR_BOARD_DISCONECTED = -100 (este error se genera cuando la placa no esta conectada)<br /> * ERROR_MODULE_NOT_PRESENT = -101 (este error se genera cuando el modulo al que se quiere acceder no esta disponible)<br /> * ERROR_EXCEPTION = -102 (este tipo de error lo incluimos para aquellos casos donde puede darse un fallo impredecible)<br /> <br /> Para poder hacer uso de estos tipos de errores, tuvimos que modificar la funcion call_module de usb4butia.py<br /> &lt;source lang=&quot;python&quot;&gt;<br /> from plugins.butia.monitor import ERROR_BOARD_DISCONECTED<br /> from plugins.butia.monitor import ERROR_MODULE_NOT_PRESENT<br /> from plugins.butia.monitor import ERROR_EXCEPTION<br /> <br /> #....<br /> <br /> def callModule(self, modulename, board_number, number, function, params = [], ret_type = int):<br /> &quot;&quot;&quot;<br /> Call one function: function for module: modulename in board: board_name<br /> with handler: number (only if the module is pnp, else, the parameter is<br /> None) with parameteres: params<br /> &quot;&quot;&quot;<br /> try:<br /> number = int(number)<br /> board_number = int(board_number)<br /> if len(self._bb) &lt; (board_number + 1):<br /> return ERROR_BOARD_DISCONECTED<br /> board = self._bb[board_number]<br /> if board.devices.has_key(number) and (board.devices[number].name == modulename):<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> else:<br /> number = self._open_or_validate(modulename, board) #Trata de obtener el modulo<br /> if number == ERROR:<br /> return ERROR_MODULE_NOT_PRESENT<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> except Exception, err:<br /> if hasattr(err, 'errno'):<br /> if (err.errno == 5) or (err.errno == 19):<br /> self.closeB(board)<br /> self._debug('ERROR:usb4butia:callModule', err)<br /> return ERROR_EXCEPTION #Aca exploto<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> <br /> Entradas:<br /> * set_new_devices : lista de sensores conectados<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_new_devices:<br /> ** Se pone el pone el atributo inuse en True y se inicializan todos los contadores en 0 para la instancia de MonitorElem correspondiente al sensor<br /> <br /> ===== '''desactivateMonitor''' =====<br /> <br /> Entradas:<br /> * set_old_devices : lista de sensores que estaban conectados antes del llamado<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_old_devices:<br /> ** Se pone el pone el atributo inuse en False para la instancia de MonitorElem correspondiente al sensor. Los contadores permanecen iguales.<br /> <br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7670 Monitor 2015-09-10T22:11:36Z <p>Nvazquez: /* MonitorButia */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Identificación de errores''' ====<br /> A partir de la investigación del sistema previa al desarrollo, fuimos observando que podemos detectar ciertos tipos de errores, de forma de tener una idea más precisa de que tipo de falla es la que se obtiene, ya que cuando había algún fallo de cualquier tipo siempre se devolvía la constante -1. Por lo tanto incluímos:<br /> * ERROR_BOARD_DISCONECTED = -100 (este error se genera cuando la placa no esta conectada)<br /> * ERROR_MODULE_NOT_PRESENT = -101 (este error se genera cuando el modulo al que se quiere acceder no esta disponible)<br /> * ERROR_EXCEPTION = -102 (este tipo de error lo incluimos para aquellos casos donde puede darse un fallo impredecible)<br /> <br /> Para poder hacer uso de estos tipos de errores, tuvimos que modificar la funcion call_module de usb4butia.py<br /> &lt;source lang=&quot;python&quot;&gt;<br /> from plugins.butia.monitor import ERROR_BOARD_DISCONECTED<br /> from plugins.butia.monitor import ERROR_MODULE_NOT_PRESENT<br /> from plugins.butia.monitor import ERROR_EXCEPTION<br /> <br /> #....<br /> <br /> def callModule(self, modulename, board_number, number, function, params = [], ret_type = int):<br /> &quot;&quot;&quot;<br /> Call one function: function for module: modulename in board: board_name<br /> with handler: number (only if the module is pnp, else, the parameter is<br /> None) with parameteres: params<br /> &quot;&quot;&quot;<br /> try:<br /> number = int(number)<br /> board_number = int(board_number)<br /> if len(self._bb) &lt; (board_number + 1):<br /> return ERROR_BOARD_DISCONECTED<br /> board = self._bb[board_number]<br /> if board.devices.has_key(number) and (board.devices[number].name == modulename):<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> else:<br /> number = self._open_or_validate(modulename, board) #Trata de obtener el modulo<br /> if number == ERROR:<br /> return ERROR_MODULE_NOT_PRESENT<br /> return board.devices[number].call_function(function, params) #Aca puede venir un -1 y lo dejamos asi<br /> except Exception, err:<br /> if hasattr(err, 'errno'):<br /> if (err.errno == 5) or (err.errno == 19):<br /> self.closeB(board)<br /> self._debug('ERROR:usb4butia:callModule', err)<br /> return ERROR_EXCEPTION #Aca exploto<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> <br /> Entradas:<br /> * set_new_devices : lista de sensores conectados<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_new_devices:<br /> ** Se pone el pone el atributo inuse en True y se inicializan todos los contadores en 0 para la instancia de MonitorElem correspondiente al sensor<br /> <br /> ===== '''desactivateMonitor''' =====<br /> <br /> Entradas:<br /> * set_old_devices : lista de sensores que estaban conectados antes del llamado<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_old_devices:<br /> ** Se pone el pone el atributo inuse en False para la instancia de MonitorElem correspondiente al sensor. Los contadores permanecen iguales.<br /> <br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7669 Monitor 2015-09-10T22:02:00Z <p>Nvazquez: /* Desarrollo */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Identificación de errores''' =====<br /> A partir de la investigación del sistema previa al desarrollo, fuimos observando que podemos detectar ciertos tipos de errores, de forma de tener una idea más precisa de que tipo de falla es la que se obtiene, ya que cuando había algún fallo de cualquier tipo siempre se devolvía la constante -1. Por lo tanto incluímos:<br /> * ERROR_BOARD_DISCONECTED = -100<br /> * ERROR_MODULE_NOT_PRESENT = -101<br /> * ERROR_EXCEPTION = -102<br /> * ERROR = -1<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> <br /> Entradas:<br /> * set_new_devices : lista de sensores conectados<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_new_devices:<br /> ** Se pone el pone el atributo inuse en True y se inicializan todos los contadores en 0 para la instancia de MonitorElem correspondiente al sensor<br /> <br /> ===== '''desactivateMonitor''' =====<br /> <br /> Entradas:<br /> * set_old_devices : lista de sensores que estaban conectados antes del llamado<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_old_devices:<br /> ** Se pone el pone el atributo inuse en False para la instancia de MonitorElem correspondiente al sensor. Los contadores permanecen iguales.<br /> <br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7668 Monitor 2015-09-10T21:49:54Z <p>Nvazquez: /* Funciones */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> <br /> Entradas:<br /> * set_new_devices : lista de sensores conectados<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_new_devices:<br /> ** Se pone el pone el atributo inuse en True y se inicializan todos los contadores en 0 para la instancia de MonitorElem correspondiente al sensor<br /> <br /> ===== '''desactivateMonitor''' =====<br /> <br /> Entradas:<br /> * set_old_devices : lista de sensores que estaban conectados antes del llamado<br /> <br /> Salidas:<br /> * Ninguna<br /> <br /> Funcionamiento<br /> * Para cada sensor en set_old_devices:<br /> ** Se pone el pone el atributo inuse en False para la instancia de MonitorElem correspondiente al sensor. Los contadores permanecen iguales.<br /> <br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7667 Monitor 2015-09-10T21:40:40Z <p>Nvazquez: /* reset */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> ===== '''desactivateMonitor''' =====<br /> ===== '''reset''' =====<br /> <br /> Entradas: <br /> * Ninguna<br /> <br /> Salidas: <br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para todos los sensores que están en uso: <br /> ** Resetea todos los contadores</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7666 Monitor 2015-09-10T21:39:31Z <p>Nvazquez: /* reset */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> ===== '''desactivateMonitor''' =====<br /> ===== '''reset''' =====<br /> <br /> * Entradas: Ninguna<br /> <br /> * Salidas: Ninguna<br /> <br /> * Funcionamiento:<br /> Para todos los sensores que están en uso: resetea todos los contadores</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7647 Monitor 2015-09-10T04:27:01Z <p>Nvazquez: /* Desarrollo */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Mantenemos el código en el siguiente repositorio Git: [https://github.com/nvazquez/Turtlebots https://github.com/nvazquez/Turtlebots]<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> ===== '''desactivateMonitor''' =====<br /> ===== '''reset''' =====</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7646 Monitor 2015-09-10T04:23:22Z <p>Nvazquez: /* Funciones */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado<br /> <br /> ===== '''activateMonitor''' =====<br /> ===== '''desactivateMonitor''' =====<br /> ===== '''reset''' =====</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7645 Monitor 2015-09-10T04:22:30Z <p>Nvazquez: /* getMonitorEvaluation */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> ** Si está en uso, se calcula el promedio de errores sobre la cantidad de operaciones totales. Se devuelve la salida correspondiente segun el porcentaje calculado</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7644 Monitor 2015-09-10T04:20:20Z <p>Nvazquez: /* Funciones */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * Ninguna<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente<br /> <br /> ===== '''getMonitorEvaluation''' =====<br /> Entrada:<br /> * Ninguna<br /> <br /> Salida:<br /> * Una lista indicando el sensor, puerto donde se encuentra conectado y el tipo de evaluación de errores, el cual puede ser:<br /> ** MONITOR_RETURN_TYPE_NO_OP (indica que no se ha utilizado)<br /> ** MONITOR_RETURN_TYPE_LOW (indica que el promedio de errores para el sensor en ese puerto es menor al 25%)<br /> ** MONITOR_RETURN_TYPE_MEDIUM (indica que el promedio de errores para el sensor en ese puerto es mayor al 25% y menor al 50%)<br /> ** MONITOR_RETURN_TYPE_HIGH (indica que el promedio de errores para el sensor en ese puerto es mayor al 50%)<br /> <br /> Funcionamiento:<br /> * Para cada sensor:<br /> **</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7643 Monitor 2015-09-10T04:13:13Z <p>Nvazquez: /* Funciones */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]<br /> <br /> ===== '''evaluateResult''' =====<br /> Entrada:<br /> * sensor_name : string -&gt; El nombre del sensor o actuador que se está evaluando<br /> * sensor_port : int -&gt; El número de puerto en el que se encuentra conectado el sensor o actuador<br /> * sensor_result : int -&gt; El resultado numérico obtenido al llamar a una función específica del sensor o actuador<br /> <br /> Salida:<br /> * No devuelve valor<br /> <br /> Funcionamiento:<br /> * Para el sensor o actuador identificado:<br /> ** Se incrementa el contador de operaciones totales en 1<br /> ** Se evalua sensor_result para detectar si el mismo es un error o no, y en caso de ser un error identificar el tipo de error e incrementar el contador del error correspondiente</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7642 Monitor 2015-09-10T04:03:23Z <p>Nvazquez: /* Métodos */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Funciones''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7641 Monitor 2015-09-10T04:03:07Z <p>Nvazquez: /* MonitorButia */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> ==== '''Definición''' ====<br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> ==== '''Métodos''' ====<br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7640 Monitor 2015-09-10T04:01:41Z <p>Nvazquez: /* MonitorButia */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;<br /> <br /> En forma gráfica podemos ver sus atributos y métodos:<br /> <br /> [[Archivo:MonitorButia.png]]</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Archivo:MonitorButia.png&diff=7639 Archivo:MonitorButia.png 2015-09-10T04:00:45Z <p>Nvazquez: </p> <hr /> <div></div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7638 Monitor 2015-09-10T03:56:00Z <p>Nvazquez: /* MonitorButia */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem (ya que es el número máximo de puertos que contiene la placa USB4Butia). Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7637 Monitor 2015-09-10T03:55:01Z <p>Nvazquez: /* Desarrollo */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==<br /> <br /> Como puede verse en el directorio /plugins/butia hemos creado dos nuevas clases:<br /> * MonitorButia (definido en el archivo monitor.py)<br /> * MonitorElem (definido en el archivo monitor_elem.py)<br /> <br /> === '''MonitorElem''' ===<br /> <br /> [[Archivo:MonitorElem.png]]<br /> <br /> === '''MonitorButia''' ===<br /> <br /> Nuestra clase MonitorButia está compuesta por un hash llamado sensors, en el cual la clave de cada elemento es el String que identifica a cada uno de los sensores o actuadores, y el valor es un arreglo de 6 elementos MonitorElem. Ademas contamos con las claves por separado en el atributo sensors_name. Para clarificar veamos la inicialización de la clase MonitorButia:<br /> <br /> &lt;source lang=&quot;python&quot;&gt;<br /> def __init__(self):<br /> self.sensors = {<br /> 'grey': [MonitorElem() for i in range(6)],<br /> 'light':[MonitorElem() for i in range(6)],<br /> 'distanc': [MonitorElem() for i in range(6)],<br /> 'button': [MonitorElem() for i in range(6)],<br /> 'motors': [MonitorElem() for i in range(8)]<br /> }<br /> self.sensors_name = ['grey', 'light', 'button', 'distanc','motors']<br /> &lt;/source&gt;</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Archivo:MonitorElem.png&diff=7636 Archivo:MonitorElem.png 2015-09-10T03:45:09Z <p>Nvazquez: </p> <hr /> <div></div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7635 Monitor 2015-09-10T03:30:14Z <p>Nvazquez: /* Investigación */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> * (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7634 Monitor 2015-09-10T03:29:56Z <p>Nvazquez: /* Investigación */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> En el centro de la imagen pueden verse las componentes centrales del sistema: pybot_client y pybot_server. Al iniciar TurtleBots, se inicializan ambos, y toda la interacción que podemos hacer desde la interfaz gráfica se va a traducir en comandos que se envían desde pybot_client hacia pybot_server, donde son atendidos estos pedidos.<br /> (falta hablar de butia y usb4butia, etc)<br /> <br /> == '''Desarrollo''' ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7633 Monitor 2015-09-10T03:23:01Z <p>Nvazquez: /* Investigación */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> Previo a poder implementar algunas de las ideas que nos surgían, pasamos por un largo proceso de investigación del funcionamiento de la plataforma Butiá. Identificamos módulos clave en la arquitectura del sistema, que se comunican de la siguiente manera:<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> == '''Desarrollo''' ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Archivo:ComunicacionModulos.jpg&diff=7632 Archivo:ComunicacionModulos.jpg 2015-09-10T03:19:08Z <p>Nvazquez: </p> <hr /> <div></div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7631 Monitor 2015-09-10T03:17:50Z <p>Nvazquez: /* Investigación */</p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> [[Archivo:ComunicacionModulos.jpg]]<br /> <br /> == '''Desarrollo''' ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7630 Monitor 2015-09-10T03:16:27Z <p>Nvazquez: </p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Investigación''' ==<br /> <br /> == '''Desarrollo''' ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Monitor&diff=7629 Monitor 2015-09-10T03:15:12Z <p>Nvazquez: </p> <hr /> <div>__TOC__<br /> <br /> == '''Integrantes''' ==<br /> <br /> * Nicolás Vázquez nicovazquez90@gmail.com <br /> * Gonzalo Crovetto crovetto.gonzalo@gmail.com <br /> * Federico Mujica federicomujica1@gmail.com &lt;br&gt;&lt;br&gt;<br /> <br /> =='''Tutor'''==<br /> * Gonzalo Tejera &lt;gtejera@fing.edu.uy&gt;&lt;br&gt;&lt;br&gt;<br /> <br /> == '''Introducción''' ==<br /> <br /> La plataforma Butiá se caracteriza por su amigabilidad y ayuda al usuario. Este proyecto plantea estudiar las posibilidades de ampliar la ayuda al usuario mediante la incorporación de un elemento monitor, que permita diagnosticar y apoyar el desarrollo de comportamientos.<br /> <br /> == '''Objetivo''' ==<br /> <br /> El objetivo del proyecto es integran un monitoreo del estado de los sensores a la interfaz gráfica del TutleBot. De esta manera queremos que el usuario sepa de una forma facil e intuitiva cuando un sensor esta teniendo algún tipo de problema.<br /> <br /> == '''Motivación''' ==<br /> <br /> Al finalizar este proyecto debemos poder brindar una forma intuitiva para usuarios sin conocimientos de electrónica ni programación de saber cual es el estado de los sensores butia.<br /> De esta forma, el usuario puede darse cuenta cuando cambiar un cable o un sensor defectuoso que este afectando su programa.<br /> <br /> == '''Desarrollo''' ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7159 Chinchuflin 2015-06-09T04:19:18Z <p>Nvazquez: /* Código desarrollado */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como fuimos desarrolando las partes del desafío:&lt;br/&gt;<br /> <br /> En este primer video se aprecia solamente como el robot recoge la pelota <br /> &lt;youtube&gt;A_elGhZKFsc&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> En este segundo video podemos ver ya integrada la parte de recolección de la pelota y luego depositarla en la casa<br /> &lt;youtube&gt;AnzCpkZYSd0&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> Por último vemos que luego que depositar la pelota en la casa, el robot retrocede hasta encontrar la línea negra para luego continuar el camino<br /> &lt;youtube&gt;cT0tF1b588U&lt;/youtube&gt;<br /> <br /> == Código desarrollado ==<br /> <br /> [[Archivo:Practico3.jpg]]<br /> <br /> El código fuente se puede descargar aquí [[Archivo:CodigoPractico3.zip]]</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7158 Chinchuflin 2015-06-09T04:19:01Z <p>Nvazquez: /* Código desarrollado */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como fuimos desarrolando las partes del desafío:&lt;br/&gt;<br /> <br /> En este primer video se aprecia solamente como el robot recoge la pelota <br /> &lt;youtube&gt;A_elGhZKFsc&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> En este segundo video podemos ver ya integrada la parte de recolección de la pelota y luego depositarla en la casa<br /> &lt;youtube&gt;AnzCpkZYSd0&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> Por último vemos que luego que depositar la pelota en la casa, el robot retrocede hasta encontrar la línea negra para luego continuar el camino<br /> &lt;youtube&gt;cT0tF1b588U&lt;/youtube&gt;<br /> <br /> == Código desarrollado ==<br /> <br /> [[Archivo:Practico3.jpg]]<br /> <br /> El código fuente se puede descargar aquí [[CodigoPractico3.zip]]</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7157 Chinchuflin 2015-06-09T04:18:40Z <p>Nvazquez: /* Código desarrollado */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como fuimos desarrolando las partes del desafío:&lt;br/&gt;<br /> <br /> En este primer video se aprecia solamente como el robot recoge la pelota <br /> &lt;youtube&gt;A_elGhZKFsc&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> En este segundo video podemos ver ya integrada la parte de recolección de la pelota y luego depositarla en la casa<br /> &lt;youtube&gt;AnzCpkZYSd0&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> Por último vemos que luego que depositar la pelota en la casa, el robot retrocede hasta encontrar la línea negra para luego continuar el camino<br /> &lt;youtube&gt;cT0tF1b588U&lt;/youtube&gt;<br /> <br /> == Código desarrollado ==<br /> <br /> [[Archivo:Practico3.jpg]]<br /> <br /> El código fuente se puede descargar aquí [[Archivo:CodigoPractico3.zip]]</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Archivo:CodigoPractico3.zip&diff=7156 Archivo:CodigoPractico3.zip 2015-06-09T04:17:42Z <p>Nvazquez: </p> <hr /> <div></div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Archivo:Practico3.jpg&diff=7155 Archivo:Practico3.jpg 2015-06-09T04:15:28Z <p>Nvazquez: Codigo Practico 3</p> <hr /> <div>Codigo Practico 3</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7154 Chinchuflin 2015-06-09T04:01:48Z <p>Nvazquez: </p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como fuimos desarrolando las partes del desafío:&lt;br/&gt;<br /> <br /> En este primer video se aprecia solamente como el robot recoge la pelota <br /> &lt;youtube&gt;A_elGhZKFsc&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> En este segundo video podemos ver ya integrada la parte de recolección de la pelota y luego depositarla en la casa<br /> &lt;youtube&gt;AnzCpkZYSd0&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> Por último vemos que luego que depositar la pelota en la casa, el robot retrocede hasta encontrar la línea negra para luego continuar el camino<br /> &lt;youtube&gt;cT0tF1b588U&lt;/youtube&gt;<br /> <br /> == Código desarrollado ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7153 Chinchuflin 2015-06-09T04:00:12Z <p>Nvazquez: /* Funcionamiento General */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como fuimos desarrolando las partes del desafío:&lt;br/&gt;<br /> <br /> En este primer video se aprecia solamente como el robot recoge la pelota <br /> &lt;youtube&gt;A_elGhZKFsc&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> En este segundo video podemos ver ya integrada la parte de recolección de la pelota y luego depositarla en la casa<br /> &lt;youtube&gt;AnzCpkZYSd0&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> Por último vemos que luego que depositar la pelota en la casa, el robot retrocede hasta encontrar la línea negra para luego continuar el camino<br /> &lt;youtube&gt;cT0tF1b588U&lt;/youtube&gt;<br /> <br /> == Aspectos de integración de los equipos ==<br /> <br /> == Código desarrollado ==<br /> <br /> == Material multimedia ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7152 Chinchuflin 2015-06-09T03:52:51Z <p>Nvazquez: /* Funcionamiento General */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como fuimos desarrolando las partes del desafío:&lt;br/&gt;<br /> <br /> En este primer video se aprecia solamente como el robot recoge la pelota <br /> &lt;youtube&gt;A_elGhZKFsc&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> En este segundo video podemos ver ya integrada la parte de recolección de la pelota y luego depositarla en la casa<br /> &lt;youtube&gt;AnzCpkZYSd0&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> == Aspectos de integración de los equipos ==<br /> <br /> == Código desarrollado ==<br /> <br /> == Material multimedia ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7151 Chinchuflin 2015-06-09T03:49:47Z <p>Nvazquez: /* Funcionamiento General */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como fuimos desarrolando las partes del desafío:&lt;br/&gt;<br /> <br /> En este primer video se aprecia solamente como el robot recoge la pelota <br /> &lt;youtube&gt;A_elGhZKFsc&lt;/youtube&gt;&lt;br/&gt;&lt;br/&gt;<br /> <br /> == Aspectos de integración de los equipos ==<br /> <br /> == Código desarrollado ==<br /> <br /> == Material multimedia ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7150 Chinchuflin 2015-06-09T03:41:27Z <p>Nvazquez: /* Funcionamiento General */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como quedaron integradas las partes y el funcionamiento del robot:<br /> <br /> &lt;youtube&gt;A_elGhZKFsc&lt;/youtube&gt;<br /> <br /> == Aspectos de integración de los equipos ==<br /> <br /> == Código desarrollado ==<br /> <br /> == Material multimedia ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7149 Chinchuflin 2015-06-09T03:37:02Z <p>Nvazquez: /* Funcionamiento General */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como quedaron integradas las partes y el funcionamiento del robot:<br /> <br /> &lt;iframe width=&quot;560&quot; height=&quot;315&quot; src=&quot;https://www.youtube.com/embed/A_elGhZKFsc&quot; frameborder=&quot;0&quot; allowfullscreen&gt;&lt;/iframe&gt;<br /> <br /> &lt;iframe width=&quot;560&quot; height=&quot;315&quot; src=&quot;https://www.youtube.com/embed/A_elGhZKFsc&quot; frameborder=&quot;0&quot; allowfullscreen&gt;&lt;/iframe&gt;<br /> <br /> {{#ev:youtube|https://www.youtube.com/watch?v=pSsYTj9kCHE}}<br /> <br /> == Aspectos de integración de los equipos ==<br /> <br /> == Código desarrollado ==<br /> <br /> == Material multimedia ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7148 Chinchuflin 2015-06-09T03:36:18Z <p>Nvazquez: /* Funcionamiento General */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como quedaron integradas las partes y el funcionamiento del robot:<br /> <br /> &lt;iframe width=&quot;560&quot; height=&quot;315&quot; src=&quot;https://www.youtube.com/embed/A_elGhZKFsc&quot; frameborder=&quot;0&quot; allowfullscreen&gt;&lt;/iframe&gt;<br /> <br /> &lt;iframe width=&quot;560&quot; height=&quot;315&quot; src=&quot;https://www.youtube.com/embed/A_elGhZKFsc&quot; frameborder=&quot;0&quot; allowfullscreen&gt;&lt;/iframe&gt;<br /> <br /> &lt;embedvideo service=&quot;youtube&quot;&gt;https://www.youtube.com/watch?v=pSsYTj9kCHE&lt;/embedvideo&gt;<br /> <br /> == Aspectos de integración de los equipos ==<br /> <br /> == Código desarrollado ==<br /> <br /> == Material multimedia ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7147 Chinchuflin 2015-06-09T03:33:40Z <p>Nvazquez: /* Funcionamiento General */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como quedaron integradas las partes y el funcionamiento del robot:<br /> <br /> &lt;iframe width=&quot;560&quot; height=&quot;315&quot; src=&quot;https://www.youtube.com/embed/A_elGhZKFsc&quot; frameborder=&quot;0&quot; allowfullscreen&gt;&lt;/iframe&gt;<br /> <br /> == Aspectos de integración de los equipos ==<br /> <br /> == Código desarrollado ==<br /> <br /> == Material multimedia ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7146 Chinchuflin 2015-06-09T03:13:24Z <p>Nvazquez: /* Trabajo Realizado */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> <br /> [[Archivo:Chinchuflin.jpg]]<br /> <br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> El kit Lego fue utilizado para resolver la captura de los gatos. Decidimos crear un brazo mecánico, accionado por un motor, que básicamente golpeara la pelota (gato) y lo depositara en el canasto construido también con el kit Lego. Esta canasta que contenía al gato, debía depositarlo en la casa al estar enfrentada a ella, con lo que también accionábamos un motor que lograba realizar el trabajo.<br /> <br /> === Funcionamiento General ===<br /> <br /> Veamos como quedaron integradas las partes y el funcionamiento del robot:<br /> <br /> == Aspectos de integración de los equipos ==<br /> <br /> == Código desarrollado ==<br /> <br /> == Material multimedia ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Archivo:Chinchuflin.jpg&diff=7145 Archivo:Chinchuflin.jpg 2015-06-09T03:07:59Z <p>Nvazquez: </p> <hr /> <div></div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7144 Chinchuflin 2015-06-09T02:59:21Z <p>Nvazquez: /* Butia */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> === Butiá ===<br /> <br /> La plataforma Butiá fue utilizada para movilizar al robot siguiendo la línea negra. A su vez, mientras se seguía la línea, el robot era capaz de detectar un árbol con un gato. Para lograr esto, colocamos un sensor de distancia en la parte lateral izquierda del robot, para que pueda detectar al gato. Una vez detectado, el robot debía girar hasta quedar enfrentado al gato, por lo que fue necesario agregar otro sensor de distancia en la parte frontal.<br /> Una vez recogido el gato (mediante el uso del kit Lego), el robot volvía a la línea negra y luego comenzaba a girar hasta quedar enfrentado a la casa donde debía depositar al gato. Nuevamente para lograr enfrentar al robot con la casa, utilizamos el sensor de distancia y avanzamos hasta la casa hasta que nos encontramos a una distancia suficiente, para que se pueda depositar al gato en la casa mediante el uso del kit Lego.<br /> Por último, el robot debía retroceder un poco y girar hasta encontrar la línea negra, con la precondición de que una vez recogido el gato de un árbol, quitaramos el árbol del escenario. Esto último para que el sensor lateral de distancia no detecte nuevamente el mismo árbol.<br /> <br /> === Lego ===<br /> <br /> == Aspectos de integración de los equipos ==<br /> <br /> == Código desarrollado ==<br /> <br /> == Material multimedia ==</div> Nvazquez http://164.73.124.35/inco/proyectos/butia/mediawiki/index.php?title=Chinchuflin&diff=7143 Chinchuflin 2015-06-09T02:47:07Z <p>Nvazquez: /* Trabajo Realizado */</p> <hr /> <div>== Integrantes ==<br /> &lt;b&gt;Butiá&lt;/b&gt;<br /> *Gustavo Di Cesare<br /> *Ernesto Perroux<br /> *Nicolás Vázquez<br /> &lt;b&gt;Lego&lt;/b&gt;<br /> *Federico Mujica<br /> *Agustín Esteche<br /> <br /> == Trabajo Realizado ==<br /> === Butia ===<br /> <br /> <br /> === Lego ===<br /> <br /> == Aspectos de integración de los equipos ==<br /> <br /> == Código desarrollado ==<br /> <br /> == Material multimedia ==</div> Nvazquez