“desarrollo de interfaz para el traslado de un objeto...

“Desarrollo de interfaz para el traslado de un objeto utilizando una celda flexible dentro del plano por

medio de visión artificial”

Trabajo de Titulación presentado en conformidad a los requisitos para obtener el

título de Ingeniero Civil en Informática

Por Cesar Hernaldo Flores Arteaga

Leonardo Andres Ruiz Rodriguez

Profesor Guiá

JUAN CARLOS PARRA Profesor del Departamento de Sistemas

de Información, Facultad de Ciencias Empresariales.

Concepción, 26 de Febrero de 2010

Universidad del Bío-Bío. Sistema de Bibliotecas - Chile

Tabla de Contenidos

Tabla de ContenidosResumen.....................................................................................................................................................1 Agradecimientos ........................................................................................................................................2 Introducción ...............................................................................................................................................4 Contenido...................................................................................................................................................6 1 Presentación del Problema.....................................................................................................................8

1.1 Origen del Tema. ............................................................................................................................8 1.2 Objetivos ........................................................................................................................................9

1.2.1 Objetivo General ....................................................................................................................9 1.2.2 Objetivos Específicos .............................................................................................................9

1.3 Alcances y Limitaciones.................................................................................................................9 1.3.1 Alcances................................................................................................................................10 1.3.2 Limitaciones .........................................................................................................................10

1.4 Hardware y Software a Utilizar....................................................................................................11 1.4.1 Hardware ..............................................................................................................................11 1.4.2 Software................................................................................................................................11

1.5 Presentación del Problema ...........................................................................................................11 1.6 Especificación de Requerimientos ...............................................................................................12

1.6.1 Descripción de Interfaces .....................................................................................................12 1.6.1.1 Interfaz de Usuario........................................................................................................12 1.6.1.2 Interfaz de Hardware ....................................................................................................13 1.6.1.3 Interfaz de Software......................................................................................................13 1.6.1.4 Interfaces de comunicación ..........................................................................................13

1.6.2 Requerimientos Funcionales ................................................................................................14 1.6.3 Requisitos de Rendimiento...................................................................................................14 1.6.4 Requisitos de Desarrollo.......................................................................................................15 1.6.5 Requisitos No Funcionales ...................................................................................................16

1.7 Especificaciones del Área de Trabajo ..........................................................................................16 1.8 Conceptos Relacionados ..............................................................................................................22

1.8.1 ¿Que es Automatización? .....................................................................................................22 1.8.2 ¿Qué es Visión Artificial?.....................................................................................................23 1.8.3 ¿Qué es Inteligencia Artificial? ............................................................................................24 1.8.4 ¿Qué es Visión por Computador?.........................................................................................25 1.8.5 ¿Qué es Dev-C++? ...............................................................................................................26

1.9 Problemas surgidos y dificultades de éste “Capítulo” .................................................................27 2 Tratamiento de Imágenes .....................................................................................................................28

2.1 Presentación del Problema ...........................................................................................................28 2.2 Conceptos Relacionados ..............................................................................................................29

2.2.1 ¿Que es una Imagen?............................................................................................................29 2.2.2 Procesamiento Digital de Imagen.........................................................................................29

2.3 Pasos fundamentales del procesamiento digital de imágenes .....................................................31 2.4 OpenCV........................................................................................................................................33

2.4.1 ¿Qué es OpenCv? .................................................................................................................33


2.4.2 OpenCV Estructura y Contenido..........................................................................................34 2.4.3 ¿Por qué usar OpenCV? .......................................................................................................35

2.5 Pasos a principales en la obtención de características del objeto.................................................36 2.5.1 Algoritmo Meanshift ............................................................................................................36

2.5.1.1 Umbral. .........................................................................................................................37 2.5.1.2 Distancia Espacial.........................................................................................................38 2.5.1.3 Iteraciones.....................................................................................................................40

2.5.2 Binarización de Imágenes.....................................................................................................41 2.5.3 Transformaciones Morfológicas...........................................................................................42

2.5.3.1 Erosionar.......................................................................................................................43 2.5.3.1 Dilatar ...........................................................................................................................46

2.5.4 Centroide ..............................................................................................................................48 2.6 Trabajar OpenCV en Dev-c++ .....................................................................................................49 2.7 Aplicaciones del tratamiento de Imágenes ...................................................................................49 2.8 Diseño...........................................................................................................................................50

2.8.1 Diagrama de flujo de datos...................................................................................................50 2.9 Problemas surgidos y dificultades de éste “Capítulo” .................................................................52

3 Lógica Difusa.......................................................................................................................................54 3.1 Definiciones previas.....................................................................................................................54

3.1.1 Conjuntos Difusos y Grado de pertenencia ..........................................................................54 3.1.2 Valores de Membresía ..........................................................................................................55

3.2 Definición Lógica Difusa.............................................................................................................56 3.3 Esquema Lógica Difusa ...............................................................................................................58

3.3.1 Fuzzificación ........................................................................................................................58 3.3.2 Base de Conocimiento..........................................................................................................58 3.3.3 Inferencia..............................................................................................................................59

3.3.3.1 Mecanismo de Inferencia..............................................................................................59 3.3.3.2 Conectores lógicos entre Antecedentes.........................................................................59

3.3.4 Desfuzzificación ...................................................................................................................60 3.3.4.1 Métodos de Desfuzzificación .......................................................................................60

3.4 Funcionamiento ...........................................................................................................................61 3.5 ¿Por qué Lógica Difusa? .............................................................................................................62 3.6 Como crear un Sistema Difuso Basado en Reglas .......................................................................63 3.7 Matlab...........................................................................................................................................64

3.7.1 Definición .............................................................................................................................64 3.7.2 Uso y aplicaciones................................................................................................................65 3.7.3 Componentes de Matlab .......................................................................................................65

3.7.3.1 Entorno de desarrollo....................................................................................................65 3.7.3.2 La librería de funciones matemáticas Matlab ...............................................................65 3.7.3.3 Gráficos.........................................................................................................................66 3.7.3.4 La interfaz de aplicación Matlab (API) ........................................................................66

3.7.4 Toolboxes..............................................................................................................................66 3.7.5 Simulink ...............................................................................................................................67 3.7.6 Fuzzy ....................................................................................................................................67

3.8 Implementación............................................................................................................................67


3.8.1 Entorno de trabajo Matlab ....................................................................................................67 3.8.2 Entorno de trabajo Fuzzy Logic Toolbox .............................................................................68

3.8.2.1 FIS Editor (Sistema de inferencia Borroso)..................................................................68 3.8.2.2 Variables Lingüísticas ...................................................................................................70 3.8.2.3 Membership Function Editor (Editor de reglas de Pertenencia)...................................71 3.8.2.4 Rule Editor (Editor de Reglas)......................................................................................72 3.8.2.5 Rule Viewer (visualizador de reglas)............................................................................73 3.8.2.6 Guardar y exportar al Workspace .................................................................................74

3.8.3 Entorno de trabajo Simulink.................................................................................................75 3.8.3.1 Simulink Library Browser ............................................................................................75 3.8.3.2 El espacio de trabajo de Simulink.................................................................................77 3.8.3.3 Integración Fuzzy Toolbox y Simulink.........................................................................78

3.8.4 Generación de Código C en Simulink ..................................................................................79 3.9 Diseño e implementación.............................................................................................................83

3.9.1 Diagrama de Bloques ...........................................................................................................83 3.10 Problemas surgidos y dificultades de éste “Capítulo” ...............................................................84

4 Robótica ...............................................................................................................................................85 4.1 Laboratorio de Sistemas Automatizados de Producción CIMUBB .............................................86 4.2 Scorbot – ER V Plus.....................................................................................................................87 4.3 Modos de Operación: ...................................................................................................................90 4.4 Inicialización ................................................................................................................................92 4.5 Operación del Robot.....................................................................................................................93 4.6 Sistemas de coordenadas..............................................................................................................93 4.7 Rol que Cumple el Robot Scorbot ER-V Plus en el Proyecto .....................................................94 4.8 Comunicación Por Puerto Serial ..................................................................................................95 4.9 Comunicación Serial en el Lenguaje de Programación C ...........................................................96 4.10 Monitoreo del Puerto Serial .....................................................................................................106 4.11 Comandos ACL a Utilizar ........................................................................................................112 4.12 Problemas surgidos y dificultades de ésta “Capítulo” .............................................................116

5 Diseño, Integración e Implementación ..............................................................................................118 5.1 Casos de Uso ..............................................................................................................................119 5.2 Diagrama de Secuencias.............................................................................................................125 5.3 Diseño Lógico ...........................................................................................................................128

5.3.1 Diagrama de Flujo de Datos ...............................................................................................128 5.3.1.1 Diccionario de Datos DFD .........................................................................................130 5.3.1.2 DFD Nivel Contexto...................................................................................................131 5.3.1.3 DFD Nivel Superior....................................................................................................132 5.3.1.4 DFD Nivel Detalle del Proceso 1 ...............................................................................133 5.3.1.5 DFD Nivel Detalle del Proceso 2 ...............................................................................142 5.3.1.6 DFD Nivel Detalle Proceso 3 .....................................................................................145 5.3.1.7 DFD Nivel Detalle del Proceso 4 ...............................................................................152 5.3.1.8 DFD Nivel Detalle del Proceso 5 ..............................................................................156 5.3.1.9 DFD Nivel Detalle del Proceso 6 ...............................................................................163

5.4 Integración..................................................................................................................................169 5.4.1 Conversión de Escalas: Píxeles a Décimas de Milímetros.................................................170


5.4.2 Interpretación de los valores entregados por “Lógica Difusa”...........................................177 5.5 Diseño Físico..............................................................................................................................179

5.5.1 QT.......................................................................................................................................180 5.5.2 ¿Que es Qt?.........................................................................................................................180 5.5.3 Estructura de Qt..................................................................................................................182 5.5.4 ¿Por qué usar QT? ..............................................................................................................184 5.5.5 Qt Creator ..........................................................................................................................184 5.5.6 Integración de QT y OpenCV en Dev-c++.........................................................................186 5.5.7 Diagrama de Clases ............................................................................................................187 5.5.8 Diseño Físico de Interfaces ...............................................................................................189

5.6 Problemas surgidos y dificultades de esta “Capítulo” ...............................................................203 Conclusión del Proyecto ........................................................................................................................205 Bibliografía ............................................................................................................................................207


Resumen

1

Resumen

El presente informe contempla los conocimientos básicos y experiencias de cómo se logró

realizar el proyecto de título para la obtención del grado de Ingeniero Civil en Informática. El cual

cumplió los objetivos propuestos, los que fueron lograr la unificación de conocimientos referente a

distintos temas : visión artificial, inteligencia artificial, tratamiento de imágenes implementándolo por

medio de un sistema capaz de manipular una celda flexible, la que mediante la visión que uno obtenga

a través de una cámara web, que vendría siendo el campo de visión que poseemos, se obtendrá un

objeto cilíndrico, el cual estará dentro de unos límites demarcados a priori, producto de esto la celda

flexible podrá proceder a obtener el objeto que se seleccionará gracias al tratamiento de imágenes

realizada previamente para poder identificarlos, por medio del software que se desarrollo.

La forma de interacción con el software es relativamente sencilla siendo de vital importancia el

conocimiento que se tenga en el tratamiento de imágenes, lo que al usuario no le será imposible

utilizarlo sin alguna ayuda al respecto. Mediante la manipulación del software se logrará poder obtener

los centroides de los objetos cilíndricos que se coloquen en el campo de visión establecido, con lo cual

el usuario podrá seleccionar a priori cual de los objetos desea tomar y desplazar, por medio de botones,

lo que capturara la celda flexible, esto pensando en que el sistema puede ser utilizado para obtener

elementos de mucho mayor peso siendo imposible realizarlo con facilidad por una persona, logrando

convertirse en una herramienta potencialmente capaz de transportar objetivos. Es importante destacar

que a partir de la posición en que empieza, la celda generará entre comillas sus propias deducciones y

así decidir hacia donde moverse, siendo un artefacto inanimado podrá llegar hasta el objetivo y poder

obtenerlo, con lo cual el siguiente paso que hará sera depositarlo en algún sitio que el usuario le haya

designado con anterioridad. El logro se obtuvo mediante un arduo trabajo. La investigación y la

metodología que se utilizó de prototipo, mediante lo cual se pudo ir avanzando etapa tras etapa hasta

poder lograr el sistema completo, realizando para ellos el correspondiente análisis y el diseño necesario

para no caer en problemas estructurales que podrían ser fatales durante el desarrollo del Sistema. Como

propuesta se podría dejar el presente proyecto como base para realizar avances en temas como manejo

de profundidad (consideración de la coordenada Z), siendo otro apartado muy interesante a estudiar e

implementar.


Agradecimientos

2

Agradecimientos

Este es el momento para poder expresar nuestros agradecimientos a todas aquellas personas que

de una u otra forma han participado en este proceso tan arduo que nos ha tocado vivir durante estos

años de carrera, en los que hemos vivido diferentes experiencias y conocido a muchas personas y

realizado amistades.

Primero que todo debemos expresar nuestros agradecimientos a quienes nos dieron la vida,

aquellas personas que nos criaron y que lo siguen haciendo aún. Nuestras familias que nos han

entregado su amor incondicional, su compañía, apoyo, muchas gracias por sus consejos y su infinita

comprensión a nuestra ausencia como parte de la familia.

Por otra parte debemos agradecer de manera especial a nuestro profesor Guía Juan Carlos Parra

quien nos brindó su apoyo, consejos y nos dirigió a personas especializadas en ciertos temas, sin lo

cual no pudiésemos haber logrado el proyecto.

Don Cristian Aguilera quien nos brindó parte de su tiempo escuchándonos y dándonos consejos

de como abordar el tema de lógica difusa para el desplazamiento del Scorbot. Gracias por habernos

dejado los conceptos claros.

Don Luis vera quien ha sido la persona que nos ha estado viendo trabajar día a día en el

CIMUBB, quién nos ha brindado su ayuda en todo lo posible, sus conocimientos con respecto al

Scorbot entre muchas otras cosas, incluso la confianza que nos tuvo para poder dejarnos quedar noches

enteras en el laboratorio, por todo esto muchas gracias.


Agradecimientos

3

No podemos dejar de dar las gracias a nuestro grupo de compañeros, que al inicio de esta

carrera sólo éramos un montón de desconocidos, pero que a través de este largo y pedregoso camino se

fueron estableciendo lazos de compañerismo y amistad. Nunca olvidaremos esas mañanas, tardes, días

o noches enteras en que estudiábamos o trabajábamos en grupo, ayudándonos mutuamente para que

todos pudiéramos pasar los ramos y seguir adelante, cada vez que cumplíamos este objetivo la

satisfacción era mucho mayor, ya que todo el esfuerzo entregado en forma colectiva daba sus frutos.

Pero no todo fueron estudios, sino que también compartíamos, nos reíamos, mientras esperábamos la

siguiente clase, así nos olvidábamos por algún rato de nuestros deberes y preocupaciones, Desde luego

gracias compañeros, esperamos que todos sigamos siendo amigos y podamos atesorar estos hermosos

recuerdos para siempre. Gracias, Nelson Pérez, Jorge Vergara, Oscar Demetrio, Robinson Hidalgo.

Debo agradecer especialmente a Paulina Sepúlveda por su apoyo incondicional, ayudando en la

lectura del informe, e ideas para conformar este proyecto además de correcciones ortograficas, muchas

gracias por tu ayuda.

Otra persona que también nos ayudo en un comienzo fue la profesora Yasna Mesa quien

gentilmente nos presto ayuda desinteresada y a quien le agradecemos toda su disposición frente a

nosotros.


Introducción

4

Introducción

El proceso automatizado en la industria es sin duda uno de los aspectos más complicados que

poco a poco han ido interiorizando en las empresas, empezando desde un primer momento a

automatizar procesos simples, desde estableciendo pautas a seguir cada vez que se quiera ejecutar

alguna acción hasta realizar los procesos automáticos mediante infraestructura especializada y distintos

agentes automatizados que prestan ayudan importantes, es dentro de este marco que el CIMUBB de la

universidad del Bío-Bío nos proporciona una infraestructura capaz de utilizar Computadores para

Integrar una Empresa de Manufactura acorde a la infraestructura que existe. Dentro de este se

encuentran celdas flexibles que son capases de emular de cierto modo el brazo de una persona,

teniendo como lenguaje base ACL.

Nosotros como estudiantes de la Universidad del Bio Bio hemos vivido experiencias en el

laboratorio, pero siempre limitada a ciertos aspectos restrictivos, es por ello que nace la idea de poder

manejar esta celdas flexibles por medio de un sistema el cual sera capaz de proporcionarnos lo

necesario para poder interactuar con la superficie de trabajo que se desea, mediante la visión que nos

proporcione una cámara web, en este punto ya se están mezclando diferentes conceptos los cuales van

desde la visión por computadora, inteligencia artificial y el tratamiento de imágenes, todos temas de

peso e muy interesantes, siendo aplicaciones de ellos Mobile Eye, el cual mediante visión por

computadora incorporada a un vehículo es capaz de detectar personas y la distancias que hay desde al

auto a distintos objeto, siendo esto una tecnología de punta establecido hace poco tiempo, siendo

tecnologías de vanguardia. Siguiendo ésta línea se nos ocurre la investigación de estos temas

relacionados deseando aplicarlos de alguna manera para poder dejar un precedente y de marcar un

camino para futuras aplicaciones que se puedan lograr utilizando como base o aprendizaje el presente

proyecto de título.

La utilización del CIMUBB, la infraestructura existente nos permite potenciar lo que deseamos

a través de sus celdas flexibles, constituyendo un desafío el obtener un objeto cilíndrico que se pueda

detectar dentro de un campo de visión, siendo ya importante que se pueda implementar en este


Introducción

5

laboratorio, pudiendo experimentar la tecnología de punta que se maneja en este lugar.

Para poder realizar esta investigación práctica se necesitará de un estudio acabado en el tema y de la

guía necesaria para poder tener bases sólidas, como en qué lenguaje poder programarlo además estudiar

como incorporarlo a la infraestructura que ya existe presente en el lugar. Todos estos desafíos serán

expuestos en los siguientes capítulos que comprenderán módulos de funcionamiento autónomo, los

cuales serán integrados finalmente logrando el sistema completo.


Contenido

6

Contenido

El contenido del proyecto de título que se presenta se ha presentado de la siguiente forma:

A lo largo del primer Capítulo se tratará la Presentación del Problema, como ya se ha

expresado, ésta es el capítulo introductorio para poder darse a entender que se va a realizar, porque se

va a realizar y como se va a realizar el presente informe de proyecto de título.

En el Segundo Capítulo se explicará el Tratamiento de las imágenes, describiéndose los

aspectos referentes a obtención y manipulación de imágenes, la realización de ciertos filtros y

obtención de información a partir de ella, por lo cual se dará sus respectivos preámbulos y detalles que

se consideren relevantes, lo cual servirá para poder detectar objetos que serán de interés para poder

capturarlo posteriormente con la celda flexible.

El Tercer Capítulo tratará el tema correspondiente a Lógica Difusa, ese tema presentará

fundamentos de lógica en la computación, el cómo se le puede intentar dar un cierto grado de

conocimiento a la computadora y que ésta pueda tomar entre comillas decisiones propias basándose en

ciertas reglas preestablecido de antemano, para de ésta manera lograr decidir hacia que punto moverse

la celda flexible, que está en una posición predefinida. También se establecerán las formas de cómo

utilizar el Toolbox de Matlab de lógica difusa además de un breve vistazo a Simulink.

El Cuarto Capítulo corresponderá a la Conexión con el Scorbot ER-V Plus, dando a conocer

aquellas formas en donde se le enviarán instrucciones de movimientos para poder desplazarse dentro de

un campo de visión establecido mediante las conexiones con la celda flexible con lo cual se podrá

capturar el objeto.


Contenido

7

El Quinto y último Capítulo corresponde al Desarrollo de la Aplicación. Hoy en día las

interfaces son indispensables para el manejo de cualquier programa, por lo cual se pretende mostrar

por medio de qué lenguaje de programación se realizará, el por qué se tomó esa decisión, su

portabilidad y otros aspectos a descubrir que influirán en el proyecto. Mientras que por otro lado en

este capítulo se expondrá todo el proceso involucrado en la Integración, estableciéndose este apartado

como un nexo entre las distintos capítulos nombradas anteriormente, esto debido a que cada parte se

trató como un módulo diferente, con lo cual la consolidación se establecerá al unir distintos tipos de

programaciones e ideas concluyendo así la finalización del proyecto, para esto se explicaran los

problemas y resultados que se obtuvieron en el vínculo de todos estos temas.


Capítulo 1: Presentación del Problema

8

1 Presentación del Problema

El presente capítulo pretende ser un primera aproximación al tema a tratar, dando a conocer

ideas y conceptos que son relevantes para su interiorización, se pretende dejar en claro qué es y cómo

se realizará el proyecto dejando bien marcado cuales son sus alcances y limitaciones a través del área

de trabajo.

1.1 Origen del Tema.

Los procesos automatizados son cada vez mas importantes dentro de las industrias modernas,

permitiendo realizar procesos reiterativos en forma organizada y programada con anticipación,

aplicándose a tareas de tipo reiterativas lo cual permitiría agilizarlas.

El tratamiento de imágenes, como es el caso de programas de estilos mas conservadores como

“Paint” que viene en los sistemas operativos de tipo Windows o aquellos que son mas sofisticados tal

es el caso de Photoshop o Gimp de los cuales se pueden jugar con los colores, incorporarle imágenes o

aplicarle distintos tipos de efectos, filtros, etc. que trasformarán nuestra imagen, según nuestra

imaginación, siendo esto un estímulo importante en lo que se refiere a transformar imágenes, siendo

esto mas visto como una decoración o diseño. Desde este punto no es tan impactante como tratamiento

de imágenes reales en medicina para encontrar tumores en radiografías por ejemplo, u otro tratamiento

de imágenes.

Modernos software's de reconocimientos faciales como es el caso de las cámaras digitales que

detectan las sonrisas,como es el caso de la “Sony Cybershot Smile Shutter” en las cuales mediante un

escaneo de los rostros de la mayoría de las personas cuando sonríen capturan la imagen, demostrando

la potencialidades que se pueden lograr utilizando una cámara.



9

1.2 Objetivos

1.2.1 Objetivo General

Tomar un objeto cilíndrico con un celda flexible dentro de un plano determinado a partir de las

coordenadas obtenidas mediante visión artificial y desplazarlo, implementándolo en el laboratorio

CIMUBB de la Universidad del Bío-Bío.

1.2.2 Objetivos Específicos

1. Desarrollo de algoritmo capaz de identificar objetos dentro de un campo de visión determinado

apoyando el desarrollo de la aplicación.

2. Identificar las coordenadas de posicionamiento del objeto dentro del campo de visión

(coordenadas espaciales) mediante la creación de un algoritmo.

3. Aprender a utilizar el manejo de la celda flexible Scorbot ER-V Plus (celda flexible).

4. Diseñar modulo para identificar la posición de destino del objeto.

5. Implementar un algoritmo mediante lógica difusa que permita el encaminamiento del Scorbot

hasta tomar el objeto seleccionado.

6. Permitir la integración de los algoritmos anteriores en una aplicación.



10

1.3 Alcances y Limitaciones

1.3.1 Alcances

• El sistema permitirá al usuario seleccionar en cualquier instante, mientras muestre lo que está

ocurriendo dentro del campo de visión (luego de iniciar el sistema), tomar una foto de lo que se

desee analizar.

• El sistema permitirá seleccionar objetos que se encuentren dentro del área delimitada a la

captura de los objetos.

• El sistema mostrará un área mayor a lo posibilitado por el Scorbot para capturar el objeto, esto

debido a que una persona a pesar que no pueda acceder a ciertas partes por cualquier

eventualidad si es posible que visualice dicho sector.

• El sistema capturara objetos cilíndricos establecidos posteriormente en el área de trabajo.

• El campo de visión es estática y se encuentra por encima del Scorbot.

• El Scorbot antes de iniciar su desplazamiento hasta el objeto se ubicará por encima del centro

del campo de visión y en una posición preestablecida.

• Para llegar hasta el objeto el Scorbot se irá desplazando por medio de lógica difusa y a una

altura por encima de cualquier objeto, sin desplazamiento en eje Z (altura), solamente X e Y

(cartesianos).

• La rutina de depositar el objeto una vez obtenida, no corresponde a lógica difusa.



11

1.3.2 Limitaciones

• La calibración de la cámara no es exacta debido al constante movimiento que sufre, ya sea por

personas externas o por el propio movimiento generado por el Scorbot.

• Los objetos que se encuentren tocando algún borde que corresponda a los limites establecidos

no sera posible seleccionarlo al momento de elegir un objeto.

• La identificación de el o los objetos dependerá de la correcta utilización del sistema en el

capítulo de análisis de la imagen correspondiente a la binarización que aplique, ya sea en su

parte normal o inversa.

• Los cilindros a colocar, estarán puestos sobre su base y no se apilaran cilindros uno encima de

otro.

1.4 Hardware y Software a Utilizar

1.4.1 Hardware

• Intel Core 2 Duo CPU 1.86GHz, 1GB de RAM

• Web Microsoft LifeCam

• Scorbot ER-V Plus

1.4.2 Software

• Windows XP Profesional Service Pack 3

• ATS

• Free Serial

• Matlab y Simulink



12

1.5 Presentación del Problema

El logro de poder capturar un objeto dentro de un campo de visión delimitado y dejarlo en una

posición distinta del campo de visión, mediante un Scorbot ER-V Plus implica distintos desafíos,

siendo la obtención y ubicación espacial dentro del campo de visión uno de los desafíos; además de

poder interpretar de una manera correcta esa información capturada por medio de una cámara web,

para así poder obtener las coordenadas de un objeto, por otra parte se encuentra el desafío de poder

interactuar con la celda flexible para que se mueva y de una u otra forma darle un cierto poder de

razonamiento para dirimir como lograr llegar hasta el objetivo, este es la primera impresión del

problema, lo cual va a ser segmentado en diferentes partes, para poder atacar distintos problemas, esto

debido a que la planificación que tenemos presente es de ciclos iterativos de desarrollo.

1.6 Especificación de Requerimientos

Esta sección define los requerimientos que han de ser satisfechos por el sistema. Se debe dejar

en claro que los requisitos acá descritos se obtuvieron de la conversaciones que entablamos con el

profesor guía Juan Carlos Parra, el señor Cristian aguilera y Don Luis Vergara, quienes nos apoyaron

en el proceso del desarrollo del presente proyecto y quienes escribieron este informe, esto pues el

sistema nace de una investigación por mezclar diferentes tipos de procedimientos que se describirán

más adelante, es por ello que no hay una persona que haya requerido el sistema como tal.

1.6.1 Descripción de Interfaces

1.6.1.1 Interfaz de Usuario

El sistema se basa en el uso de pantallas que mostrarán los procesos a realizar en el tratamiento

de la imagen que va a ir generando el usuario, siendo importante la flexibilidad que posee la sección de



13

la binarización, esto porque la interfaz posibilita al usuario para realizar una infinidad de mezclas de

umbrales para poder obtener los objetos, esto mediante sliders, botones de siguiente y realización de

algoritmos como meanshift, a demás la interfaz incorpora el uso del mouse refiriéndose al aspecto de

hacer click en una sección de una imagen, siendo esto de gran utilidad en la selección del objeto,

siendo importante destacar que si un objeto no es seleccionado la acción no se realizará, otro aspecto

son las alertas que se encuentras en ciertos puntos del sistema para darnos la posibilidad de retractarnos

de una acción dada facilitando de esta forma la interacción con el sistema.

1.6.1.2 Interfaz de Hardware

Se ha definido la implementación de una cámara web que servirá de soporte para la obtención

de una imagen de la superficie donde se encuentran los objetos, además para tomar el objeto se necesita

de la utilización del brazo robótico Scorbot ER-V Plus y para realizar estas acciones es necesario el

correcto funcionamiento del sistema en el computador.

1.6.1.3 Interfaz de Software

Este sistema efectúa una interacción con un sistema software externo que controla la

comunicación serial con el puerto siendo programado con este propósito para poder interactuar con el

Scorbot, además el software contiene la maquina de lógica difusa.

Es importante mencionar que el sistema actual no interactúa con la red de Internet.

1.6.1.4 Interfaces de comunicación

Se utilizará una comunicación serial con la celda flexible RS-232(instalada al mismo

computador donde se encuentra el sistema) , también se conecta la cámara web al puerto USB 2.0.



14

1.6.2 Requerimientos Funcionales

1. Ser capaz de obtener objetos mediante la manipulación parcial de tratamientos en la imagen

2. Calcular centroides de objetos analizados

3. Al seleccionar captura Imagen en el menú principal podemos obtener la señal de video desde la

cámara web, de lo que está sucediendo en la superficie donde se encuentran los objetos.

4. A partir del video recibido se captura una imagen de él, para ser posteriormente procesada.

5. Poder obtener una vista de los objetos mostrándose los que se puedan seleccionar de una forma

diferente.

6. Seleccionar un objeto haciendo click sobre éste.

7. Seleccionar posición destino haciendo un click sobre el área de trabajo mostrada como imagen

en el sistema

8. Ser capaz de realizar click sobre la imagen y saber si se está dentro de el área que se establece o

fuera de ella

1.6.3 Requisitos de Rendimiento

1. Dado el área de trabajo seleccionado se considera que el tiempo de respuesta en acciones

críticas como realizar el algoritmo de meanshift no supere un segundo.

2. El tiempo de desplazamiento hasta el momento de obtención del Scorbot sera variable esto

debido al camino que piense entre comillas el sistema para llegar al objeto, ocupando la lógica

que se le aplica al llegar a posicionarse encima del objeto.



15

1.6.4 Requisitos de Desarrollo

El ciclo de vida elegido para desarrollar el producto será el de prototipo, debido a que se va a

realizar una aplicación compleja, grande y con alto grado de error. Por medio de los patrones se irán

construyendo fases por separado del proyecto las cuales serán establecidas y explicadas a lo largo del

presente informe, para ir avanzando y viendo como se van comportando cada uno de las fases por

medio de este modelo de prototipado obtendremos una base para llegar al resultado final del proyecto,

sin que esto se vea mermado por un error en alguna parte del desarrollo anterior pues como ya se

mencionó cada sección constituye una especie de sub-sistema, con lo que se harán pruebas

correspondientes a cada módulo, logrando identificar posibles fallas en la programación u lógica que

exista detrás haciendo posible la construcción de bases sólidas, no siendo estas un problema al

momento del siguiente avance. Con respecto a esto, es un riesgo el involucrarse e investigar o

implementar nuevas tecnologías, más aún siendo temas como el presente, por un lado de visión

artificial y por otro la manipulación de celdas flexibles, mas allá de simples pinceladas de

conocimientos teóricos al respecto, es por esto que el diseño a emplear nos va a ser de utilidad, debido

a que no se cuenta con mucha experiencia en esta área.

Otro punto importante es que mediante esta técnica vamos a tener una constante participación

con las personas expertas involucradas en el proyecto, siendo ellas nuestro profesor guía Juan Carlos

Parra que nos guío durante todo el proceso dándonos ideas y llevándonos a personas mas

especializadas en ciertos temas como, el Señor Cristian Aguilera quién nos dió un buen enfoque en lo

que se refiere a lógica difusa y Don Luis Vera quién nos prestaba ayuda en distintos aspecto del robot

Scorbot, permitiéndonos esto tener una mayor seguridad en que los requerimientos establecidos no

vayan a ser mal entendidos ni que nos salgamos del camino a seguir, también se nos facilitó la rapidez

del desarrollo, aprendizaje y uso de los sistemas esto gracias a constantes comunicaciones establecidas

con las personas vinculadas al tema en cuestión, en los momentos necesarios pre-establecidos en el

proyecto en si.



16

1.6.5 Requisitos No Funcionales

1. El sistema será implementado en Qt incorporándolo con OpenCV siendo el lenguaje padre

C/C++

2. El sistema tendrá que poseer una interfaz amigable para el usuario, debiendo tener cierto

entendimiento en el tema para su correcta utilización, debido a la complejidad de los conceptos

relacionados en éste.

1.7 Especificaciones del Área de Trabajo

Para el desarrollo de nuestro Tema fue necesario contar con el apoyo de los Profesores y la

infraestructura que nos brindó el laboratorio de sistemas automatizados de producción CIMUBB, con

el que cuenta la facultad de Ingeniería de nuestra Universidad. En él nos facilitaron una estación de

trabajo, compuesta a grandes rasgos por un Robot Scorbot ER-V Plus, un computador al cual va

conectado el Scorbot y una cámara Web, además del soporte a cargo del ingeniero del CIMUBB Don

Luis Vera, a continuación en la Figura 0-1 se aprecia el área de trabajo.



17

Figura 0-1: Área de Trabajo, laboratorio CIMUBB.

Una vez presentado el ambiente de trabajo se procederá a realizar una descripción mas detallada

de los componentes que la conforman, acompañado de imágenes explicativas para dar una mayor

compresión, por ello en la Figura 0-2 se detallan los componentes de la estación de trabajo.



18

Figura 0-2: Componentes del área de trabajo.

Descripción:

Se identifica al Robot Scorbot ER-V Plus, ésta celda flexible es la utilizada para tomar el objeto

una vez analizada previamente la imagen capturada por la cámara web, éste análisis corresponde a la

detección de objetos dentro de la superficie de alcance del robot.

Corresponde al computador que se ocupó para la realización del proyecto, a el van

conectados el robot Scorbot ER-V Plus a través del puerto serial RS-232 y la cámara Web por medio



19

de USB 2.0, en este equipo es donde se monta la aplicación creada en el proyecto, que maneja tanto al

robot como a la cámara. Las especificaciones técnicas del computador son las siguientes:

Sistema: Windows XP Profesional Service Pack 3

Equipo : Intel Core 2 Duo CPU 1.86GHz, 1GB de RAM

Muestra la cámara Web Microsoft LifeCam VX-6000 (ver Figura 0-3), esta emite video de una

resolución de 640x480 píxeles, del cual tomamos una imagen del área de alcance del Robot Scorbot

donde se encuentran situados los objetos, para ser analizada por el programa diseñado. La cámara se

encuentra situada en una barra de aluminio a una altura de 77,5 centímetros de la superficie donde se

encuentran los objetos, la cual esta enfocando hacia abajo, para poder de esta manera realizar una toma

completa de la superficie, como ejemplo de la toma se sitúa la Figura 0-4.

Figura 0-3: Cámara Web Microsoft LifeCam VX-6000.



20

Figura 0-4: Imagen tomada de la superficie, por la cámara.

Determina la barra de aluminio en la cual va montada la cámara web, esta tiene un grosor de 1.5

cm. y una altura total de 1,57 metros hasta el piso, podemos ver con más detalle las dimensiones y la

forma de la barra en la Figura 0-2. Como vemos tiene forma de “L invertida” debido a la posición

que debe llevar la cámara web en el espacio de trabajo. Todas las dimensiones están acordes para que

no interfieran en el funcionamiento del Scorbot.

Identifica a la superficie donde se encontrarán los objetos que podrá seleccionar el robot Scorbot,

se escogió esta superficie pensando en las posiciones del sistema cartesiano con el que cuenta la celda

flexible, debido a que se debe tomar como límite el radio de alcance del robot (ver Figura 0-6), además

debemos coordinar que esta superficie esté enfocada correctamente por la cámara web. En la Figura 0-

5 se señala la superficie que se utilizara en las pruebas.



21

Figura 0-5: Superficie donde se encontraran los objetos a seleccionar (Dimensión: 26 x 26 cm.).

Figura 0-6: Limites del área de trabajo

Representa a la superficie que esta disponible en el área de trabajo, pero por efectos de esta

investigación no se ocupará como base para dejar los objetos a seleccionar, debido a que la cámara en

su ubicación actual no alcanza a tener una completa visión de esa área.



22

Corresponde a uno de los objetos que será tomado por el Robot Scorbot ER-V Plus, es un cilindro

de 3,5cm de diámetro y 2,8cm de alto (Ver Figura 0-7), cabe mencionar que serán objetos de estas

características los que se podrán seleccionar, debido a la forma y las dimensiones de la pinza del

Scorbot.

Figura 0-7: Cilindro

Muestra la mesa de trabajo donde se encuentra situado el robot Scorbot, por lo tanto es la

superficie donde están los objetos que serán seleccionados, ésta posee una dimensión de 90cm de largo

y 90cm de ancho, con una altura de 77cm, como se puede apreciar en la Figura 0-2.

1.8 Conceptos Relacionados

Este apartado hace referencia a ciertos aspectos que se piensa que son relevantes para

cualquiera que desee leer el presente proyecto de título, refiérase a esto como pinceladas de un tema

que se profundizara en cada una de sus capítulos presentes a lo largo de este documento.

1.8.1 ¿Que es Automatización?

Automatización es la tecnología referida al uso de sistemas mecánicos, eléctricos y

computarizados para operar y controlar la producción(Groover, 1980), un ejemplo es la producción

automática de envases plásticos de bebidas.



23

Groover, indica que existen básicamente 3 tipos de automatización:

I. Automatización Rígida, se caracteriza por realizar procesos de producción de gran volumen

conllevando una gran velocidad en el desarrollo de la producción, siguiendo siempre un

esquema predefinido, por lo cual resulta mas sencillo de implementar. Debido a esta rigidez se

ve dificultado el querer cambiar el esquema predefinido, por ejemplo querer añadir una nueva

máquina a la producción de un producto X.

II. Automatización Programable, esto viene siendo el aspecto contrario al anteriormente

mencionado, siendo los sistemas que se encuentran dotados de equipos con una gran posibilidad

de ser configurados, siendo capaces de tomar decisiones basados en ciertas pautas o valores

introducidos por un operador.

III. Automatización Flexible, es una extensión de la programación programada diferenciándose en

su capacidad para cambiar parte de los programas o disposiciones físicas, sin perder tiempo de

producción.

1.8.2 ¿Qué es Visión Artificial?

Visión Artificial es el conjunto de técnicas que permiten la obtención de información por

métodos ópticos, tanto de manera automática como asistidas por un operador.

Este conjunto heterogéneo de técnicas incluye iluminación, captación de imagen, digitalización

de la misma, pre procesamiento o acondicionamiento, procesamiento y comunicación de los resultados.

Aspectos que serán expuestos posteriormente.

En algunos procesamientos se emplean algoritmos asimilables a Inteligencia Artificial (redes

neuronales, sistemas basados en reglas, clasificadores, etc.), pero son minoritarios frente a

procesamientos específicos que van desde la medida de distancia en pixeles o el contar de los mismos

hasta tratamientos en el dominio de la frecuencia.



24

1.8.3 ¿Qué es Inteligencia Artificial?

Se denomina inteligencia artificial a la rama de la ciencia informática dedicada al desarrollo de

agentes racionales no vivos.

Para explicar la definición anterior, entiéndase a un agente como cualquier cosa capaz de

percibir su entorno (recibir entradas), procesar tales percepciones y actuar en su entorno (proporcionar

salidas), y entiéndase a la racionalidad como la característica que posee una elección de ser correcta,

más específicamente, de tender a maximizar un resultado esperado (este concepto de racionalidad es

más general y por ello más adecuado que inteligencia para definir la naturaleza del objetivo de esta

disciplina).

Por lo tanto, y de manera más específica la inteligencia artificial es la disciplina que se encarga

de construir procesos que al ser ejecutados sobre una arquitectura física producen acciones o resultados

que maximizan una medida de rendimiento determinada, basándose en la secuencia de entradas

percibidas y en el conocimiento almacenado en tal arquitectura.

Existen distintos tipos de conocimiento y medios de representación del conocimiento. El cual

puede ser cargado en el agente por su diseñador o puede ser aprendido por el mismo agente utilizando

técnicas de aprendizaje.

También se distinguen varios tipos de procesos válidos para obtener resultados racionales, que

determinan el tipo de agente inteligente. De más simples a más complejos, los cinco principales tipos

de procesos son:



25

• Ejecución de una respuesta predeterminada por cada entrada (análogas a actos reflejos en seres

vivos).

• Búsqueda del estado requerido en el conjunto de los estados producidos por las acciones

posibles.

• Algoritmos genéticos (análogo al proceso de evolución de las cadenas de ADN).

• Redes neuronales artificiales (análogo al funcionamiento físico del cerebro de animales y

humanos).

• Razonamiento mediante una lógica formal (análogo al pensamiento abstracto humano).

También existen distintos tipos de percepciones y acciones, pueden ser obtenidas y producidas,

respectivamente por sensores físicos y sensores mecánicos en máquinas, pulsos eléctricos u ópticos en

computadoras, tanto como por entradas y salidas de bits de un software y su entorno software.

Varios ejemplos se encuentran en el área de control de sistemas, planificación automática, la

habilidad de responder a diagnósticos y a consultas de los consumidores, reconocimiento de escritura,

reconocimiento del habla y reconocimiento de patrones. Los sistemas de IA actualmente son parte de la

rutina en campos como economía, medicina, ingeniería y la milicia, y se ha usado en gran variedad de

aplicaciones de software, juegos de estrategia como ajedrez de computador y otros videojuegos.

1.8.4 ¿Qué es Visión por Computador?

Visión por computador es la ciencia y la tecnología de las máquinas que ven. Como una

disciplina científica, la visión por computador se refiere a la teoría para la construcción de sistemas

artificiales que obtengan información de las imágenes. Los datos de imagen puede tomar muchas

formas, como una secuencia de video, puntos de vista de varias cámaras, o datos multidimensionales

desde un escáner médico.

Como disciplina tecnológica, la visión por ordenador trata de aplicar sus teorías y modelos para



26

la construcción de sistemas de visión por computador. Ejemplos de aplicaciones de visión artificial son

los sistemas para:

*Control de procesos (por ejemplo, un robot industrial o un vehículo autónomo).

*Detección de eventos (por ejemplo, para la vigilancia visual en caso de objetos abandonados o

de conteo de personas).

Organizar la información (por ejemplo, para bases de datos de indexación de imágenes y

secuencias de imágenes).

*Modelado de objetos o entornos (por ejemplo, la industria de inspección, análisis de imágenes

médicas o el modelado topográfico).

*Interacción (por ejemplo, como la entrada de un dispositivo para la computadora la interacción

humana).

Visión por Computador también se puede describir como un complemento (pero no

necesariamente lo contrario) de la visión biológica. En la visión biológica, la percepción visual de los

seres humanos y los animales se estudian diferentes, dando lugar a modelos de cómo funcionan estos

sistemas en términos de procesos fisiológicos. Visión por ordenador, por otro lado, los estudios y se

describen los sistemas de visión artificial que se implementan en software y/o hardware. El intercambio

interdisciplinario entre lo biológico y la visión por ordenador ha demostrado ser cada vez más fructífera

para ambos campos.

1.8.5 ¿Qué es Dev-C++? Dev-C++ nos entrega un completo IDE (entorno de desarrollo integrado) implementado en

Delphi de Borland, que es utilizado para la programación en C y C++. Este posee un compilador

llamado MinGW (compilador basado en GCC) que se instala conjuntamente y es totalmente

transparente para el usuario. Con el podemos crear ejecutables Win32, GUI o así como DLLs y

librerías estáticas. Posee debugging integrado, administrador de proyectos, soporta plantillas para crear

nuestros propios tipos de proyectos, class browser entre otras funcionalidades. Y no podemos dejar de



27

mencionar que Dev-C++ es distribuido gratuitamente por www.Bloodshed.net

Dev-C++ se utilizara pues nos servira para poder integrar los diferentes componentes en el cual

desarrollaremos la aplicación, todo esto se vera a fondo en el 5

1.9 Problemas surgidos y dificultades de éste “Capítulo”

Debido a que este es el entendimiento del sistema, las dificultades principales correspondieron

a los requerimientos del sistema, en como abordarlo y de que manera integraros temas entre comillas

diferentes y poder de una u otra manera hacerlos interactuar para formar un sistemas que permitirá

concretar la investigación que se realizo sobre los puntos principales ya expuestos.

El tiempo invertido en la recolección de datos fue esencial, hay que destacar que en internet y en

libros y publicaciones hay bastante información de tipo teórica sobre como tratar imágenes, sobre el

manejo de una celda flexible, inteligencia artificial, de la declaración de lenguaje ACL (utilizado para

la comunicación con el scorbot). Es claro que hay pinceladas al respecto de ciertos ejemplo, pero nada

concreto de lo cual uno pudiese tomar como base, siendo esto un reto de manera tal que nos incentivara

a seguir investigando y buscar las maneras de como realizar nuestro objetivo, siendo otro punto

importante el descubrir la compatibilidad que existiese entre las decisiones tomadas para cada una de

las que constituyeron nuestro proyecto de titulo.


Capítulo 2: Tratamiento de Imágenes

28

2 Tratamiento de Imágenes

La vista es el sentido mas avanzado que poseemos siendo las imágenes las que juegan un papel

importante en la percepción que tenemos.

Las personas tenemos como limitante la banda visible del espectro electromagnético (EM), pero

no así las maquinas quienes pueden percibir prácticamente el espectro completo, desde los rayos gama

hasta las ondas de radio, es por esto la importancia que hay al tratar imagen por medio de las

computadoras, cuya exactitud es superior a nuestros alcances.

En este se dará a conocer las distintas procesos que se le aplicarán a una imagen para poder

obtener información de ella, la que va a ser de utilidad para poder posteriormente obtener las

coordenadas de los objetos en pixeles, este proceso implica tener un entendimiento acabado en el tema

de las imágenes, lo cual sera abordado posteriormente. Se explicarán los diferentes procedimientos

realizados a la imagen además de nombrar el lenguaje que se utilizará para poder realizar este módulo.

2.1 Presentación del Problema

La obtención de información referente al temas es abundante, pero el tratamiento de

información por medio de lenguajes viene siendo mas recatada. Se investigó, se analizó que se podían

tratar imágenes por medio de librerías adicionales como GD de PHP, pero el tratamiento de ello era

algo simplón, no a la altura de algo mas experimentado como la biblioteca de visión artificial openCV

la cual se decidió ocupar.

Además de esto se tuvo que profundizar en temas referente al tratamiento de imágenes, el

filtrado de imágenes, máscaras y otros conceptos que eran nuevos, para nuestro entender.



29

Como primera etapa se propuso la obtención de un objeto dentro de una imagen, además de sus

coordenadas, mediante distintos tratamientos de la imagen explicados más adelante en éste capítulo.

Todo esto mediante la librería openCV cuya sintaxis de lenguaje de programación es parecida a C /

C++.

2.2 Conceptos Relacionados

Este apartado hace referencia a aspectos que son preliminares para poder entender a que se

refiere con la manipulación de las imágenes mostrando conceptos relacionados con el presente

capítulo.

2.2.1 ¿Que es una Imagen?

Una imagen puede ser definida matemáticamente como una función bidimensional, f(x,y),

donde x e y son coordenadas espaciales en un plano y f en cualquier par de coordenadas es la

intensidad o nivel de gris de la imagen en esa coordenada, al momento en que x e y, y los valores de f

son todas cantidades finitas, discretas, se puede decir que la imagen es una Imagen Digital. Esta se

compone de una cantidad finita de elementos, cada uno con un lugar y un color especifico, cada uno de

estos elementos se les llama pixel, esto quiere decir que si una imagen posee una resolución de 300 x

200, la cantidad de pixeles que se encuentra en ella por fila es de 300 y por columna es de 200 con lo

que hace un total de 60000 pixeles los cuales componen la imagen

2.2.2 Procesamiento Digital de Imagen.

Son todos aquellos procesos que se llevan acabo con una computadora, aquellos cuya entrada y

salida son imágenes además de aquellos procesos que extraen atributos a las imágenes, incluyendo el

reconocimiento de objetos individuales



30

Tipos de Procesos:

I. Procesos de Bajo Nivel, Utilizan operaciones como el pre procesamiento de imagen para

reducir el ruido, mejora del contraste, y filtros de enfoque, para de este modo generar otros tipos

de imágenes, por ejemplo lograr que una imagen sea mas clara en el caso de imágenes tomadas

con escasa luz.

Se caracterizan porque sus entradas son imágenes y sus salidas también.

II. Procesos de Nivel Medio, Operaciones como segmentación y clasificación de objetos

individuales.

Se caracterizan porque sus entradas son generalmente imágenes, pero sus salidas son atributos

extraídos de esas imágenes, ejemplo de ello es la obtención de contornos, bordes, identidad de objetos

individuales.

III. Procesos de Alto Nivel, Implica el obtener algún significado de un conjunto de objetos

reconocidos mediante análisis de imagen y finalmente realizar las funciones cognitivas

asociadas con la vista, esto se refiere a como las personas le dan una interpretación a las señales

de tránsito, siendo una imagen nosotros al reconocerla le damos un significado y realizamos una

acción asociada a ella.

Un ejemplo de tratamiento de imagen al ver distintas banderas de distintos países sería: los

procesos de adquisición de la imagen del área que contiene a la bandera, el pre procesamiento de la

imagen, la extracción (segmentación) de banderas individuales, la descripción de los componente de la

bandera de una forma aceptable para el procesamiento computacional, y el reconocimiento de cada

parte individual que compone la bandera o identificar que bandera es, entra ya en el campo de Visión

por computador.



31

2.3 Pasos fundamentales del procesamiento digital de imágenes

Las partes fundamentales del procesamiento digital de imágenes en forma general son las

siguientes, no siendo siempre necesario seguirlas todas o en el mismo orden, eso va a depender de que

sea lo que se necesite procesar, es decir, cual sea el problema en si.

1) Adquisición de imágenes

Generalmente incluye pre procesamiento. Consistiendo en reducir la información en la misma, de

modo que pueda ser interpretada por medio de una computadora.

2) Mejora de la imagen

La idea de este paso es obtener detalles sean o no a simple vista que no se percatan perfectamente, o

simplemente recalcar ciertas características que son de nuestro interés. Logrando de esta forma que la

imagen procesada se vea mejor.

3) Restauración de la imagen.

Produce una mejora de la apariencia de la imagen, a diferencia de la mejora de la imagen, subjetiva, la

restauración es objetiva, en el sentido en que las técnicas de restauración tienden a ser modelos

probabilísticos o matemáticos de degradación de la imagen , esto quiere decir, que una imagen que no

se veía nítida producto de ruido externo, aplicando la restauración a la imagen obtenemos dicha imagen

como es originalmente sin el ruido causado por algún agente externo.

4) Procesamiento del color.

Procesamientos especiales para el color ya sea en RGB, HSL u otro modelo de color.

RGB,es un modelo de color que representa los colores como combinaciones de rojo, verde y azul, es el

modelo mas utilizado para visualizar y trabajar con imágenes digitales.

HSL,es un modelo de color que representa los colores por medio de su Tonalidad, de su Saturación y su

Luminosidad. El modelo HSL se representa gráficamente como un cono doble o un doble hexágono.

Los dos vértices en el modelo HSL se corresponden con el blanco y el negro, el ángulo se corresponde

con la tonalidad, la distancia al eje con la saturación y la distancia al eje blanco-negro se corresponde a



32

la luminancia.

5) Ondeletas

Fundamentalmente utilizadas para representar imágenes en varios grados de resolución. Se utiliza

principalmente en compresión.

6) Compresión

Reduce el almacenamiento requerido para guardar una imagen, o el ancho de banda para transmitirla,

un ejemplo de esto es la imágenes que se guardan en formato .jpg, este es una extensión de imagen que

ocupa un algoritmo de compresión para poder dejar la imagen en un peso menor al de la extensión

origina comparándola por ejemplo con una extensión .bmp que es más pesada y conserva muchos

detalles de la imagen.

7) Procesamiento morfológico

Es una herramientas para extraer componentes de la imagen útiles para la representación y descripción

de formas.

8) Segmentación

Divide una imagen en sus partes constituyentes.

9) Representación y descripción.

Acá se toman decisiones tales como si la forma obtenida debe ser tratada como un frontera o una

región, además de extrae atributos que resultan en información de interés.



33

2.4 OpenCV

2.4.1 ¿Qué es OpenCv?

OpenCV es una biblioteca libre de visión artificial originalmente desarrollada por Intel.

Ejemplos de sistemas desarrollados con openCV son sistemas de seguridad con detección de

movimiento, aplicaciones de control de procesos donde se requiere reconocimiento de objetos. El

desarrollo de estos sistemas puede ser con fines educacionales entre otros esto se debe a que su

publicación se da bajo licencia BSD, que permite que sea usada libremente para propósitos comerciales

y de investigación con las condiciones en ella expresadas.

Open CV es multiplataforma, Existiendo versiones para Linux, Mac OS X y Windows.

Contiene mas de 500 funciones que abarcan una gran gama de áreas en el proceso de Visión, como

reconocimiento de objetos (reconocimiento facial), calibración de cámaras, visión estéreo y visión

robótica.

Como metas el proyecto pretende proveer un "Tool-Kit" o Marco de desarrollo fácil de utilizar

y altamente eficiente. Esto se ha logrado, realizando su programación en código c y c++ optimizados,

aprovechando además las capacidades que proveen los procesadores multi núcleo. Open CV puede

además utilizar el sistema las Primitivas de Rendimiento Integradas de Intel. Que es un conjunto de

rutinas de bajo nivel específicas para procesadores Intel (IPP).

Las siglas Opencv provienen de los términos anglosajones “Open Source Computer Vision

Library”. Por lo tanto, Opencv es una librería de tratamiento de imágenes, destinada principalmente a

aplicaciones de visión por computador en tiempo real.



34

2.4.2 OpenCV Estructura y Contenido

OpenCV es ampliamente estructurado en cinco componentes principales, los cuales se muestran

en la Figura 1-5. El componente de CV contiene el procesamiento básico de imágenes y algoritmos de

alto nivel de visión por computador, ML es la máquina de aprendizaje de la colección, que incluye

muchas clasificadores de herramientas estadísticas y de la agrupación. HighGUI contiene rutinas I / O

y funciones para almacenar y cargar videos e imágenes, y CXCore consta de estructuras de datos y

funciones que proporcionan la base para todos los algoritmos de visión por computadora.

Figura 1-1: Estructura OpenCv

El modulo cvaux posee todas las funciones de tipo experimental y aquellas que se encuentres

obsoletas. En futuras versiones algunas de estas funciones pueden migrar hacia CV, mientras que otras

nunca lo harán. Algunas funciones que se encuentran en cvaux:

• Tracking de Ojos y Boca

• Descriptor de Texturas

• Calibracion de Camaras



35

2.4.3 ¿Por qué usar OpenCV? La otra opción para el tema del tratamiento de la imagen era utilizar Matlab, pero la verdad es

que OpenCV es una librería muy potente orientado a la visión por computadora, fácil de utilizar y

además portable a otras plataformas, Matlab también es un potente programa, pero la desventaja que

posee es que existen problemas de compatibilidad con otros sistemas, otro punto es que buscamos para

nuestra implementación rapidez debido a la cantidad de información a utilizar por lo que OpenCV es

una excelente opción debido a que se puede trabajar con punteros en esta librería y además está

desarrollado en C++, lenguaje de programación en la que ya tenemos experiencia por lo que se nos

hará un poco mas sencillo utilizar esta librería.

También sabemos que OpenCV es una biblioteca de visión artificial por lo que cuenta con

innumerables problemas que ya se han solucionado, facilitando y complementando así el trabajo para

este proyecto. Transformándose de esta manera en una ventaja competitiva dentro de las herramientas

principales para el desarrollo óptimo de una solución al problema propuesto.

Otro aspecto importante es que al trabajar con openCV podemos utilizar mediante su

componente HighGUI su GUI pudiendo así implementarse un sistema referente al modulo en cuestión

sin necesidad de integrarlo aun con su parte de interfaz final, pese a que la GUI que podemos formar

está limitada, es lo suficiente para poder como se acaba de decir, implementar este capítulo como un

módulo separado.

No podemos dejar pasar la oportunidad de mencionar que OpenCV es open source y no como

Matlab que debemos pagar la licencia para su utilización.



36

2.5 Pasos a principales en la obtención de características del objeto

Acá se señalarán los pasos a seguir para el correcto tratamiento de la imagen que se procesará,

obtenida por medio del punto de visión del sistema, que corresponderá a una cámara, la que estará fija

en un punto determinado.

La imagen obtenida se podrá analizar para así obtener los objetos que la componen y

seleccionar posteriormente el que sea de nuestro interés, con el que se trabajará más adelante (ver

figura 1.1).

Figura 1-2: Imagen inicial obtenida por webcam

2.5.1 Algoritmo Meanshift

La segmentación de imágenes por el algoritmo de corrimiento de media, Mean-Shift de ahora

en adelante nombrado como MS, se puede definir como la descomposición de una imagen en regiones

homogéneas, las cuales comparten características tales como intensidad y distribución espacial.

Los aspectos mas relevantes del algoritmo MS se mostraran a continuación.



37

2.5.1.1 Umbral.

El algoritmo trabaja de manera similar a los métodos de filtrado que operan en la vecindad de

cada pixel de la imagen que se desea procesar, solamente que en la segmentación de imágenes,

(hablando en términos del dominio de intensidad), se minimiza el número de máximos locales en la

imagen dejando sólo aquellos que son significativos, y todos los pixeles que se encuentren en su

vecindad cercana serán asociados a ellos, generando así las regiones homogéneas.

Este algoritmo funciona eliminando el ruido de tipo aditivo que pudiera existir en nuestra

imagen previo a la segmentación.

El algoritmo MS trabaja mediante operaciones matemáticas en la vecindad de cada pixel de la

imagen que deseamos segmentar.

El algoritmo es simple, se sustituyen los pixeles de la imagen original por el promedio de los

pixeles dentro de su vecindad (ventana), incluido el mismo; pero promediando sólo aquellos cuyo valor

de intensidad esté dentro de un intervalo de ponderación T del valor de intensidad del píxel central. Es

a esta ponderación T a la que denominamos umbral.

El algoritmo se describe como sigue:

Sea p(i,j) el valor de intensidad de un pixel con coordenadas (i,j) de la imagen original, V la

longitud de la ventana y N el número de elementos en la ventana que cumplen con la condición p(i,j) <

T. Entonces:



38

Donde P (i, j) es la transformación de p (i, j) con las mismas coordenadas espaciales. Por

ejemplo véase la Figura 1.2 para observar esto claramente. Considérese un umbral T=2 y un tamaño de

ventana de 3x3.

Figura 1-3: Sustitución del píxel central por el promedio de los píxeles en el interior de la ventana con un umbral T. Observe que el pixel central, cuyo valor de intensidad previo al filtrado era 2, fue sustituido por

3, al promediar solo aquellos pixeles que se encuentran dentro del umbral (T=2). También observe que

se aplicó el mismo algoritmo para todos los pixeles dentro de la ventana.

2.5.1.2 Distancia Espacial

Otro parámetro importante que hace que el MS nos permita segmentar imágenes, y que lo hace

diferente de los algoritmos de filtrado comunes, es la distancia espacial de cada pixel con su vecindad

en la imagen. Originalmente cada pixel en la imagen que deseamos segmentar se encuentra a una

distancia espacial 1 de los pixeles en su vecindad. Por lo que a partir de la matriz de la imagen original,

podemos generar fácilmente dos matrices más con las coordenadas espaciales de la misma. Es decir,

una matriz de renglones y otra de columnas. Y es a partir de estas matrices de coordenadas X e Y de la



39

imagen, que sustituimos cada pixel de estas matrices por el promedio de su vecindad. Promediando, (al

igual que con el umbral), sólo aquellos valores espaciales que se encuentren a una distancia espacial D

del pixel central en ambas matrices.

De este modo el MS sustituye cada pixel en la imagen que queremos segmentar, por el

promedio de aquellos pixeles dentro de la ventana que se encuentren en el intervalo del umbral T y que

además las coordenadas espaciales de los mismos estén a una distancia espacial D o menor. Es decir,

para sustituir cada pixel de la matriz de intensidad se deben cumplir con tres consideraciones:

i) Se consideran solamente los valores de intensidad de los pixeles dentro de la ventana que estén

dentro del umbral T;

ii) Se consideran solamente aquellos pixeles dentro de la ventana que estén a una distancia espacial

D de la matriz de coordenadas X, (matriz de columnas); y

iii) Se consideran solamente aquellos pixeles dentro de la ventana que estén a una distancia

espacial D de la matriz de coordenadas Y, (matriz de renglones).

Entonces sustituimos en las tres matrices el promedio de aquellos valores de intensidad y

distancias espaciales que cumplieron con lo anterior; para un mismo pixel central, y así

respectivamente para todos y cada uno de los demás en la imagen que deseamos segmentar.

El efecto de utilizar la información espacial en la imagen que deseamos segmentar provoca que

al momento de efectuar operaciones en la vecindad de cada píxel de la imagen, promediemos

únicamente aquellos pixeles en la vecindad cercana y no a aquellos que pertenezcan a estructuras de

otras regiones espaciales en la imagen.



40

2.5.1.3 Iteraciones.

La segmentación de la imagen, es decir, la visible agrupación de las diferentes estructuras

anatómicas presentes en la imagen de RM, se logra mediante la iteración del algoritmo descrito

anteriormente. Por tanto, la iteración de la imagen original que deseamos segmentar con MS converge

a una única imagen segmentada después de n iteraciones, y para la iteración n+1, n+2, ..., M; con

M>>n, la imagen resultante será la misma que la obtenida en la n-ésima iteración. Por lo tanto, el

número de iteraciones está acotado, y no necesariamente mientras más iteremos este algoritmo,

obtendremos mejores resultados

A continuación se muestra en la figura 1-4 el resultado del algoritmo MS aplicado sobre la

figura 1-2.

Figura 1-4: aplicación del algoritmo Mean Shift sobre la figura 1-2.



41

2.5.2 Binarización de Imágenes

La binarización es un caso particular de la segmentación que consiste en transformar los pixeles

de la imagen en 0 o 1, dependiendo de su nivel de gris, esto pues es necesario que la imagen que se va a

binarizar se encuentre en niveles de grises, es decir, obtener una imagen binaria f b a partir de una

imagen en niveles de gris f a consiste en:

donde Z es un subconjunto de todos los niveles de gris posibles en.

Pero la forma de binarizar mas utilizada consiste en utilizar un umbral T que determina a partir

de qué nivel de gris de va a considerar primer plano y el resto del fondo, de tal forma que se preserven

las propiedades esenciales de la imagen.

Para determinar este umbral existen métodos de búsqueda automática de umbrales, como es el

caso del método p-tile.

P-tile consiste en hallar el umbral T tal que el p% de los pixeles sean mayores (o menores) que

T. Por tanto, p es un dato que se debe proporcionar en la linea de comandos y que indica el porcentaje

de imagen que ocupa el objeto u objetos.

A continuación se mostrará binarización a diferentes niveles de Umbral:



42

Figura 1-5: aplicación de binarización sobre la figura 1-4 con un umbral de 127

Figura 1-6: aplicación de binarización sobre la figura 1-4 con un umbral de 180

2.5.3 Transformaciones Morfológicas

La base de la transformación morfológica es en el campo matemáticamente de la teoría de

conjuntos.

El objetivo de las transformaciones morfológicas es la extracción de estructuras geométricas en

los conjuntos sobre los que se opera, mediante la utilización de otro conjunto de forma conocida

denominado elemento estructurante. El tamaño y la forma de este elemento se escoge, a priori, de



43

acuerdo la morfología del conjunto sobre el que va a interaccionar y de acuerdo a la extracción de

formas que se desean obtener. Ejemplos básicos de elementos estructurantes utilizados en la práctica se

muestran en la figura 1-7.

2.5.3.1 Erosionar

En ‘teoría de retículos’, una erosión es una operación que conmuta con el ínfimo. Dado un

retículo completo X, una erosión es una función ε : X → X en la que:

donde I es cualquier conjunto de índices y {xi} es una colección arbitraria de valores xi ∈ X.

La transformación de erosión es el resultado de comprobar si el elemento estructurante Y está

totalmente incluido dentro del conjunto X. Cuando esto no ocurre, el resultado de la erosión es el

conjunto vacío.

La erosión de un conjunto X por un elemento estructurante Y se define como el conjunto de

puntos o elementos x, pertenecientes a X, de forma que cuando el elemento estructurante Y se traslada

a ese punto, el elemento queda incluido en X:

La ecuación anterior puede reformularse en términos de una intersección de conjuntos

trasladados. Las traslaciones vienen determinadas por el elemento estructurante Y:



44

El efecto de una operación de erosión puede observarse en la figura 3.2, en la que un elemento

estructurante Y, en forma de disco circular, hace desaparecer las estructuras de menor tamaño al

elemento.

Figura 1-7: Erosión de X por el elemento estructurante Y. Los elementos conectados del conjunto X más pequeños que Y

son eliminados.

La última definición de erosión puede extenderse directamente al caso de imágenes binarias y

de escala de grises. La erosión de una imagen f por un elemento estructurante Y se denota por εY(f) y

se define como el mínimo (^) de las traslaciones de f por los elementos s de Y:

En señales digitales o imágenes de escala de grises la noción de ínfimo pasa a denotarse

mínimo. En este caso, la erosión es el mínimo valor de la función imagen en la ventana (dominio)

definida por el elemento estructurante cuando su origen se sitúa en x (señales unidimensionales) ó (x,y)

(imágenes). Para señales unidimensionales se puede definir la erosión como:

Para imágenes la erosión puede ser definida como:



45

En la figura 1-7 se muestra la erosión de una señal unidimensional de función f. Se puede

observar el efecto de la intersección de traslaciones definidas por el elemento estructurante Y. El

resultado es el mínimo valor de todos los presentes bajo la definición del elemento estructurante.

Figura 1-8: Erosión de una señal unidimensional definida por la función f. Elemento estructurante de tamaño 3. El

resultado es el mínimo de todos los valores presentes bajo la definición del elemento estructurante. El resultado de la erosión en señales bidimensionales de escala de grises (imágenes) es una

señal de menor valor, es decir, una imagen más oscura, puesto que la erosión pretende minimizar el

valor de la señal que, en el caso de los grises tiene una definición [0,255].

2.5.3.2 Dilatar

La dilatación es la operación dual de la erosión. En ‘teoría de retículos’, un operador δ : X → X

se denomina dilatación en el caso que conmute con el supremo de una colección de valores:



46

donde I es cualquier conjunto de índices y {xi} es una colección arbitraria de valores xi X.

El resultado de la dilatación es el conjunto de puntos origen del elemento estructurante Y tales

que el elemento contiene algún punto del conjunto X, cuando el elemento se desplaza por el espacio

que contiene a ambos conjuntos:

δ Y ( X ) = {x | Yx ∩ X ≠ 0}

Esta última ecuación puede reescribirse como una unión de conjuntos trasladados. Las

traslaciones vienen definidas por el dominio del elemento estructurante:

δY (X ) = U X −s

sY

El efecto de una operación de dilatación puede observarse en la figura 1-9, en donde un

elemento estructurante Y de forma de disco circular aumenta la definición del objeto X.

Figura 1-9: Dilatación de X por el elemento estructurante Y. El conjunto X aumenta su definición.

Se puede extender la última definición de dilatación a imágenes binarias o de escala de grises f,

interpretando la dilatación como el máximo valor de las traslaciones de f (definidas por la forma del

elemento estructurante) en cada punto de la imagen:



47

La dilatación de la imagen binaria de la figura 1-10 por el elemento estructurante anterior se

presenta en la figura 1-11. Es posible observar como los objetos de tamaño menor al del elemento

estructurante desaparecen.

Figura 1-10: Imagen Binaria sin Erosionar

Figura 1-11: Imagen Binaria Erosionada



48

En otras palabras, el valor de dilatación de un píxel (x,y) es el máximo valor de la imagen en la

ventana de vecindad definida por el elemento estructurante cuando su origen se sitúa en (x,y):

En la figura 1-12 se muestra la dilatación de una señal unidimensional de función f. Se puede

observar el efecto de la intersección de traslaciones definidas por el elemento estructurante Y. El

resultado es la selección del mínimo valor de todos los presentes bajo la definición del elemento

estructurante.

Figura 1-12: Dilatación de una señal unidimensional definida por la función f. Elemento estructurante de tamaño 3. El resultado es el máximo de todos los valores presentes bajo la definición del elemento estructurante.

2.5.4 Centroide

En geometría, el centroide o baricentro de un objeto X perteneciente a un espacio n-

dimensional es la intersección de todos los planos que dividen a X en dos partes de igual n-volumen.



49

El centroide es un punto que define el centro geométrico de un objeto. Su localización puede

determinarse a partir de formulas semejantes a las utilizadas para determinar el centro de gravedad o el

centro de masa del cuerpo, el centroide nos sirve para encontrar el punto en el que se concentra las

fuerzas que actúan sobre una figura irregular, o figuras geométricas no muy conocidas.

2.6 Trabajar OpenCV en Dev-c++

La primera etapa en nuestro proyecto es el tratamiento de la imagen y para ello escogimos por

las diversas razones mencionadas anteriormente OpenCV, para esto previamente se debe instalar Dev-

C++ que va ser quien va a albergar a OpenCV.

Una vez instalado Dev-C++, se procede con la instalación de OpenCV, a continuación debemos

modificar las opciones del copilador de Dev-C++, agregando en esta parte un nuevo compilador y los

correspondientes directorios de OpenCV que hacen referencia a Binarios, Librerías y Cabeceras

C/C++, previo esto ya estamos en condiciones de trabajar con las librerías de OpenCV.

2.7 Aplicaciones del tratamiento de Imágenes

El tratamiento de imágenes es importante pues puede ser aplicado de muchas formas:

Medicina molecular, Se inyecta al paciente un isótopo radioactivo que emite rayos gamma cada

vez más débiles, estos se detectan y se forma la imagen.

Mapas en 3D para adquisición submarina, al disparar 2 pistolas de aire produciendo vibraciones

de frecuencia, al recuperar las ondas de regreso procesa la información y construye un mapa 3D del

fondo del océano.



50

2.8 Diseño

2.8.1 Diagrama de flujo de datos

Esta es la forma en que el sistema en su primera fase desarrollo concretamente openCV realiza

su funcionamiento que es: tratamiento de imágenes, mostrando cada una de ellas al usuario, además de

poder hacer click sobre la imagen cuando se hallan encontrado los objetos, es aquí donde ésta

aplicación determinará si es que la posición donde se estableció la búsqueda del objeto se encuentra o

no devolviendo como resultado su centroide.



51



52


El primer problema fue entender una librería con sus estructuras, debiendo invertirse tiempo

valioso de esta forma, debido a que existe muy poca documentación al respecto, siendo esto un punto

problemático pues todo lo que se realizara se debía hacer prácticamente desde cero, invertíendose

tiempo valioso en las pruebas y posibles soluciones al respecto, primero se empezó revisando librerías

en php lamentablemente habían cosas que se convertían muy problemáticas a realizar debido a que no

se encontró en su instante alguna librería de visión artificial como lo es OpenCV. Otro punto que causo

dificultad fue la conexión con la cámara web siendo en un primer instante bastante problemático,



53

lográndose superar estos problemas a medida que se iban haciendo pruebas y leyendo libros al respecto

que dieran nociones al respecto.

Con respecto a la instalación de esta librería fue un problema en un primer momento debido a

que al utilizarlo en ubuntu 9.10 se tubo que descargar su archivos binarios y tener que compilarlo,

logrando utilizarlo momentáneamente e investigar como compilar a mano por consola a través del g++

y por otro lado en windows se tubo que aprender a incorporar instalarlo, luego incorporarlo a el

entorno de programación utilizado siendo devC++ resultando en un comienzo un acto relativamente

complejo, lográndose finalmente dando buenos resultados y aprendiendo a a partir de ello el manejo de

las variables de entorno de ellos sistemas.


Capítulo 3: Lógica Difusa

54

3 Lógica Difusa

Lógica difusa también llamada lógica borrosa, es la lógica que utiliza expresiones que no son ni

totalmente ciertas ni completamente falsas, es decir, es la lógica aplicada a conceptos que pueden tomar

un valor cualquiera de veracidad dentro de un conjunto de valores que oscilan entre dos extremos, la

verdad absoluta y la falsedad total, por medio de estos conceptos se desarrollara el tema de poder

poder determinar donde moverse dentro del espacio que posee el Scorbot ER-V Plus, esto dándole

ciertas nociones de conocimientos que se les va a entregar por medio de lógica difusa, para de esta

forma poder decidir entre comillas que acción debe realizar.

3.1 Definiciones previas

3.1.1 Conjuntos Difusos y Grado de pertenencia

Por definición conjunto es una agrupación de elementos bien definida, en un conjunto difuso a

cada elemento que compone la agrupación, se le asocia un grado de pertenencia, esto quiere decir que

se le asocia un numero entre 0 y 1. Mientras el grado de pertenencia este mas cerca al 1 tanto mas

estará el elemento en el conjunto, mientras que si el grado de pertenencia se encuentre mas cercano al

0 tanto menos estará el elemento en el conjunto, un ejemplo sería: una temperatura de 10ºC ¿Es fría o

tibio?, frío y caliente viene siendo un conjunto bien definido, en lógica difusa podemos definir un par

de conjuntos frío y tibio y especificar el grado de pertenencia de la temperatura dada en cada conjunto

con lo que se podría definir que 10ºC es tanto frío como tibio



55

Figura 2-1: Representación del grado de pertenencia

La ventaja de los conjuntos difuso es que se pueden tener cambios graduales en la salida para

cambios pequeños en las entradas. Como se puede observar ambas temperaturas tienen cierto grado de

pertenencia al conjunto Frío y al conjunto Tibio

3.1.2 Valores de Membresía

El concepto de función de membresía en un conjunto difuso se ilustra en el ejemplo

a continuación:

Figura 2-2: Función de membresía



56

Donde, según la figura anterior, la función de membresía o pertenencia de un elemento x en

el conjunto difuso triangular (A) está dado por:

Figura 2-3: Formula para el calculo de membresia en un clauster triangular

De esta manera, existen otras formas de conjuntos difusos, como son trapezoidales, tipo

campana de Gauss, tipo S, etc. Para todos ellos, el concepto de función de membresía es el mismo; es

decir, existe un grado de pertenencia que varia entre 0 y 1.

3.2 Definición Lógica Difusa

La lógica difusa o borrosa (Fuzzy logic) plantea la idea que en un instante dado, no es posible

precisar el valor de una variable X dentro de un conjunto definido, sino tan solo conocer el grado de

pertenencia a cada uno de los conjuntos en que se ha particionado el rango de variación de la variable,

es decir, que tanta correspondencia tiene la variable X en cada uno de los conjuntos definidos. Este

método de razonamiento de maquina es similar al pensamiento humano, que puede procesar

información incompleta o incierta, como se realiza cotidianamente. Precisamente es en esto en que se

diferencia de la lógica convencional (Lógica Clásica) la cual trabaja con información bien definida y



57

precisa, valores concretos, o es blanco o es negro.

El grado de pertenencia se cuantifica mediante la función de pertenencia f, que normalmente se

escoge de una forma trapezoide.

Por ejemplo, al calificar que “el cielo es azul'' uno está tentado a graduar qué tan “azul'', en

efecto, es el cielo, ya sea “Poco Azul”, “azul” o “muy Azul”, e igualmente, si “un vehículo se mueve

rápido'', también se está obligado a considerar qué tan rápido es el vehículo, aunque esto último no

implique necesariamente cuantificar la velocidad del vehículo con toda precisión.

El concepto de lógica difusa fue introducido por el Dr. Lotfi Zadeh de UC/Berkeley en los años

60 como los medios de modelar la incertidumbre del lenguaje natural. Quien inconforme con los

conjuntos clásicos (crisp sets) que sólo permiten dos opciones, la pertenencia o no de un elemento a

dicho conjunto la presentó como una forma de procesar información permitiendo pertenencias parciales

a unos conjuntos que en contraposición a los clásicos los denominó Conjuntos Difusos (fuzzy sets), el

concepto de conjunto difuso fue expuesto por Lofti Zadeh en un paper en 1965 y es considerado un

clásico de la lógica difusa, el artículo se titula "Fuzzy Sets", permitiendo de esta forma obtener

resultados más aproximados.

Pocos años después en 1974, el Británico Ebrahim Mandani, demuestra la aplicabilidad de la

lógica difusa en el campo del control. Desarrolla el primer sistema de control difuso (Fuzzy Control)

práctico, la regulación de un motor de vapor. Las aplicaciones de la lógica difusa en el control no se

pudieron ser implementadas con anterioridad a estos años debido a la poca capacidad de cómputo de

los procesadores de esa época.

Esta metodología proporciona una manera simple y elegante de obtener una conclusión a partir

de información de entrada vaga, ambigua, imprecisa o incompleta, en general la lógica difusa imita

como una persona toma decisiones basadas en información con las características mencionadas. Una de

las ventajas de la lógica difusa es la posibilidad de implementar sistemas basados en ella tanto en

hardware como en software o en combinación de ambos.



58

3.3 Esquema Lógica Difusa

Figura 2-4: Esquema Lógica Difusa

3.3.1 Fuzzificación

En la fuzzificación se asignan grados de pertenencia a cada una de las variables de entrada

con relación a los conjuntos difusos previamente definidos utilizando las funciones de pertenencia

asociadas a los conjuntos difusos

3.3.2 Base de Conocimiento

La Base de conocimiento de genera a partir de reglas difusas, teniéndose un conjunto de reglas

SI-ENTONCES que pueden ser expresadas de la siguiente forma:

Rm: Si u1es A1my u2es A2

my ...upes Apm ,

ENTONCES v es Bm

Con m=1,2,..., M

Y donde Aim

y Bm son conjuntos difusos en U i R (números reales) y VR respectivamente,

e son los valores numéricos



59

concretos de u y v, también respectivamente.

La base de conocimiento contiene el conocimiento asociado con el dominio de la

aplicación y los objetivos del control. En esta etapa se deben definir las reglas lingüísticas de control

que realizarán la toma de decisiones que decidirán la forma en la que debe actuar el sistema

3.3.3 Inferencia

Corresponde a la sección que mediante los mecanismos de inferencia que veremos más

adelante, relaciona conjuntos difusos de entrada y de salida; y que representa a las reglas que definen el

sistema. Las entradas a este bloque son conjuntos difusos (grados de pertenencia) y las salidas son

también conjuntos difusos, asociados a la variable de salida.

3.3.3.1 Mecanismo de Inferencia

Los mecanismos de inferencia son aquellos en los que se usan los principios de la inferencia

difusa para realizar un mapeo de los conjuntos difusos de entrada a los conjuntos difusos de salida.

Cada regla es interpretada como una implicación difusa. Es decir, el bloque de inferencia es aquel en el

cual se realiza la “traducción matemática” de las reglas difusas: estas reglas modelan el sistema pero

para poder trabajar con ellas y extraer un resultado se deben evaluar matemáticamente la información

que reflejan. Como ya se ha mencionado anteriormente, las reglas más utilizadas para diseñar un

sistema basado en lógica difusa toman la forma:

Siu1esA1 yu2esA2 yu3esA3 ENTONCESvesB

3.3.3.2 Conectores lógicos entre Antecedentes

En este caso límite, las tablas de verdad de los operadores lógicos clásicos y las de los

operadores lógicos difusos deben coincidir. Considerando las tablas clásicas de verdad de los



60

operadores AND, OR y NOT

Figura 2-5: Tabla de verdad de los operadores AND, OR y NOT.

3.3.4 Desfuzzificación

Corresponde a la sección que a partir del conjunto difuso obtenido en el mecanismo de

inferencia y mediante los métodos matemáticos de desfuzzificación, se obtiene un valor concreto de la

variable de salida, es decir, el resultado.

3.3.4.1 Métodos de Desfuzzificación

El bloque de desfuificación realiza la función contraria al de Fuzzificación. Este tiene como

entradas valores concretos de las variables de entrada y como salidas grados de pertenencia a conjuntos

difusos (entre 0 y 1). La entrada al bloque de desfuificación es el conjunto difuso de salida, resultado

del bloque de inferencia y la salida es un valor concreto de la variable de salida. Para obtener, a partir

del conjunto difuso de salida que resulta de la agregación de todas las reglas, un resultado escalar, se

aplican métodos matemáticos. Ejemplos sencillos de algunos de estos métodos de cálculo son:

• Método del máximo: se elige como valor para la variable de salida aquel para el cual la



61

función característica del conjunto difuso de salida es máxima. En general no es un método

óptimo, ya que este valor máximo puede ser alcanzado por varias salidas.

• Método del centroide: utiliza como salida del sistema el centro de gravedad de la función

característica de salida. Matemáticamente :

Es el método más utilizado en aplicaciones de la lógica difusa a la ingeniería, ya que se obtiene una

solución única, aunque a veces es difícil de calcular.

• Método de la altura: se calcula para cada regla el centro de gravedad del conjunto difuso de

salida Bm y después se calcula la salida del sistema como la media ponderada:

3.4 Funcionamiento

Según todo lo previamente mostrado, lo primero que se debe realizar es comprender los

cuantificadores de nuestro lenguaje en términos de por ejemplo, “Muy Abajo”, “Abajo”, “Arriba”,

“Muy Arriba” entre muchos otros dependiendo lo que queramos representar del mundo real, y para ello

en los conjuntos difusos se definen operadores, los cuales pueden ser unión, intersección, diferencia,

negación o complemento, y otras operaciones sobre conjuntos, en los que se basa esta lógica.

Cada conjunto difuso posee asignada una función de pertenencia para sus elementos, que nos

indican en que medida ese elemento pertenece al conjunto difuso, también debemos decir que la lógica

difusa se basa en reglas heurísticas, donde estas reglas tienen la forma, SI (antecedente) ENTONCES

(consecuente), por ejemplo:

SI hace mucho frió ENTONCES aumento la calefacción.

Los métodos de inferencia para esta base de reglas deben ser simples, veloces y eficaces. Por lo



62

tanto los resultados de dichos métodos son un área final, que resulta de un conjunto de áreas solapadas

entre sí (cada área es resultado de una regla de inferencia). El método que usamos es el del centroide,

en el que la salida final será el centro de gravedad del área total resultante.

Para construir nuestra maquina de lógica difusa se debe disponer de datos de entrada los suelen

ser recogidos por sensores, que miden las variables de entrada de un sistema. Después debemos tener

nuestro sistema de control que es el que esta compuesto por nuestro conjunto de reglas que fueron

formuladas por expertos, para así proporcionar las correspondientes salidas de nuestro sistema.

Figura 2-5: Esquema de funcionamiento para un sistema difuso, en el que distinguimos las entradas, reglas y salidas.

3.5 ¿Por qué Lógica Difusa?

Normalmente en la lógica convencional tenemos un conjunto de enunciados que pueden ser

verdaderos o falsos, si o no, 0 o 1. En el contexto de la lógica difusa, el enunciado de “la temperatura es

25 grados centígrados” puede ser verdadero o falso. Sin embargo, en muchas situaciones la respuesta

puede ser mas de un simple “no estoy seguro”, “quizás”, “un poco” y entre otras otras. Por ejemplo, en

la frase “la temperatura esta muy alta” no es ni verdadera ni falsa, ya que es una idea cualitativa que

representa una opinión más que un hecho objetivo, es debido a este tipo de circunstancias es que surge

la necesidad de interpretar el movimiento que realizará la celda flexible para alcanzar el objeto, la cual

es compleja. Es por esta razón que no solamente se van a interpretar las instrucciones como, hacia



63

arriba, hacia abajo, izquierda o derecha, sino que puede moverse un poco a la izquierda o un mucho

hacia arriba, es por esto que la lógica difusa sera de gran ayuda en la interpretación de estos valores

lingüísticos que utilizaremos y serán explicados mas adelante.

Otro aspecto que importante es que el proceso de moverse por medio de un área demarcada es

difícil de implementar en una función matemática, por lo cual se deben ocupar reglas de tipo mas

intuitivas que serán reflejadas en la base de conocimiento del sistema.

3.6 Como crear un Sistema Difuso Basado en Reglas

1. Identificación de las variables de entrada y salida, la parte primordial, debió a que los sistemas

de tipo difuso pueden poseer múltiples variables de entrada, además de obtener múltiples

salidas con un valor particular asociado a cada uno de ellas, como en este proyecto que posee

dos variables de entrada que son el las distancias que hay entre la posición actual de la celda y

el objeto, de las coordenadas ordenada y abscisa.

2. Determinación de Conjuntos Difusos, se refiere al grado de pertenencia que existe para cada

una de las variables de entrada al sistema.

3. Selección de método para desfuzzificación, ya sea el método del máximo, del centroide o de la

altura.

4. Creación de base de conocimiento de utilizando reglas de tipo SI ENTONCES, parte esencial

para poder crear el conocimiento base del sistema, siendo cada una de estas reglas un aporte en

algún grado de relación con una situación X que esté pasando dentro del contexto que rodea al

sistema.

5. Diseño de mecanismo de inferencia, en el caso de este proyecto de título, va a ser diseñado

mediante el Toolbox de lógica difusa que posee Matlab.

6. Evaluación y uso del programa, importante paso que siempre debe existir en cualquier

programa o sistemas que se cree, esto por medio del mismo programa o con otro tipos de

evaluaciones predefinidas por el propio desarrollador del correspondiente sistema, utilizando en



64

nuestro caso la herramienta de Toolbox que trae Matlab además de ocupar Simulink para

comprobar el correcto funcionamiento.

3.7 Matlab

El sistema matlab se utilizará por motivos de diseño de mecanismo de inferencia, esto mediante

un toolbox que trae matlab que es especializado en lógica difusa, pudiendo practicar con ello los

conceptos de lógica difusa previamente desarrollados en el presente informe.

3.7.1 Definición

Describiéndolo en forma general, Matlab un programa para ingeniería dedicado a realizar

cálculos técnicos-científicos y de propósito general. En el se integran operaciones de calculo,

visualización y programación, donde la interacción con el usuario emplea una notación matemática

clásica.

Es un ambiente de computación técnica de alto rendimiento, para cómputo numérico y

visualización, que integra análisis numérico, cómputo de matrices, procesamiento de señales y gráficas

en un ambiente fácil de usar, donde los problemas y sus soluciones se expresan como se haría en

matemáticas, sin necesidad de la programación tradicional.

El nombre Matlab, surge de Matrix Laboratory, el cual es un sistema interactivo cuyo elemento

básico es una matriz que no requiere dimensionamiento. Esta característica permite resolver muchos

problemas numéricos en una fracción del tiempo que llevaría hacerlo en un lenguaje de programación

como Fortran, Basic, o C.



65

3.7.2 Uso y aplicaciones

•Matemáticas y calculo.

•Desarrollo de algoritmos.

•Adquisición de datos.

•Modelado, simulación y prototipado.

•Análisis y procesado de datos.

•Gráficos científico y de ingeniería.

•Desarrollo de aplicaciones.

3.7.3 Componentes de Matlab

Los componentes fundamentales de Matlab son:

3.7.3.1 Entorno de desarrollo

Corresponden a un conjunto de utilidades que permiten el uso de funciones Matlab y ficheros

en general. Gran cantidad de estas utilidades son interfaces gráficas de usuario y de ventana de

comandos.

3.7.3.2 La librería de funciones matemáticas Matlab

Lo componen un conjunto de algoritmos de cálculo, los cuales lo componen las funciones mas

elementales como la suma, senos, cosenos o la aritmética compleja, hasta funciones mas avanzadas

como la inversión de matrices, el cálculo de autovalores, funciones de Bessel y transformadas rápidas

de Fourier.



66

3.7.3.3 Gráficos

Son un conjunto de utilidades destinadas a visualizar vectores y matrices en forma de gráficos.

Dentro de estas utilidades existe una gran cantidad de opciones para poder ajustar el aspecto de los

gráficos, destacando de estos la visualización tridimensional con opciones de iluminación y sombreado

y la posibilidad de crear o incorporar animaciones

3.7.3.4 La interfaz de aplicación Matlab (API)

Es una librería que permite escribir programas ejecutables independientes en C y otros

lenguajes, accediendo mediante DLLs, a las utilidades de cálculo matricial de Matlab.

3.7.4 Toolboxes

En MATLAB las toolboxes son colecciones de funciones, códigos o macros de MATLAB,

conocidos como M-files, muy fáciles de comprender y de usar, que extienden el ambiente del programa

con el fin de resolver clases particulares de problemas. Algunas de las áreas para las cuales existen

toolboxes son: Procesamiento de Señales, Análisis y Diseño de Sistemas de Control, Simulación

Dinámica de Sistemas, Identificación de Sistemas, Redes Neuronales, Ecuaciones Diferenciales

Parciales, Procesamiento de Imágenes, Matemática Simbólica, Lógica Difusa, Estadística,

Optimización, Comunicaciones, Finanzas, etc. De las cuales se utilizaran para este proyecto

Simulación Dinámica de Sistemas y Lógica Difusa, los cuales se detallaran mas adelante.



67

3.7.5 Simulink

Es una aplicación que proporciona al usuario un entorno gráfico por medio del cual se facilita el

análisis, diseño, construcción y simular modelos de sistemas físicos y sistemas de control, al incluir una

serie de rutinas que resuelve los cálculos matemáticos de fondo, junto con una sencilla interfaz para su

uso, proporcionando un entorno de usuario gráfico que permite el dibujar diagramas de bloques tal

como se haría sobre un papel. El comportamiento de estos sistemas se define mediante funciones de

transferencias, operaciones matemáticas, elementos de Matlab y señales predefinidas de todo tipo.

Los componentes incluidos junto al programa Simulink, incluye bibliotecas de fuentes de señal,

dispositivos de presentación de datos, sistemas lineales y no lineales, conectores y funciones

matemáticas. En caso de ser necesario, se pueden crear nuevos bloques a medida por el usuario.

3.7.6 Fuzzy

Corresponde al área de lógica difusa, cuya utilidad consiste en poder realizar acciones

pareciéndose mas a como razonaría en cierta forma nuestro cerebro, esto mediante los inputs (entradas)

y outputs (salidas) que se agreguen en la interfaz. Además de sus correspondientes reglas para tomar las

decisiones en base a los distintos input que se posean.

3.8 Implementación

3.8.1 Entorno de trabajo Matlab

En la figura 1 muestra como están organizadas las ventanas por defecto al iniciar Matlab. Las

ventanas que en ella aparecen son: en la esquina superior izquierda, corresponde a la estructura del

directorio donde nos encontramos, debajo de esta se encuentra la ventana que contiene el historial de



68

los comandos que se han utilizado en Matlab, en la ventana de la derecha se encuentra la linea de

comandos.

Figura 2-6: organización de ventanas Matlab

3.8.2 Entorno de trabajo Fuzzy Logic Toolbox

3.8.2.1 FIS Editor (Sistema de inferencia Borroso)

Para poder ingresar a este toolbox dedicado al área de lógica difusa se debe escribir en la linea

de comandos de la figura 2-6 “fuzzy” y presiona “enter”, a lo cual se abrirá a su entorno de desarrollo

figura 2-7, en el cual se podrán ocupar “n” variables de entrada así como “m” variables de salida. Los

componentes que se pueden observar son:

•input1 corresponde a las variables de entradas que van a tener, para el caso del proyecto a realizar se



69

han contemplado 2 variables de entrada correspondientes a los ejes de las coordenadas cartesianas la

ordenada y la abscisa lo cual va a representar el punto en el cual se encuentre la punta de la celda

flexible a cada instante dentro del campo de visión, los cuales van a poseer 7 conjuntos difusos, los

cuales se describirán más adelante.

Esta parte corresponde a la fuzzificación.

•El rectángulo blanco con el título de Untitled representa las reglas de control que poseerá el

controlador.

•Output1 corresponde a las variables de salida , las cual para el caso del proyecto a realizar corresponde

a 2 variables de salida las cuales tendrán 7 conjuntos difusos, los cuales serán descritos más adelante.

Esta parte corresponde a la defuzzificación.

Figura 2-7: FIS Editor



70

3.8.2.2 Variables Lingüísticas

Para definir las funciones de pertenencia del controlador fuzzy (variables lingüísticas), se

considera la siguiente notación:

Notación correspondiente a la primera variable de entrada-salida:

•muy_izquierda: se encuentra muy a la izquierda.

•izquierda: se encuentra moderadamente a la izquierda.

•poco_izquierda: se encuentra solamente un poco a la izquierda.

•cero: se encuentra prácticamente en el centro.

•poco_derecha: se encuentra solamente un poco a la derecha.

•derecha: se encuentra moderadamente a la derecha.

•muy_derecha: se encuentra muy a la derecha.

Notación correspondiente a la segunda variable de entrada-salida:

•muy_abajo: se encuentra muy abajo.

•abajo: se encuentra moderadamente abajo.

•poco_abajo: se encuentra solamente un poco abajo.

•cero: se encuentra prácticamente en el centro.

•poco_arriba: se encuentra solamente un poco arriba.

•arriba: se encuentra moderadamente arriba.

•muy_arriba: se encuentra muy arriba.

De este modo la interpretación a dar en el proyecto seria que tan alejado se encuentra la celda

flexible del objeto a alcanzar.

3.8.2.3 Membership Function Editor (Editor de reglas de Pertenencia)

Para entrar a Membership Function Editor, Figura 3,bhasta con hacer doble click sobre algún

icono de variable de entrada o de salida de la Figura 2-7, en éste editor se encontrarán al lado izquierdo



71

todas las variables de entrada y todas las de salida que se hayan agregado con anterioridad dando la

posibilidad de poder editar la funciones de pertenencias correspondientes a la variable sobre la cual se

haga un click, o los rangos numéricos de la variable entre otras cosas.

En el caso del proyecto el rango de las funciones de pertenencias fueron obtenidas mediante la

consultas pertinentes a personas con conocimientos en el tema, y a través de mediciones realizadas en

el Centro de Robótica de la Universidad del Bio-Bio CIMUBB obteniendo un rango de -4 a 4 ajustando

estos valores a las variables lingüísticas mencionadas anteriormente en las variable de entradas y en el

caso de las variables de salida es de una -100% a un 100%.

Figura 2-8: Membership Function Editor



72

3.8.2.4 Rule Editor (Editor de Reglas)

Para poder entrar al Rule Editor es necesario hacer doble click sobre el diagrama del sistema

que representan las reglas del sistema, Figura 2-9, una vez que se definieron las funciones de

pertenencia se puede ingresar el conjunto de reglas necesarios, esto se realiza seleccionando la

combinación de variables de entrada mediante los conectores And o Or seleccionando la combinación

de variables de salidas deseadas por el usuario que esta generando una base de conocimientos, además

de añadir reglas el editor permite eliminar y cambiar reglas. Formando de esta forma el cerebro del

sistema, puesto que éste reaccionará según las reglas que se hayan añadido acá.

Figura 2-9: Rule Editor



73

En el caso del proyecto a realizar se han añadido un total de 49 reglas las cuales fueron

generadas mediante la consulta a expertos en el tema que se encuentras en la Universidad del Bio-Bio

en el laboratorio de Robótica. El conjunto de estas reglas va a aportar para poder dirimir cual va a ser la

respuesta adecuada en la salida, esto pues cada regla aporta en el conocimiento que debe tener el

sistema.

3.8.2.5 Rule Viewer (visualizador de reglas)

Para poder entrar a Rule Viewer, Figura 2-10, es necesario ir al menu View->Rules, desde cualquier

parte del entorno de trabajo Fuzzy Logic Toolbox. Esta es una herramienta muy interesante que posee

el toolbox, la cual permite visualizar el estado de todas las reglas de control ante una determinada

combinación de variables de entrada esto mediante el corrimiento de la linea vertical roja, permitiendo

además apreciar el comportamiento de la salida del controlador Fuzzy y la salida de defuzzificada para

dichas entradas, pudiendo apreciarse como es que cada una de las reglas aporta en cierta medida para la

o las variables de salida que se encuentren, esto según como se hayan definido con anterioridad la base

de conocimiento.



74

Figura 2-10: Ruler Viewer

3.8.2.6 Guardar y exportar al Workspace

Una vez terminado de Insertar variables, jugar con los valores de pertenencia al igual que con

sus variables de salidas y una vez concluido con el manejo del editor de reglas, se puede proceder a

guardar el controlador, para realizar esto se debe dirigir al menú File-> Export->To File..., a lo cual se

abrirá una ventana para guardar con el nombre que uno desee dejándolo en extensión “.fis”, una vez

realizado esto ya se podrá exportar el controlador al Workspace que se este utilizando. Para realizar

esto se debe dirigir a File->Export->To Workspace..., al hacer esto se preguntara cual es el nombre que

se le desea dar para ser reconocido en el Workspace ver Figura 2-11.



75

Figura 2-11: Exportar variable a Workspace

3.8.3 Entorno de trabajo Simulink

3.8.3.1 Simulink Library Browser

Para poder ingresar a se debe escribir en la linea de comandos de la figura 2-6 “simulink” y

presiona enter, aparecerá lo que se observa en la Figura 2-12. El propósito de esta ventana consiste en

permitir la navegación por la enorme cantidad de librerías de bloques que se encuentran disponibles

para el modelado.

En la figura 2-12, se pueden distinguir claramente tres partes principales: de arriba hacia abajo

comenzando por la izquierda se puede observar un contenedor que posee una visión en forma de árbol

de todos los Toolboxes instalados que contiene bloques Simulink. La amplitud de este árbol dependerá

de las opciones que se hayan elegido al seleccionar matlab. En el proyecto en cuestión los nodos

relevantes van a ser Simulink y el Fuzzy Logic Toolbox.

A la derecha se pueden observar los bloques Simulink contenidos contenidos en el Toolbox o el

nodo de la parte izquierda de la ventana, mencionada anteriormente.



76

En la parte inferior se encuentra la descripción de los bloques Simulink seleccionados, que

servirán de utilidad para mayor comprensión del usuario.

Por último, cabe destacar que en la parte superior de la Figura 2-11, existen varias herramientas

como la búsqueda de un bloque determinado a partir de su nombre, resultando bhastante útil en los

casas que no sepamos en que toolbox se encuentre y no estar desmenuzando el árbol de contenidos uno

por uno para poder encontrarlo.

Figura 2-12: Ventana de navegación de bloques de Simulink (Simulink Library Browser)



77

3.8.3.2 El espacio de trabajo de Simulink

Podemos acceder a el presionando en el icono superior izquierdo de la ventana de la figura 2-11

(página en blanco), se abrirá una ventana como la de la Figura 2-13 pero en blanco sobre la que se

podrá iniciar la creación de un modelo de simulación.

Figura 2-13: Espacio de trabajo Simulink

En el espacio de trabajo de Simulink se creará un modelo insertando los bloques

correspondientes. En el caso del proyecto se insertaran del Toolbox Simulink de la Figura 2-12 el

Commonly Used Blocks, de los cuales:

•Dos corresponderán a los In1 que serán las entradas de las variables que recibiremos del campo de

visión correspondientes a lo ejes coordenados del lugar donde se encuentre la celda flexible, tomando

como referencia la pinza que posee este.



78

•Dos Out1 que tendrán como significado cuanto es lo que nos debemos desplazar para poder llegar

hasta el objeto en cuestión a capturar.

•Un Mux el cual es un Multiplexar escalar o un vector de señales, esto para poder enviar las

información a la maquina lógica.

•Un Demux el cual parte las señales obtenidas de la maquina logica en escalares o pequeños vectores,

permitiendo entregar esos valores a las correspondientes salidas.

•Por ultimo 1 Fuzzy Logic Controller el cual se obtiene del toolbox llamado Fuzzy logic Toolbox, el

cual representa al FIS Editor que se puede ver en la Figura 2-7.

Cada uno de estos bloques son arrastrados desde la Figura 2-12 hasta el entorno de trabajo de

Simulink, para ser utilizados según lo que se desee realizar, en el caso del proyecto al realizar todas las

uniones necesarias se logra lo que se ve en la Figura 2-13.

3.8.3.3 Integración Fuzzy Toolbox y Simulink

Este paso se debe realizar una vez diseñado el controlador, el cual fue guardado en un archivo

“.fis”. Se debe estar trabajando en el espacio de trabajo de Simulink y poseer uno de los bloques Fuzzy

Logic Controller en ese entorno, luego se debe hacer doble click sobre uno de estos bloques al cual le

incluiremos el controlador abriendo la ventana que se puede observar en la Figura 2-13.

Figura 2-14: Integración Controlador creado en Fuzzy Toolbox a Simulink



79

El parámetro que se le debe dar es el que se encuentra seleccionado, el cual corresponderá al

nombre de la variable exportada del controlador mencionado anteriormente en la sección Guardar y

Exportar al Workspace.

A partir de este punto ya se puede realizar pruebas en el sistema creado, cambiando las

variables de entrada por Const (ubicadas en Commonly Used Blocks) los cuales son números

constantes en las variables de entrada y las variables de salidas por Display (ubicada en Sinks) los

cuales son literalmente display's que mostraran en valor numérico la salido obtenida, todo esto ubicado

la sección de Simulink. Cabe decir que esta es una de las posibles formas de probar el controlador

realizado, esto puede variar según el nivel de conocimiento que tenga la persona sobre el manejo de

Simulink.

3.8.4 Generación de Código C en Simulink

Simulink nos proporciona la posibilidad de generar código C sin necesidad de escribirlo a partir

de los modelos previamente creados, esto es invocando al generador de código C que permite convertir

el diagrama de bloques implementado en un código C, pudiendo configurarse de distintas formas para

poder entrar a las opciones se debe dirigir al menú Tool->Real-Time Workshop->Option ..., aparecerá

la ventana de la Figura 2-15.



80

Figura 2-15: Configuracion Real-Time Workshop

En ella se puede seleccionar el lenguaje al que se quiere generar el código, en el caso del proyecto C o

C++, además de ello se puede generar si se desea solamente el código. Pinchamos sobre el botón

Browser de la Figura 2-15 generando la ventana mostrada en la Figura 2-16, acá uno puede seleccionar

el sistema de archivo de destino que se desee, en el caso del proyecto seria el seleccionado en la Figura

2-16, ert.tcl Real Time Workshop Embedder Coder

Figura 2-16: System Target File Browser



81

Una vez realizado esto se procede a seleccionar Solver del menú izquierdo de la Figura 2-15, la

ventana que aparecerá se muestra el la Figura 2-17, acá uno puede cambiar el tiempo que va a durar la

simulación, si se desea puede dejarse como Inf., o sea, sin tiempo de termino. Otro parámetro a ser

cambiado es en el recuadro Solver Options, en Type seleccionar Fixed-step, con lo cual ocurrirá una

disminución en la cantidad de opciones, seleccionando alado de type posteriormente la primera opción

“discrete”.

Figura 2-17: Configuración Solver

A partir de estas opciones ya es posible generar el código-C diseñado puede ser ejecutado en

tiempo real, dirigiéndose en el menú de la Figura 2-13 (espacio de trabajo simulink) a Tool->Real-Time

Workshop->Build Model, generándose de esta forma el código el cual no necesita ser escrito

manualmente por un programador pues es creado a nivel de diagramas de bloques en Simulink. El

código generado debido a su naturaleza al ser compilado en alguna maquina este correrá sin ningún

problema en ella (este código que se genera es el que utiliza Simulink cuando realiza una simulación).



82

Una vez compilado queda en el workshop en el que se encuentra trabajando, dejando una

carpeta con el nombre del modelo hecho en simulink mas “_ert_rtw”, quedando dentro de ella las

diferentes achivos, tanto .c como .h

Los archivos mas importantes son:

NombreModelo.c: Algoritmo del modelo.

NombreModelo.h: Inclusión de cabeceras , declaración de estructuras a Parámetros, Bloques, Estados,

Entradas y Salidas.

NombreModelo_data.c: Inicializa las variables de parámetros con los valores iniciales.

NombreModelo_types.h: Declara estructuras como tipos de datos.

NombreModelo_private.c: Definiciones comunes necesarios por el modelo y los subsistemas.

rtwtypes.h: Define los tipos en el sistema

ert_main.c; El prototipo para dejar funcionando el sistema creado, una especie de main pero

incompleto.

Un aspecto importante a resaltar es que para poder compilar estos archivos es necesario

incorporar el siguiente archivo: rtlibsrc.h el cual define tipos de datos en el sistema, este se encuentra

en Archivos de programa\MATLAB\R2008a\rtw\c\libsrc, la dirección puede variar dependiendo de la

versión de Matlab instalado.

Este puede ser útil para varios propósitos: puede ser usado para control en tiempo real,

simulación en tiempo real o simulación acelerada en tiempo no real. Sus aplicaciones pueden ser

control de movimiento, control de procesos, sistemas automotores, equipos médicos, robótica, etc.



83

3.9 Diseño e implementación

3.9.1 Diagrama de Bloques

Mediante este sistema que permite en matlab modelar distintos tipo de sistemas sean o no

lineales ademas de discretos. Siendo factible para nosotros poder modelar lo que se ha hecho en la

maquina difuza, el modelo seria el siguiente:

Figura 2-18: diagrama de bloque correspondiente a la logica difusa realizado con Matlab

Con este diagrama se puede ir probando los valores apretando en el

botón el cual procesará la máquina que se ha construido, mediante las constantes que aparecen a la

izquierda, haciendo dobleclick sobre éstas se pueden cambiar sus valores, una vez realizado esto se

hace click en el símbolo el cual produce el comienzo de la simulación, mostrándose en los displays de

la derecha el resultado correspondientes en porcentaje de los ejes X e Y.



84


El primer problema surgido fue con que elemento de programación poder darle cierto raciocinio

a nuestro sistema, es por ello que acudimos a Don Christian Aguillera quien nos pudo ayudar a decidir

la opción a elegir para poder terminar dichas incertidumbres, posteriormente surgir otra problemática,

debido a que utilizaríamos el toolbox de matlab, nuestro primer desafío consistió en comprender las

nociones básicas que posee matlab, incluyendo a Simulink con el que utilizaríamos nuestro sistema,

debido a que se puede modelar en bloque se hizo un diseño modesto de que necesitaríamos,

enfocándonos posteriormente a la concretación del la lógica mediante la comprensión de la teoría que

hay que poseer para poder desarrollar nuestras variables de entradas y de esta forma fusificarlas y luego

de su tratamiento a través de las reglas de conocimiento que fueron un desafío poder ir viendo como

cada una de las variables lingüísticas declaradas se podría mezclar entre si para darnos ciertos valores

lingüísticos de salida conformando de esta forma el conocimiento necesario que poseería nuestro

sistema para poder realizar la hazaña de alcanzar desde un punto fijo el recorrido necesario para

alcanzar el objeto.

Con respecto a como se realizaron estas reglas, se tuvieron que hacer distintas pruebas,

realizándolo primeramente mediante nuestro diseño e implentación de este por medio de simulink y asi

saber si los valores de salida correspondientes a porcentajes nos servirían mas menos para nuestro plan

final de localización del objeto, siendo este un proceso complejo de varias pruebas y aplicaciones de

conocimientos que se realizó en forma exhaustiva.


Capítulo 4: Robótica

85

4 Robótica

Como sabemos para el desarrollo de nuestro proyecto una de las partes fundamentales es la

utilización de un brazo robótico, el cual tomará el objeto seleccionado previamente a través de la

aplicación.

Por lo tanto este capítulo consiste en la descripción y estudio del funcionamiento del brazo

robótico Scorbot ER-V Plus perteneciente al laboratorio de sistemas automatizados de producción

CIMUBB de nuestra casa de estudios, con la finalidad de lograr el conocimiento necesario para

integrarlo a la aplicación desarrollada y que sea de esta manera un aporte a contribuir en el total logro

de los objetivos propuestos.

En primera instancia damos a conocer el laboratorio CIMUBB donde se encuentra la estación de

trabajo para el proyecto, luego de esto describimos a cabalidad la celda flexible, para dar a conocer su

funcionamiento y características principales que se deben conocer para el desarrollado del sistema,

entonces después de conocer su modo de operación, pasamos a interiorizarnos en establecer la

comunicación de una aplicación desarrollada por nosotros que nos permita comunicarnos directamente

con el brazo robótico, sin necesidad de un terminal de acceso como el modo ATS, esta parte es

fundamental debido a la necesidades planteadas en los requerimientos y que nos va permitir además

integrar una de las fases con el sistema en general.

También otro aspecto importante es conocer los comandos del lenguaje ACL que son necesarios

para el movimiento y articulación del brazo en sus distintos ejes y componentes, entonces se realiza

una descripción de los comandos básicos a utilizar y una descripción de su funcionamiento en

conjunto.

Para finalizar este se dan a conocer los resultados obtenidos además de nuestras impresiones, a

lo largo del desarrollo necesario para esta etapa, también se muestran las problemáticas enfrentadas en

el trabajo y como se enfrentaron.



86

4.1 Laboratorio de Sistemas Automatizados de Producción CIMUBB

Este laboratorio propiamente tal pertenece a la Facultad de Ingeniería de nuestra Universidad del

Bío-Bío, quien en conjunto con el ministerio de Educación del Estado de Chile lo financiaron,

surgiendo de esta manera en el año 2000 El Laboratorio de Sistemas Automatizados de Producción.

Demostrando la importancia de las industrias manufactureras en la contribución al desarrollo de

las naciones industrializadas, y hacer parte de esto a nuestro país, La industria manufacturera

comprende la elaboración de materias primas, productos semi-elaborados y productos terminados, los

cuales se transan en el mercado nacional o internacional, gracias a los tratados de libre comercio

obtenidos por el Estado en los últimos años. Por lo que la aplicación de la tecnología Informática-

Computacional ha permitido grandes avances en el desarrollo de procesos industriales, ya sea

agilizando las fases del proceso productivo, organizacional y comunicacional dentro de la industria,

obteniendo de esta manera una baja en los costos proporcional al volumen de unidades producidas,

además de una mejora considerable en la metodología de trabajo.

El cambio producido en los procesos industriales ha sido significativo, ya que logró conectar los

procesos productivos que antes se encontraban aislados en un sólo sistema integrado, permitiendo la

comunicación de las diferentes áreas de la empresa y que cada una de ellas tiene influencias sobre las

demás y así sucesivamente.

Cuando ésta integración se establece completamente en un sistema de manufactura se estaría

hablando de CIM o actualmente sería un ERP, que hoy representa la herramienta de gestión mas

avanzada y eficiente hasta la fecha en materia de integración.

El laboratorio de la Universidad se encuentra constituido pos sistemas de control de alta

calidad, maquinas CNC, posee estaciones de trabajo CAD/CAM/CAE y también de simulación,

integrando todo bajo el concepto CIM, logrando la automatización casi completa del ciclo del

producto, abarcado desde la etapa del diseño hasta la propia fabricación, considerando una perspectiva

de integración tanto horizontal como vertical.



87

Algunos de los temas que se desarrollan en el laboratorio CIMUBB son:

• Gestión y Modelación de Sistemas Automatizados de Producción.

• CAD / CAM / CAE.

• Control Automático de Procesos Discretos, Sensores e Instrumentación.

• Redes Locales Industriales (LAN Industrial).

• Procesamiento de los Materiales.

• Transferencia Tecnológica.

• Robótica.

• Visión Artificial.

En nuestro proyecto como sabemos los temas que nos incumben corresponden al área de la

robótica y de la visión artificial, manejadas ambas a través del desarrollo de una aplicación simple, que

permita manipular estas dos partes. Como describiremos a continuación utilizamos el Robot Scorbot

ER V Plus de la estación de Trabajo 3 del CIMUBB, como también una cámara web que nos brindará

el soporte en el tema de visión artificial.

4.2 Scorbot – ER V Plus

Para nuestro proyecto utilizamos la celda flexible Scorbot – ER V plus del CIMUBB, este brazo

es un robot vertical articulado con cinco juntas rotativas. Además el robot posee seis grados de libertad.

Su controlador autónomo y multitarea trabaja en tiempo real, permitiendo ejecutar simultáneamente e

independientemente hasta un total de 20 programas en memoria, podemos decir también que es un

robot rápido, seguro, flexible y fiable, que esta diseñado para formación, investigación y aplicaciones

en laboratorio.

Los movimientos que las juntas rotativas pueden ejecutar son descritos a continuación:



88

Figura 3-1: Especificación de la Junta y la Acción.

Número de eje Nombre de la junta Acción que realiza 1 Base Gira el cuerpo (body) 2 Shoulder Sube o baja el brazo superior (uper arm) 3 Elbow Sube o baja el antebrazo (fore arm) 4 Wrist pitch Sube o baja la pinza (gripper) 5 Wrist roll Gira la pinza (gripper)

Figura 3-2: Tabla explicativa de la Junta y su correspondiente Acción.

Este controlador posee además 16 entradas y 16 salidas, destinadas a recibir y transmitir señales

de dispositivos externos que interactúen con el robot, estos pueden ser sensores, pulsadores, entre otros.

En las salidas tenemos que la mayoría son de transistor y tan solo 4 son a relay. Los parámetros del

controlador incluyen constantes proporcionales, diferenciales e integrales para cada uno de los ejes,

protecciones térmicas, de impacto, límites, compensado de centro de herramientas, parámetros de la

pinza y varios otros cálculos de parámetros. La totalidad de los 200 parámetros de control pueden ser

manejados por el usuario.

También el Scorbot posee un botón de parada de emergencia o interrupción completa en caso de

pruebas erróneas en las cuales se debe evitar cualquier daño a la celda flexible, por lo que este botón

desconecta el sistema y enciende una luz roja de alerta.

Internamente el controlador incluye el lenguaje ACL, que aporta las capacidades de



89

programación avanzada. Permitiendo el control de la trayectoria continúa, interpolación líneal y

circular, también permite optimización de trayectorias, entre diferentes perfiles de control. El efecto

final de la trayectoria se puede definir como una fórmula general de trabajo del robot.

El Scorbot ER-V plus es considerado un robot ideal tanto para el estudio del control y

aplicaciones. Permitiendo realizar pruebas del control del circuito abierto o cerrado con varios tipos de

velocidad, ya sea parabólica, trapezoidal, de funcionamiento libre, aceleración y desaceleración.

Especificaciones Técnicas Scorbot ER-V Plus:

Scorbot ER-V Plus (Brazo Mecánico) Número de ejes 5 más pinza Construcción Brazo vertical articulado Radio de operación 610 mm Movimiento de los ejes Var. Ejes Vel. Compuesta Eje 1:Base Eje 2:Brazo inferior Eje 3:Brazo superior Eje 4:-elev. pinza Eje 5:Giro pinza

310º +130/-35º +/-130º +/-130º

600mm/seg.

Velocidad Puede cambiarse en incrementos de un 1% Capacidad de carga 1kg. en la extensión del brazo Repetibilidad 0. 5mm Tipo de motores 6 servomotores DC con control de lazo cerrado Transmisión Engranaje con correa dentada. Realimentación Encoders ópticos de alta resolución Abertura de la pinza 75mm. con almohadillas de goma, 65mm con ellas. Antibacklash El eje de la base es soportado por sistema de engranaje tipo

antibacklash Sincronización del robot (Home)

Búsqueda punto 0 de referencia en todos los ejes, usando microinterruptores

Peso del brazo 10.8 Kg Temperatura ambiente de funcionamiento

2º C a 40º C

Figura 3-3: Especificaciones Técnicas del Robot.

Para el manejo del Scorbot – ER V plus se cuenta con diferentes modos de operación que en



90

siguiente punto se trataran.

4.3 Modos de Operación:

Software

ACL (Advanced Control Lenguage)

Es un avanzado lenguaje de programación de robots, y con el cual nos podemos comunicar de esta

forma con el Scorbot – ER V plus, proporcionando las siguientes funcionalidades:

• Control directo de los ejes robóticos.

• Programación por el usuario del sistema robótico.

• Control de entradas/salidas.

• Ejecución de programas simultanea, sincronizada e interactiva; soporte multi-tasking completo.

• Fácil gestionamiento de archivos.

ATS (Advanced Terminal Software)

Corresponde a la interfaz para el ACL. Este software es un emulador de terminal para el acceso al

ACL desde un computador (Figura 3-4), entre sus acciones este permite la captura de las posiciones del

robot, la edición de programas y la descarga de un programa realizado en un procesador de textos.

Utiliza Lenguaje de programación ACL y comandos de acción directa.

Este modo fue clave para conocer el funcionamiento y manipulación del Scorbot a través del

lenguaje de programación ACL, proporcionándonos su posición actual, cambio de posiciones,

movimientos de sus ejes, creación de programas entre muchas otras funcionalidades. Por lo tanto el

modo ATS permite:

• Forma corta de configurar el controlador.

• Manejar desde una computadora el robot.



91

• Definición de periféricos.

• Editor de programas.

• Teclas de short-cut para entrar.

• Bakup manager.

Figura 3-4: Modo ATS.

Teach Pendant

Este es un dispositivo opcional, es una terminal de mano, usada para controlar el robot y los

periféricos conectados al controlador. Es práctico para el movimiento de ejes y control de pinza,

grabado de posiciones, direccionamiento de los ejes a posiciones grabadas y ejecutar o abortar

programas en el controlador (en caso de emergencias). Provisto de control de aprendizaje de posiciones

en coordenadas XYZ y de articulaciones, trabaja tanto en coordenadas joint como en cartesianas, teclas

multifunción, pantalla LCD de 32 caracteres. En la Figura 3-5 podemos ver como es el Teach Pendant.



92

Figura 3-5: Teach Pendant.

4.4 Inicialización

Como sabemos la posición de los ejes es medida por encoders que registran la variación de

movimiento referida a una posición inicial. Se recomienda para que el robot funcione correctamente

que esta posición debiera ser la misma cada vez que el robot sea utilizado. Para ello el controlador tiene

un programa interno llamado “home”, el cual deberá ser ejecutado cada vez que se ponga en marcha el

robot.

Para ejecutar el homing desde el PC se escribe en el ATS:

>home <enter>

Para ejecutar el homing desde el teach pendant (TP) oprima:

run – 0 - enter

Para inicializar los ejes (ya sea del robot o de los periféricos) escriba en el ATS:

>home nº de eje



93

4.5 Operación del Robot

Modo manual

Este modo se puede ejecutar cuando el sistema esta en modo directo, la función que tiene este

modo es permitir el control directo de los ejes sin la necesidad de usar el Teach Pendant. Para activar el

modo manual solo basta presionar las teclas: <alt> + m

Teclas de Acción Eje

Q – 1 eje 1 W – 2 eje 2 E – 3 eje 3 R – 4 eje 4 T – 5 eje 5 Y – 6 eje 6 U – 7 eje 7 I – 8 eje 8

Figura 3-6: Teclas Modo Manual.

Modo directo

Cuando el sistema esta en modo directo, el usuario tiene el control directo de todos los ejes del

robot. El controlador va ejecutando los comandos a medida que van siendo ingresados por el operador.

Cuando se esta en modo directo, el prompt aparece en pantalla de la siguiente manera: >_

4.6 Sistemas de coordenadas

Coordenadas joint: Especifican la posición de los ejes robóticos en unidades de encoders, ya que

estos proporcionan un número de señales proporcional al movimiento de los ejes.

Coordenadas cartesianas: Es un sistema geométrico para especificar la posición del punto central de

la herramienta del robot TCP definiendo la distancia en unidades lineales (décimas de milímetros)



94

desde el origen situado en la base, para efecto de nuestro proyecto este va a ser el sistema de

coordenadas que vamos a emplear, considerando solo los ejes X e Y por ubicación y referencia de la

cámara que se esta ocupando, entonces las posiciones del eje Z van a estar predefinidas con

anterioridad y no serán efecto de estudio en este proyecto.

Figura 3-7: Sistema de Coordenadas.

4.7 Rol que Cumple el Robot Scorbot ER-V Plus en el Proyecto

Los Puntos de este capítulo tratados anteriormente fueron de vital importancia para que en

primera instancia nos familiarizáramos con el robot, ya sea conocer sus partes, que es lo primero que

debemos hacer antes de comenzarlo a utilizar, que hacer en caso de querer abortar una operación,

conocer su sistema de coordenadas, su lenguaje de programación, en que modo utilizarlo, entre

muchos otros aspectos que debemos indagar para poder obtener de el su mayor provecho, para que de

ésta manera contribuya al cumplimiento de los objetivos del proyecto.

Con todo esto ya claro sabemos que el brazo robótico es una de las partes mas importantes en el

proyecto por no decir la más relevante, considerando que casa fase de desarrollo aporta su porcentaje a

lograr el objetivo final, por ello el rol que cumple en el proyecto es primordial, ya que va a ser quien

después de haber procesado la imagen se encargue de tomar el objeto, y lo desplace a una posición de

destino dentro de los limites de la superficie.



95

Y para poder tomar el objeto seleccionado en la aplicación debemos conocer primero a fondo

los comandos del lenguaje de programación ACL que se requerirán para el correcto funcionamiento del

robot y además cuales serán necesarios para lograr el objetivo de este capítulo que es mover el brazo

robótico por medio de la aplicación desarrollada. Este movimiento del brazo robótico ocurre como

consecuencia a partir de la integración entre la fase correspondiente al Análisis de la Imagen que nos

entrega el centroide del objeto en pixeles, pero éste se debe trasformar a décimas de milímetros que

corresponden a las unidades en que vamos a desplazar al Scorbot. Siguiendo la fase de análisis de

imagen se integra esta con la Fase de la Maquina de Lógica Difusa, en resumen ésta última fase del

sistema es la que interactuará con el Scorbot, es decir le irá indicando hacia donde se debe ir moviendo

hasta que la máquina difusa le diga que se encuentra en posición de tomar el objeto que se seleccionó

previamente a través del sistema, por lo que esta aplicación debe tener claro como hacer moverse al

Scorbot.

Todo este tema de la integración se verá en el capítulo final del proyecto donde todas las demás

fases de desarrollo se unirán y se verá con mas claridad como se integran al sistema final y de que

forma fueron integradas.

Este análisis nos dejó como consecuencia el establecer los movimientos que debe realizar el

Scorbot, por lo que vamos a tener que identificar y seleccionar el conjunto de pasos a seguir,

estableciendo un orden en la ejecución de comandos ACL para que el robot se pueda desplazar.

También debemos ver la forma de comunicar el Scorbot con la aplicación que estamos desarrollando ya

que la interacción va a estar a cargo de este sistema y no por el modo ATS o por el Teach Pendant ni

modo manual, solo a través de comandos en leguaje ACL.

4.8 Comunicación Por Puerto Serial

Como necesitamos interactuar directamente con el Scorbot a través de la aplicación que

estamos desarrollando, vimos primero que este se conecta al computador directamente al puerto serial



96

con el conector RS-232 (el cual es una interfaz que se designa para el intercambio de datos binarios).

El puerto serial en años anteriores era uno de los accesos de comunicación más comunes que

permite conectar periféricos, como lo es el caso del robot Scorbot, otros de estos dispositivos pueden

ser mouse, teclado, modem o simplemente establecer una conexión entre computadores, pero como

sabemos en la actualidad este dispositivo se ha reemplazado por el “USB” debido a la rapidez al enviar

datos que este posee.

La comunicación que se establece con el robot es bit a bit, es decir permite enviar un bit a la

vez, al contrario de dispositivos de transmisión más modernos que envían varios bit simultáneamente.

Por lo tanto debemos buscar un lenguaje de programación en el cual podamos comunicarnos a

través del puerto serial con la celda flexible y además debe ser compatible en la integración con la

aplicación que junta todas las fases de desarrollo del proyecto.

Luego de tener muy presente estas restricciones optamos por realizar la conexión del puerto

serial con el Scorbot en el lenguaje de programación C, debido a la compatibilidad entre la interfaz del

sistema que es desarrollada en C++, destacando así la línea de la eficiencia en la aplicación y la

portabilidad.

4.9 Comunicación Serial en el Lenguaje de Programación C

Como sabemos este lenguaje de programación fue creado en la década de los 70 por Dennis M.

Ritchie, cuyo propósito es lograr la eficiencia de sistemas, tanto operativos como de aplicaciones.

Conocemos de antemano sus ventajas que representa el programar en C debido a que es posible

utilizar sus características de bajo nivel para realizar implementaciones óptimas, además debemos

agregar la portabilidad de este a los diversos sistemas operativos, trasformando así nuestras

aplicaciones en sistemas multiplataformas.



97

Para la implantación de la comunicación serial vamos a utilizar la librería LnxComm que fue

diseñada especialmente para entregar apoyo a personas involucradas en el diseño y construcción de

hardware, además de programadores que estén interesados en manejar este conocimiento, esta librería

permite establecer una conexión con el puerto serial solamente programando escasas linead de código,

proporcionando de esta manera una mejor forma de entender este concepto, ya que esta librería tiene lo

necesario para comunicarnos tanto en Linux como en Windows a través del puerto serial, apoyando la

portabilidad de nuestros códigos desarrollados. Esta librería esta en su totalidad desarrollada en

Lenguaje C.

Como ya dijimos esta librería tiene funciones, las cuales cumplen las mismas características

tanto para Linux como para Windows.

Las funciones con las que cuenta son las siguientes:

Open_Port

Esta corresponde a la función de lectura del puerto serial.

HANDLE Open_Port(char COMx[]);

Abre el puerto de comunicaciones, esta función recibe como parámetro una cadena con el

nombre del puerto y devuelve una variable de tipo HANDLE que es el manejador del puerto. Este

HANDLE es un índice a una tabla, ya que sirve para almacenar dependiendo de la arquitectura 16, 32,

64 bits, por lo tanto este corresponde en Windows, a una referencia a una estructura de datos interna del

sistema.

COMx[] : Es una cadena que contiene el nombre del puerto a abrir, como por ejemplo.

“COM1″ , “COM2 ″ , “COM3 ″ , “COM4 ″ ,…

“/dev/ttyS0 ″ , “/dev/ttyS1 ″ , “/dev/ttyS2 ″ , “/dev/ttyS3 ″ , …



98

“/dev/ttyUSB0 ″, “/dev/ttyUSB1 ″, “/dev/ttyUSB2 ″, “/dev/ttyUSB3 ″, …

“/dev/ttyACM0 ″, “/dev/ttyACM1 ″, “/dev/ttyACM2 ″, “/dev/ttyACM3 ″, …

Retorna: Esta retorna el manejador de puerto que se encuentra abierto

Get_Configure_Port

Nos entrega la configuración actual del puerto serie.

DCB Get_Configure_Port(HANDLE fd);

Esta función devuelve un variable de tipo DCB con la configuración actual del puerto serie, la

función recibe un parámetro de tipo HANDLE que es el manejador con la configuración actual del

puerto, devuelto por la función Open_port

fd : Es el HANDLE manejador del puerto.

Retorna: Una estructura DCB con la configuración actual del puerto.

La estructura DCB define los valores de control para dispositivos de comunicación serie.

typedef struct _DCB { DWORD DCBlength; // sizeof(DCB) DWORD BaudRate; // velocidad en baudios actual DWORD fBinary: 1; // modo binario, no se comprueba EOF DWORD fParity: 1; // comprobación de paridad activa DWORD fOutxCtsFlow:1; // CTS control de flujo de salida DWORD fOutxDsrFlow:1; // DSR control de flujo de salida DWORD fDtrControl:2; // DTR tipo de control de flujo DWORD fDsrSensitivity:1; // DSR sensitividad DWORD fTXContinueOnXoff:1; // XOFF continuar Tx DWORD fOutX: 1; // XON/XOFF control de flujo de salida DWORD fInX: 1; // XON/XOFF control de flujo de entrada DWORD fErrorChar: 1; // activa reemplazo de error DWORD fNull: 1; // activa null stripping DWORD fRtsControl:2; // RTS control de flujo DWORD fAbortOnError:1; // aborta lectura/escritura si hay error DWORD fDummy2:17; // reservado WORD wReserved; // no usado WORD XonLim; // transmitir umbral XON WORD XoffLim; // transmitir umbral XOFF BYTE ByteSize; // número de bits por byte, 4-8



99

BYTE Parity; // 0-4=no, impar, par, marca, espacio BYTE StopBits; // 0,1,2 = 1, 1.5, 2 char XonChar; // carácter XON para Tx y Rx char XoffChar; // carácter XOFF para Tx y Rx char ErrorChar; // carácter de reemplazo para errores char EofChar; // carácter de fin de entrada char EvtChar; // carácter de evento recibido WORD wReserved1; // reservado; no usar } DCB;

Configure_Port

Con esta función podemos establece la nueva configuración del Puerto serial dependiendo del

periférico que queremos manejar, en nuestro caso corresponde al scorbot ER V Plus, que necesita

manejarse a 9600 baudios, bits de datos de tamaño 8, ninguna paridad y bit de parada 1.

DCB Configure_Port( HANDLE fd, unsigned int BaudRate, char CharParity[]);

Esta función configura el puerto serie con los parámetros fd, BaudRate y CharParity.

fd : Es el manejador del puerto devuelto por la función Open_Port.

BaudRate : Es la velocidad del puerto. (B115200, B19200, B9600, ...)

CharParity: Indica el numero de bits de la transmisión. (”8N1″,”7E1″,”7O1″,”7S1″)

Retorna: Una estructura DCB con la configuración del puerto

Set_Configure_Port

Establece la configuración del puerto, es decir reestablezco la configuración antigua del puerto

una vez que terminamos de usarlo, esto debe ocurrir antes de cerrar el puerto serie.

int Set_Configure_Port( HANDLE fd,DCB PortDCB);

Restituye la configuración del puerto serie, los parámetros serán pasados mediante una variable tipo

DCB.

fd : Es el manejador del puerto devuelto por Open_Port



100

oldConf : Es una variable DCB con la configuración del puerto, generalmente se usa la devuelta por

la funcion Get_Configure_Port.

Retorna: TRUE si todo fue bien o FALSE si hubo algún error.

Write_Port

Como lo indica su nombre esta función escribe un bloque o cadena de datos en el puerto serie.

long Write_Port( HANDLE fd, char Data[], int SizeData);

Escribe los SizeData primeros caracteres de Data en el puerto serie.

fd: Es el manejador del puerto devuelto por Open_Port.

Data: Es el dato a mandar.

SizeData: Es el número de bytes que se quieren escribir.

Retorna: En caso de éxito este devuelve el número de bytes escritos, en cambio si es cero indica que no

se ha escrito nada y en caso de error, se devuelve -1.

Read_Port

Esta es para leer un bloque de datos en el puerto serial.

long Read_Port( HANDLE fd, char *Data, int SizeData);

Lee los SizeData primeros caracteres del Puerto y lo carga en Data.

fd : Es el manejador del puerto devuelto por Open_Port.

Data: Es la variable en donde se reciben los datos.

SizeData: Es el número de bytes que se quieren recibir.

Retorna: En caso de éxito se devuelve el número de bytes leídos, cero indica que no se ha leído nada y

en caso de error, se devuelve -1.



101

Gets_Port

Recibe una cadena de tipo texto en el puerto.

long Gets_Port( HANDLE fd,char *Data,int SizeData);

Recibe datos por el puerto, lee hasta encontrar un 0×0A,0×0D o hasta completar SizeData caracteres.

Los datos son guardados en la variable Data


Data: Es la variable en donde se reciben los datos.

SizeData: Es el máximo número de bytes que se quieren recibir.

Retorna: El numero de caracteres recibidos.

Getc_Port

También recibe un carácter por el puerto.

long Getc_Port( HANDLE fd, char *Data);

Recibe un único carácter por el puerto y es cargado en la variable Data de tamaño 1 byte.


Data: Es la variable en donde se reciben los datos (1 Byte).

Retorna: El numero de caracteres recibidos.

Kbhit_Port

Indica el estado del buffer de entrada, este estado nos indica el número de caracteres disponibles en

buffer.

int Kbhit_Port( HANDLE fd);



102

Recibe como parámetro el manejador del puerto.


Retorna: El numero de caracteres en el buffer de recepción

Close_Port

Simplemente cierra el puerto serie que hemos abierto previamente.

int Close_Port( HANDLE fd);

Recibe la variable fd y cierra el puerto.


Retorna: TRUE si se ha cerrado el Puerto y FALSE en el caso contrario.

Set_Hands_Haking

Configura el control de flujo en el puerto serie.

int Set_Hands_Haking( HANDLE fd,int FlowControl);

Recibe como variables el manejador del puerto y el tipo de control de flujo.


FlowControl: Es un numero entero que indica el tipo de control de flujo.

0 Ninguno

1 RTSCTS

2 XonXoff

3 DTRDSR



103

Retorna: TRUE si todo fue bien y FALSE si no lo fue.

Set_BaudRate

Configura la velocidad del puerto serie.

int Set_BaudRate( HANDLE fd,unsigned int BaudRate);

Recibe como datos el manejador del puerto y la velocidad del mismo.


BaudRate: Es la velocidad del puerto, los valores pueden ser por ejemplo B2400, B9600,

B19200 entre otras.


Set_Time

Configura temporizador para lectura y escritura.

int Set_Time( HANDLE fd,unsigned int Time);

Recibe como variables, el manejador del puerto y el máximo tiempo entre bytes en milisegundos


Time: Multiplicador en m-seg, para el tamaño total de time-out en lectura y escritura.

Timeout = (Time-m-seg * number_of_bytes)




104

IO_Blocking

Escoge como modo bloqueante o no bloqueante para la lectura en el puerto.

int IO_Blocking( HANDLE fd,int Modo);

La función recibe como parámetro el manejador del puerto y TRUE si se quiere una conexión

bloqueante o FALSE si no.


Modo: TRUE : Modo bloqueante.

FALSE: Modo no bloqueante.


Clean_Buffer

Termina las operaciones de lectura y escritura pendientes y limpia las colas de recepción y de

transmisión de datos.

int Clean_Buffer( HANDLE fd);

La función recibe como parámetro el manejador del puerto.


Retorna: TRUE si todo fue bien es decir si limpio y FALSE si no pudo.

Create_Thread_Port

Crea una función hilo que se ejecuta cuando existan caracteres en el buffer de de entrada del

puerto.



105

pthread_t Create_Thread_Port( HANDLE *fd);

Recibe como parámetro el manejador del puerto y devuelve una variable de tipo pthread_t


Retorna: El manejador del hilo creado.

Esas serian las funciones básicas para manejar, controlar, configurar, setear, limpiar, leer,

escribir en el puerto serial entre otras. Como mencionamos al principio de la descripción de la librería

esta posee portabilidad a múltiples plataformas, para ello se debe modificar la cabecera dependiendo

del sistema operativo:

Linux:

#define __LINUX_COM__

#include “com/serial.h”

Windows:

#define __WINDOWS_COM__

#include “com/serial.h”

La función Open_Port también cambiara de argumento según el sistema operativo.

Linux:

“/dev/ttyS0 ″ , “/dev/ttyS1 ″ ,…

“/dev/ttyUSB0 ″, “/dev/ttyUSB1 ″,…

“/dev/ttyACM0 ″, “/dev/ttyACM1 ″,…

Windows:

“COM1″, “COM2, “COM3 ″,…



106

4.10 Monitoreo del Puerto Serial

La parte de la comunicación mediante puerto serial ya se encuentra definida, ahora debemos

comunicarnos con el robot, es decir debemos enviarle comandos en lenguaje ACL, ya que su

controlador interno solo entiende estos comandos.

Para ello se debe en primera instancia conectarse con el puerto serial y luego escribir en el.

Como sabemos que se puede enviar una cadena de caracteres, ésta va a ser el comando ACL, pero

dentro de un formato especifico, es decir, no es solamente enviar el comando que queramos, este debe

tener una especie de orden y formato, por ejemplo deseamos comunicarnos con el scorbot para

indicarle que realice el siguiente comando “move 0”, esto quiere decir que el scorbot se desplace a su

posición de inicio, que corresponde a la misma en la cual se mueve el scorbot al encenderlo, es como

una especie de homing, por lo tanto enviamos el comando de esta forma:

char mensaje[]="move 0"; // comado ACL

Write_Port(fd,mensaje,strlen(mensaje)); // escribir en el puerto

Luego de esperar una respuesta al haber escribir en el puerto serial nos dimos cuenta que ésta

nunca llego, y el Scorbot no realizó ninguna acción, entonces lo que necesitamos es conocer como

realmente envía los comandos el modo ATS al scorbot, ya que es la única forma que tenemos para

comunicarnos a través de comandos con el robot, es decir debemos monitorear que datos pasan por el

puerto serial realmente y de que forma, para que nosotros podamos de la misma manera enviar estos

comandos por medio de nuestra aplicación.

Para monitorear el puerto serial ocupamos el programa Free Serial Port Monitor, que nos

ayudara a verificar que datos realmente pasan por el puerto, al momento de escribir comandos en

lenguaje ACL en modo ATS y a la vez que respuesta podemos leer que nos envié el Scorbot.

Entonces debemos abrir el programa free serial y elegir la pestaña fichero y seleccionar de la

lista una nueva sesión, aparecerá entonces una ventana que nos indica un asistente de nueva sesión, hay



107

debemos presionar el botón siguiente, a continuación debemos elegir el tipo de sesión de monitoreo,

donde escogimos la primera de las tres que seria el monitor de puertos y presionamos siguiente

nuevamente y pasaremos a esta ventana que mostramos a continuación:

Figura 3-8: Selección del puerto COM.

Acá debemos seleccionar el puerto COM correspondiente, para nuestro caso sería COM1 y

presionamos siguiente, luego se nos abrirá la Aplicación de Elaboración de Datos



108

Figura 3-9: Seleccionamos que queremos visualizar al monitorear.

La figura 3-9, nos indica que deseamos monitorear, los datos, las señales, las llamadas, la

consola entre otras cosas, nuestro objetivo es ver los datos, por lo tanto lo seleccionamos. Una vez

realizado esto presionamos el botón finalizar para terminar con la configuración de monitoreo del

puerto serial.

El resultado de esto es una pantalla donde podemos apreciar en la parte superior una especie de

“Log”, donde se va registrando lo que se lee del puerto serial, y en la parte inferior se registra la

escritura en el puerto, con esto ya listo y el Scorbot ya conectado al computador y encendido, ahora

debemos abrir el modo ATS, una vez abierto comenzamos a escribir comandos para ir viendo que va

registrando el free serial tanto al momento de escribir como al leer del puerto serie (ver Figura 3-10 )



109

Figura 3-10: Monitoreo de Lectura y Escritura.

Al ver la figura anterior nos damos cuenta que los datos son registrados en estos “LOG”

(registros) en formato hexadecimal, por lo tanto cada representación hexadecimal corresponde a un

letra que ha sido escrita o leída correspondientemente en el puerto serial, al realizar una serie de

monitoreos tanto a la lectura como a la escritura nos dimos cuenta que podemos analizar estos datos de

la siguiente manera.

Lo primero es ver que sucede cuando abrimos el modo ATS, es decir, cuando este modo

establece la comunicación con el Scorbot, antes de enviar cualquier comando el free serial muestra que

el puerto COM a sido abierto, entonces al enviar el primer comando en el modo ATS, vemos en el free

serial que antes de enviarlo, como es el primer comando, se envía previamente la cadena “|echo\r\r\r”

(obviamente sin las comillas, es solo para destacar la cadena) que en hexadecimal corresponde ha 7C

65 63 68 6F OD OD OD ,esta cadena es para indicarle al Scorbot que a partir de ahora se van a enviar

comandos, para que el controlador del robot pueda procesarlos y cuando envia un comando, por

ejemplo open (para que abra la pinza), lo hace de esta manera “open\r” (en el free serial aparece la

misma cadena pero en hexadecimal 6F 70 65 6E OD), entonces cada vez que enviemos un comando

este debe ser acompañado del retorno de carro “\r”, por ejemplo



110

Al iniciar nuestra aplicación que se comunica por puerto serial con el robot, antes de enviar

cualquier comando, esta claro que previamente ya abrimos el puerto, obtuvimos su configuración y lo

configuramos según nuestras necesidades y le indicamos que iva a ser no bloqueante, debemos enviar

la siguiente cadena de caracteres

char mensaje[]="|echo\r\r\r"; // comado ACL

Write_Port(fd,mensaje,strlen(mensaje)); // escribir en el puerto

Una vez enviada la cadena anterior podemos enviar el comando que queramos

char mensaje2[]="open\r"; // comado ACL

Write_Port(fd,mensaje2,strlen(mensaje2)); // escribir en el puerto

Para un mejor entendimiento mostramos a continuación un simple ejemplo de comunicación

serial con el robot scorbot, escrito en lenguaje C, utilizando la librería LnxComm.

#define __WINDOWS_COM__ /* #define __LINUX_COM__ */ #include "serial.h" /* Incluimos las funciones para la

comunicación serial*/ void escrituraLecturaScorbot(char [],HANDLE); int main() { HANDLE fd; DCB OldConf; char inicializar[]="|echo\r\r\r"; /*inicializa el envio de comandos*/ char speed[]="speed 20\r"; /*cambia la velocidad*/ char open[]="open\r"; /*abre la pinza*/ char close[]="close\r"; /*cierra la pinza*/ char finalizar[]="|show par 1\r\03\03"; /*finaliza comunicación*/ int n; fd=Open_Port("COM1"); /* Abre el puerto serie fd=Open_Port("/dev/ttyS0"); */ OldConf=Get_Configure_Port(fd); /* guardo la configuración del



111

Puerto*/ Configure_Port(fd,B9600,"8N1"); /* Configuro el puerto serie */ IO_Blocking(fd,FALSE); /* Seleccionamos lectura no bloquenate */ escrituraLecturaScorbot(inicializar,fd); /* se llama a la funcion que escribe y lee del puerto serial*/ escrituraLecturaScorbot(speed,fd); escrituraLecturaScorbot(open,fd); escrituraLecturaScorbot(close,fd); escrituraLecturaScorbot(finalizar,fd); Set_Configure_Port(fd,OldConf); /* Restituyo la antigua configuración del puerto */ Close_Port(fd); /* Cierro el puerto serie */ printf("Presione ENTER para terminarn"); getchar(); return 0; }

void escrituraLecturaScobot(char mensaje[], HANDLE fd,)

{

char resp[100]="";

int n;

Write_Port(fd,mensaje,strlen(mensaje)); /*Escribimos en el puerto

serie */

Clean_Buffer(fd); /* Limpiamos el buffer*/

do{

n=Read_Port(fd,resp,100); /* Leimos del puerto*/

printf("resp: %s" ,resp);

memset(resp,'\0', 100); /*Limpiamos la cadena*/

if(n!=0) sleep(1000); /*Dormimos el proceso*/

else sleep(500);

}while(Kbhit_Port(fd)); /*Se ejecuta hasta que se



112

leean los caracteres

necesarios*/

Clean_Buffer(fd); /*Limpia buffer*/

printf("\n\nPresione ENTER para continuar");

getchar();

}

Lo que hace este ejemplo es establecer comunicación serial con el scorbot, para ello en primer

lugar abrimos el puerto COM1, luego obtenemos su configuración en una variable DCB, a

continuación configuramos el puerto de acuerdo al funcionamiento del Scorbot ER-V Plus y le

indicamos que vamos a realizar lectura no bloqueante.

A partir de este momento estamos en condiciones de indicarle al robot que le vamos a enviar

comandos, para alertarle de ello le enviamos la cadena de inicialización, para continuar con los

comandos que modifican su velocidad, abren la pinza, cierran la pinza y para finalizar enviamos el

comando que le indica al controlador del scorbot, que ya no le vamos a enviar mas comandos, y para

finalizar se restablece la configuración antigua del puerto y se procede a cerrarlo en ultima instancia.

4.11 Comandos ACL a Utilizar

En esta etapa debemos determinar cuales serán los comandos del Lenguaje ACL que vamos a

utilizar en la aplicación, recordando que estos comandos deben cumplir con el objetivo de poder mover

el brazo robótico, por lo que estas secuencias de comandos deben estar programadas internamente en la

aplicación que desarrollamos, por ello es importante definirlos en este capítulo. Ya que los comandos

que definamos acá son los que se necesitaran en la aplicación. Tabla de comandos necesarios.



113

Nombre del Comando Descripción

ECHO Es el primer comando que se necesita antes de enviar cualquier

acción al controlador.

MOVE 0 Realiza un proceso de inicialización de los ejes del robot.

SPEED 20 La velocidad se especifica en porcentajes. La velocidad

máxima es 100 y la mínima es 1, la velocidad por defecto es

50, para efectos del proyecto fijamos la velocidad en 20%

DEFP pos Crea una posición en el grupo A, en el grupo B o en un eje del

grupo C, si no hemos especificado un grupo supones el grupo

A. Lo que hacemos en nuestro caso es crearla de la siguiente

manera DEFP pos, esta crea una variable llamada pos en el

grupo A.

HERE pos Graba la posición actual en la variable de memoria pos creada

con DEFP o DIMP.

LISTPV pos

LISTPV POSITION

Despliega las coordenadas de la posición especificada pos en

valores de las articulaciones (encoders) y en coordenadas

Cartesianas. POSITION es un nombre reservado y se emplea

para desplegar las coordenadas actuales. Las coordenadas

Cartesianas X, Y, Z se expresan en décimas de milímetro, e

indican la distancia entre el origen del sistema global de

coordenadas del robot (en el centro y bajo la base) y el TCP

(Tool Center Point = Coordenada de la Punta de la Tenaza). P

(Pitch) y R (Roll) se expresan en décimas de grado. Estos

comandos son utilizados en el proyecto para conocer la

asignación de posiciones del robot dentro de la superficie, es

decir es empleada solo para el registro de posiciones, en la

aplicación desarrollada no se utiliza como tal, ya que tenemos

el control interno de los ejes cartesianos X, Y y Z a través de

variables.



114

SETPVC pos X 2799

Este comando esta pensado solo para modificar posiciones.

Permite cambiar una coordenada cartesiana en una posición

previamente registrada con el comando SETPV.

Tiene el siguiente formato SETPVC <pos> <coord> <valor>

Donde:

<pos> es una posición del robot (grupo A) definida

previamente por nosotros.

<coord> es una coordenada cartesiana: X,Y,Z,P o R.

<valor> esta en décimas de milímetros (X,Y,Z) o grado (P,R).

SETPV pos 1 -9000 Este comando esta pensado solo para modificar posiciones.

Permite cambiar el valor codificador de un eje en una posición

registrada. Se utiliza para setear valores en encoders.

SETPVC <pos> <eje> <valor> no avisa de coordenada de

punto inválida hasta que prueba y no lo alcanza.

MOVE pos Mueve el brazo a la posición definida en pos. Esta instrucción

“deposita” un comando de movimiento en el buffer de

movimientos, y no espera a que la operación haya sido

terminada para enviar otra instrucción de movimiento. Este

desplazamiento lo realiza de acuerdo a la velocidad actual

CLOSE Cierra la pinza hasta el fin de su movimiento.

OPEN Abre la pinza hasta el final de su movimiento.

DELP pos Borra las posiciones y los vectores de posición de la tabla de

posiciones.

SHOW PAR <n> Presenta el valor del parámetro del sistema <n>

Esta tabla nos indica el comando y una pequeña descripción de que es lo que hace y para que

sirve, en nuestro proyecto establecimos una rutina de comandos necesarios para ser utilizados en la

aplicación que tiene que ver con el manejo de la celda flexible, ya anteriormente vimos algo de esto en

el ejemplo de comunicación por el puerto serial con el scorbot.



115

Como sabemos esta rutina de comandos que corresponde a la que se implemento para tomar el

objeto a través de las indicaciones entregadas por la maquina de lógica difusa, debe estar compuesta

inicialmente por el comando ECHO, con el le indicamos al controlador que desde ahora en adelante se

van a enviar comandos para que este atento a escuchar en el puerto serial, a continuación enviamos el

comando MOVE 0, con este inicializamos los ejes de la celda a su posición de inicio, desde acá, lo que

hacemos antes de realizar cualquier movimiento es fijar la velocidad del scorbot en un 20%. Para que

los movimientos no sean tan rápidos y bruscos.

Con esto ya estamos listos para crear nuestra variable de posición con DEFP pos, esta variable

va a almacenar los valores cartesianos de la poscion del scorbot, en seguida realizamos un HERE pos,

esto quiere decir que le pasamos la posición actual del scorbot, por lo tanto se copia el valor del vector

POSITION en nuestra variable pos. Luego ya podemos indicarle al robot que valla a la posición que

hemos definido dentro de la superficie, esta es SETPVC pos x 2799, SETPVC pos y 90, SETPVC pos

z 3200. Estos valores son asignados como la ubicación por defecto del scorbot, tomando en cuenta

diferentes factores que fueron resultados de nuestro estudio, como por ejemplo que esta posición no

interfiera con la cámara web. Al setear los valores en la variable pos, debemos realizar este movimiento

con el comando MOVE pos, Con estos valores ya estamos en nuestra posición de partida que hemos

definido, por lo tanto estamos a la espera de que la maquina difusa nos indique hacia donde movernos.

Después de que esta maquina difusa nos haya guiado hasta posicionarnos encima del objeto,

debemos recordar que esta máquina sólo nos entrega información hacia donde movernos en los ejes X

e Y (debido a la ubicación de la camara web), por lo tanto el manejo del eje Z, es por defecto, que

quiere decir esto, que una vez posicionados en el centroide del objeto, bajamos en primera instancia

SETPVC pos z 1000 y también acomodamos la pinza en SETPVC pos P -890, para finalmente bajar la

pinza en SETPVC pos z 189, por lo tanto al enviar el comando CLOSE, la pinza se debe cerrar y

capturar de esta manera el objeto. Y para finalizar se lleva el objeto a la posición seleccionada dentro

de los límites de la superficie y se envía OPEN para soltar este objeto. Una vez ocurrido esto se lleva el

Scorbot fuera del alcance de la cama web para que no la obstruya al momento de tomar una nueva

imagen de la superficie, para terminar la acción se borra la posición pos con DELP pos y se envía la

confirmación para borrarlo “YES”, y se indica al controlador que ya no se van a enviar mas comandos,



116

SHOW PAR 1.

Estas serían las operaciones básicas con las que trabajaremos en el manejo de la celda flexible.

Esperamos que se halla comprendido básicamente el manejo del brazo robótico a partir de su lenguaje

de programación ACL.

4.12 Problemas surgidos y dificultades de ésta “Capítulo”

Esta es uno de los capítulos principales de nuestro proyecto, sin desmerecer los demás capítulos

claro, pero el aprender el manejo y funcionamiento de la celda flexible era primordial para el éxito de

este y cumplimiento de nuestros objetivos, resumiendo nuestro objetivo es detectar objetos, tomarlos y

trasladarlos, entonces si no lográbamos manejar la celda flexible, no podríamos tomar estos objetos ni

mucho menos trasladarlos, por lo que este capítulo se transformo a una de las mas importantes y a la

cual le dedicamos el mayor tiempo de estudio.

En primera instancia para el desarrollo de este capítulo solo contábamos con nuestros

conocimientos Ingenieriles e Informáticos adquiridos a lo largo de estos años de estudios en nuestra

Universidad, nunca antes habíamos incursionado en la robótica, ya que en la carrera no tenemos

asignaturas relacionadas con el tema, por lo que debíamos empezar de cero en este capítulo, siendo esa

nuestra primera dificultad, al preguntarnos ¿Por dónde empezamos?, Lo primero fue dirigirnos al

CIMUBB y conversar con Don Christian Aguilera Carrasco, Director del Centro CIMUBB, el nos

brindo todo su apoyo y ayuda en la investigación, por lo tanto ya teníamos el laboratorio CIMUBB

donde podíamos trabajar en el proyecto, además desde el inicio del tema nuestro Profesor Guía Don

Juan Carlos Parra, profesor de nuestra facultad, nos guió como podíamos comenzar y el fue quien nos

hizo dirigirnos al CIMUBB en primer lugar.

Una vez en el CIMUBB vino todo la parte de familiarizarnos con la celda flexible donde la

ayuda del Ingeniero de Soporte y Mantención del laboratorio Don Luis Vera, fue realmente

fundamental, acá descubrimos todo el funcionamiento del Scorbot, modos de operación, su lenguaje de

programación, y todo lo necesario para lograr nuestro proyecto.



117

En esta parte debimos formularnos horarios para poder hacer uso del laboratorio, entonces esto se torno

en un obstáculo para poder avanzar mas rápido en nuestro proyecto, ya que nos limitada el tiempo que

teníamos para trabajar con el robot, por lo tanto cada sesión la aprovechábamos al máximo.

Una de nuestra mayores dificultades fue establecer la comunicación serial con el robot debido al

lenguaje de programación en el que estábamos trabajando que es “lenguaje C”, esta parte nos tomo un

buen tiempo lograr encontrar la mejor manera de comunicarnos con el robot, debido a que teníamos

que encontrar una librería que nos entregara las herramientas necesarias para manejar el puerto,

buscamos, probamos, programamos, hasta encontrar la mejor que fue la LnxComm, ella nos facilitó

gran parte del manejo del puerto.

Luego de esto venía el análisis de datos por el puerto serial donde pasamos a otro dificultad, que

fue como enviar los comandos, y descubrimos que el controlador interno de la celda flexible tienen

rutinas de inicialización y finalización que nos permiten enviar los comandos en ACL en un formato

determinado, por lo que de esta manera el brazo robótico comprenderá la acción que le estamos

solicitando.

Más o menos a grandes rasgos esas fueron las dificultades para este capítulo, tratamos de darle

solución a todos y si lo conseguimos, por lo tanto nos mostramos satisfechos con haber cumplido con

los objetivos propuestos para este capítulo.


Capitulo 5: Diseño, Integración e Implementación

118

5 Diseño, Integración e Implementación

Este capítulo viene a ser la etapa culmine del proyecto debido a que a través de todo los

estudios desarrollados y prototipos implementados, debemos diseñar una solución que sea capaz de

integrar todo en un solo sistema, cumpliendo a cabalidad con los objetivos propuestos y los

requerimientos establecidos.

Para lograr una visión de todo como un solo sistema se trata en primera instancia los casos de

uso que vienen a ser el reflejo de lo especificado en los requerimientos, y que expresan su

comportamiento a través de los diagramas de secuencia, luego continuamos con los diagramas de flujo,

estos son los que en general nos dan una visión global de como interactúa el sistema, con sus entidades,

entre sus mismos procesos internos, ademas de sus flujos de datos, por lo tanto con ellos somos

capaces de conocer sus alcances y limitaciones, para de esta forma ver completamente su

funcionamiento, estos diagramas van acompañados de su diccionario de datos que detallan cada uno de

los componentes en el diagrama, trasparentando cada acción propuesta en el diseño.

Luego de establecer el diseño lógico y antes de pasar al diseño físico debemos exponer el tema

referente a la integración de las fases de desarrollo, donde los puntos a destacar son , primero la

transformación de pixeles a décimas de milímetros, esto permite enlazar las fases de análisis de imagen

con la fase de la celda flexible, debido a que debemos encontrar una compatibilidad entre las unidades

de medida que representan la ubicación del centroide del objeto seleccionado en la superficie de

trabajo. Otro aspecto de integración es lo que ocurre entre las fases de lógica difusa y el brazo

robótico donde ambas deben complementarse debido a que la maquina difusa va a ser quien le indique

a la celda flexible hacia donde moverse y cuanto moverse.

Luego debemos hacer referencia al diseño físico del sistema donde primero hablamos de la

biblioteca de desarrollo escogida para la implementación de la interfaz gráfica, destacando su

importancia, y ventajeas principalmente, a continuación se destaca la integración física de las diferentes

bibliotecas ocupadas en el desarrollo y como se integraron en un solo IDE, para dar paso al diagrama



119

de clases de la implementación y finalmente al diseño de la interfaz gráfica.

5.1 Casos de Uso

Los Casos de Uso (CU) son descripciones narrativas que describen el comportamiento de un

sistema desde el punto de vista del usuario. Ayudan a tener una mejor comprensión de los

requerimientos del sistema, definir los límites y las relaciones entre el sistema y el entorno. El formato

utilizado para representar los casos de uso, consta de los siguientes elementos (Larman, 2003):

• Caso de Uso: Nombre del Caso de Uso

• Actores: Lista de actores (agentes externos)

• Objetivo: Objetivo del Caso de Uso

• Precondiciones: Acciones necesarias para la correcta ejecución del CU.

• Postcondiciones: Acciones que ocurren tras la ejecución del CU.

• Escenario Principal (Flujo básico): Descripción en detalle de la ejecución normal del Caso de

Uso.

• Extensiones (Flujos alternos): Descripción de otras formas de ejecución del Caso de Uso.

• Otros: Requisitos especiales, Lista de tecnología y variaciones de datos, etc.



120

Nombre: SELECCIONAR OBJETO

Actores:

• Usuario

• Scorbot

Objetivo:

Seleccionar un objeto dentro del universo disponible.

Precondiciones:

Lo centroides de los objetos deben estar detectados.

Postcondiciones:

Genera las posiciones de desplazamiento del scorbot.

Escenario Principal:

Accion del actor Respuesta del Sistema



121

1.- El usuario realiza click sobre el botón

'siguiente', de la pantalla donde se despliegan

todos los centroides localizados en la imagen

binarizada

2.- El sistema despliega por pantalla la imagen

original capturada por la cámara web pero

mostrando botones correspondientes a cada uno

de los objetos detectados.

3.- El usuario selecciona un objeto haciendo

click sobre este.

4.- El sistema muestra un mensaje de alerta

preguntando: '¿Esta seguro que decea

seleccionar este objeto?', dando cabida a tres

opciones:

- Boton 'si': indica al scorbot capturar objeto

- Boton 'no': retorna a la pantalla de objetos

detectados.

- Boton 'ver detalles': indica el centroide del

objeto detectado en pixeles.

6.- Scorbot realiza instrucciones de

desplazamiento

5.- El sistema por medio del procesamiento de

los datos envía instrucciones de movimiento al

scorbot.

7.- Scorbot envía al respuesta sistema si se pudo

realizar la instrucción de desplazamiento

Extensiones:

5.- si se devuelve una respuesta de desplazamiento que no se pudo realizar se termina el

desplazamiento del objeto.



122

Nombre: SELECCIONAR DESTINO OBJETO

Actores:

• Usuario

• Scorbot

Objetivo:

Depositar el objeto en alguna posición dentro .

Precondiciones:

La pantalla de los botones que perteneces a los objetos.

Postcondiciones:

Finaliza proceso scorbot y se retorna a la pantalla de inicio.


Accion del actor Respuesta del Sistema

1.- El usuario selecciona un objeto haciendo

click sobre este.

2.- Llamar rutina para depositar objeto.

3.- Scorbot realiza instrucciones de

desplazamiento

4.- Una vez depositado el objeto se vualve a la

pantalla de inicio del programa.

Extensiones:

1.- Si se realiza un click fuera de los limites aceptados, se desplegara una alerta expresando

dicho problema, teniendo que seleccionar nuevamente la posición destino



123

Nombre: ANALIZAR IMAGEN

Actores:

• Usuario

Objetivo:

Obtener centroides a partir del tratamiento de la imagen.

Precondiciones:

La imagen tiene que encontrarse disponible para poder analizarla.

Postcondiciones:

Obtener los pixeles correspondientes a los objetos encontrados.


Acción del actor Respuesta del Sistema

1.- El sistema muestra una pantalla de inicio,

donde el usuario debe seleccionar desde el menú,

capturar imagen

2.- Genera la ventana donde se despliega la cama

web en vivo, donde esta muestra el area de

interés, con todo lo que se encuentre dentro de

ella


'capturar imagen'.

4.- Se muestra la imagen capturada.


'meanshif'

6.- Aplicación del algoritmo meanshift a la

imagen desplegándola por pantalla.


'siguiente'

8.- Se despliega en pantalla la ventana de

binarización sin erosión


'binarizacion1' que corresponde a la binarización

normal.

10.- Se despliega una nueva ventana mostrando

la imagen binarizada en un valor de umbral que

se puede cambiar a través del slider.

11.- El usuario realiza click sobre el botón 'listo'

una vez quedado satisfecho con el nivel de

umbral seleccionado.

12.- Se minimiza la ventana de binarización

normal y vuelve a la pantalla de binarización sin

erosión, encontrándose esta vez activo el botón

'binarizacion2' que corresponde a la binarización



124

inversa


'binarizacion2'

14.- Se despliega una nueva ventana mostrando

la imagen binarizada en un valor de umbral que

se

puede cambiar a través del slider.

15.- El usuario realiza click sobre el botón 'listo'

una vez quedado satisfecho con el nivel de

umbral seleccionado.

16.- Se minimiza la ventana de binarización

invertida y vuelve a la pantalla de binarización

sin erosión, encontrándose esta vez activo el

botón 'mezclar' que corresponde a la

binarización inversa


'mezclar'.

18.- Se despliega en pantalla la mescla de las

binarizaciones y activa boton 'siguiente'.


'siguiente'.

20.- Se despliega en pantalla la imagen aplicado

la trasformación morfológica


'siguiente'.

22.- Se despliega el centroide de los objetos

identificados.

Extensiones:

3,5,7.- Se puede retroceder a la pantalla anterior, por medio del botón del menú

7.- Se puede avanzar a la siguiente etapa por medio del botón del menú

13,15,17,19.- Se puede volver a la ventana de binarización normal, haciendo click sobre su

ventana minimizada.

17,19.- Se puede volver a la ventana de binarización inversa, haciendo click sobre su ventana

minimizada.



125

Nombre: SELECCIONAR IMAGEN

Actores:

• CamaraWeb

Objetivo:

Seleccionar una imagen a partir el video transmitido por la cámara web.

Precondiciones:

Obtener imagen a partir de la cámara web.

Postcondiciones:

Obtención del centroide de cada objeto.


Acción del actor Respuesta del Sistema

2.- Transmisión de lo que obtiene la cámara a

traves de su sensor.

1.- Sistema inicializa transmisión camaraWeb.

4.- Enviar captura imagen camaraWeb. 3.- Petición de imagen a la cámara.

Extensiones:

5.2 Diagrama de Secuencias

El diagrama de secuencia de un sistema muestra gráficamente los eventos que originan los actores y

que impactan al sistema. Por lo tanto antes de hacer el diseño lógico de la aplicación de software, es

conveniente investigar y definir su comportamiento como una "caja negra".

Se estudia el comportamiento del sistema, desde la perspectiva de qué es lo que hace, y no de cómo

lo hace. Entonces como objetivo para lograr la comprensión de estos diagramas podemos decir, que el

diagrama de secuencia de un sistema es una representación que muestra, en determinado escenario de

un caso de uso, los eventos generados por actores externos, su orden y los eventos internos del sistema.

Estos diagramas son descritos en el Anexo III a continuación del caso de uso.



126



127



128



129

5.3 Diseño Lógico

Este comprende un análisis completo del sistema representado a través de diagramas de flujo, por

lo tanto vamos a tener una visión total y en distintos niveles de detalle del sistema, para mostrar los

distintos procesos que lo componen y como estos interactuan con los diferentes actores, también para

cada diagrama se especifica un diccionario de datos, que corresponde a una explicación detallada de lo

que realiza, cada actor, proceso y flujo de datos en este sistema.

Esto nos ayudara a ver los alcances y limitaciones de nuestro sistema, debido a la visión global

que nos entrega.

5.3.1 Diagrama de Flujo de Datos

Esta busca modelar un sistema desde el punto de vista de la información, en el cual se estudia

como se usan los datos que corresponden a las entradas, en salidas que vendría a ser la información,

por lo tanto el propósito para un Diagrama de Flujo de Datos es mostrar para un sistema o subsistema

lo siguiente:

• Cuáles son los límites del sistema

• De dónde vienen los datos

• A dónde van los datos cuando dejan el sistema

• Dónde se almacenan los datos

• Qué procesos transforman los datos y las interacciones entre los procesos y los depósitos de datos

Definición de Elementos:

Entidades :

Representan las Fuentes o Destinos delos Datos.

Ejemplo : Paciente,Alumno, Contabilidad, Cliente, etc..

Proceso:

Transformación de los Datos.



130

Ejemplos: Calcular Total Factura, Inscribir Asignatura, Registrar Reserva.,etc.

Flujos de Información:

Movimiento de Datos.

Por ejemplo: Detalle de Factura, Datos del Cliente, Orden de Compra, etc.

Se compone de Datos Elementales.

Almacenes de Datos:

Repositorio delos datos procesados y utilizados por los procesos del sistema.

Por ejemplo: Facturas,Clientes, Productos, Facturas Rechazadas, Habitaciones Reservadas, etc.

La notación de DFD que ocuparemos en nuestro proyecto es la de Yourdon/Demarco, con esta

breve presentación de los diagramas, se especificaran por niveles. Tanto el:

• Diagrama de Flujo de Datos Contexto

• Diagrama de Flujo de Datos Nivel Superior

• Diagrama de Flujo de Datos Detalle

5.3.1.1 Diccionario de Datos DFD

El diccionario de datos complementa el diseño mostrado en todos los puntos anteriores. Este

tiene tres componentes esenciales:

− Especificación de procesos:

Por cada proceso especificado en el sistema, se indica su función, los datos que

recibe, y los datos que salen de el .

− Especificación de flujo de datos datos

Corresponde a los información que circula entre procesos, entidades y almacenes de

datos, se describe cada una de estas en forma detallada.

− Especificación de Entidades

Se Describe las entidades del sistema, su rol e importancia en el sistema



131

Se escogió el DFD de detalle para realizar su diccionario de datos ya que este comprende todos

los procesos y flujos que interactuan en el sistema, este diccionario es presentado a continuación junto

a los DFD



132

5.3.1.2 DFD Nivel Contexto



133

5.3.1.3 DFD Nivel Superior



134

5.3.1.4 DFD Nivel Detalle del Proceso 1



135

Diccionario de Datos Nivel de Detalle Segmentar Imagen Descripción de procesos Segmentar Imagen

Nivel Detalle

Numero 1.1

Nombre Realizar MeanShift

Parte-de Segmentar Imagen

Descripción Narrativa Corresponde a la aplicación del algoritmo meanshift a la imagen que hemos capturado desde la cámara web, pro lo tanto después de ocurrida esta acción podemos continuar con las demás etapas de análisis de imagen.

Flujo de Entrada solicitud aplicación meanshift

Flujo de Salida Datos imagen meanshift respuesta aplicación meanshift

Nivel Detalle

Numero 1.2

Nombre Realizar binarización y mezcla imagen


Descripción Narrativa Este proceso nos permite realizar la etapa de binarización, para la cual requerimos de la imagen a la que ya le aplicamos el algoritmo meanshift por lo tanto se encuentra en condiciones de realizar la binarización normal e invertida para posteriormente efectuar la mezcla de ambas.

Flujo de Entrada solicitud binarización normal solicitud binarización datos imagen binarizada invertida datos imagen binarizada normal Datos imagen meanshift solicitud binarización invertida solicitud mezcla binarización

Flujo de Salida Respuesta solicitud binarización Respuesta solicitud binarización normal Respuesta solicitud binarización invertida Respuesta solicitud mezcla binarización



136

datos imagen a binarizar normal datos imagen a binarizar datos imagen a binarizar invertida

Nivel Detalle

Numero 1.3

Nombre Realizar binarización invertida


Descripción Narrativa Corresponde a la etapa de aplicación de binarización inversa, a la imagen meanshift, esto nos ayudara a la detección del objeto en fases posteriores, por lo tanto una vez encontrado el nivel de umbral adecuado para destacar el o los objetos, la binarización inversa esta lista para ser mezclada con la normal.

Flujo de Entrada Respuesta solicitud umbral binarización invertida datos imagen a binarizar invertida

Flujo de Salida solicitud umbral binarización invertida datos imagen binarizada invertida

Nivel Detalle

Numero 1.4

Nombre Realizar binarización normal


Descripción Narrativa Corresponde a la etapa de aplicación de binarización normal, a la imagen meanshift, esto nos ayudara a la detección del objeto en fases posteriores, por lo tanto una vez encontrado el nivel de umbral adecuado para destacar el o los objetos, la binarización normal esta lista para ser mezclada con la inversa.

Flujo de Entrada Respuesta solicitud umbral binarización normal datos imagen a binarizar normal

Flujo de Salida solicitud umbral binarización normal datos imagen binarizada normal

Flujo de Entrada en el proceso 1.1 de Realizar Meanshift Nombre Flujo Solicitud aplicación Meanshift

Flujo Descripción Datos enviados al sistema para poder realizar la aplicación del algoritmo Meanshift una vez capturada la imagen del video en vivo desplegado por el sistema.



137

Origen Entidad: Usuario

Destino Proceso 1: Segmentar Imagen

Flujo de salida del proceso 1.1 Realizar meanshift Nombre Flujo Datos Imagen Meanshift

Flujo Descripción Envia los datos de la imagen trasformada según la aplicación del algoritmo meanshift

Origen Proceso 1.1: Realizar Menashift

Destino Proceso 1.2: Realizar Binarización y Mezcla Imagen

Nombre Flujo respuesta aplicación meanshift

Flujo Descripción Es la información que se le hace llegar al usuario, una vez aplicado el algoritmo Meanshift, esta respuesta es la nueva imagen una vez aplicado este algoritmo.

Origen Proceso 1.1: Realizar Menashift

Destino Entidad : Usuario

Flujo de Entrada en el proceso 1.2 de Realizar Binarización y Mezcla Imagen Nombre Flujo Solicitud Mezcla Binarización.

Flujo Descripción Acción realizada por el usuario que consta de hacer click sobre el botón mesclar, una vez que ya se hayan hecho las binarizaciones tanto la Normal Como la Inversa, para de este modo Obtener una sola imagen correspondiente a la mezcla de ambas binarizaciones.


Destino Proceso 1.2: Realizar Binarizacion y Mezcla Imagen

Nombre Flujo Solicitud Binarización Normal.

Flujo Descripción Datos enviados al sistema mediante click realizado por el usuario para solicitar la binarización normal.





138

Nombre Flujo Solicitud Binarización Invertida.

Flujo Descripción Datos enviados al sistema mediante click realizado por el usuario para solicitar la binarización invertida.



Nombre Flujo Solicitud Binarización.

Flujo Descripción Datos enviados al sistema correspondientes a la imagen aplicado meanshift previamente para poder realizar binarización posteriormente norma e inversa.



Nombre Flujo Dato Imagen Binarizada Inversa

Flujo Descripción Datos resultantes de la aplicación de la binarización invertida



Nombre Flujo Dato Imagen Binarizada Normal

Flujo Descripción Datos resultantes de la binarización normal



Flujo de salida del proceso 1.2 Realizar Binarización y Mezcla Imagen Nombre Flujo Datos imagen a binarizar invertida

Flujo Descripción Se enviá la información referente a la imagen para que se le aplique la binarización invertida.

Origen Proceso 1.2: Realizar Binarización y Mezcla Imagen

Destino Proceso 1.3: Realizar Binarización Invertida



139

Nombre Flujo respuesta solicitud binarizacion

Flujo Descripción Corresponde a la respuesta de la acción de iniciar el proceso de binarización de imagen, esta nos indica que podemos comenzar la binarización normal de la imagen.



Nombre Flujo respuesta solicitud binarización normal

Flujo Descripción La respuesta de esta solicitud es la imagen lista para aplicar binarización normal sobre ella.



Nombre Flujo Datos imagen a binarizar normal

Flujo Descripción Se enviá la información referente a la imagen para que se le aplique la binarización normal.


Destino Proceso 1.4: Realizar Binarización Normal

Nombre Flujo respuesta solicitud binarización invertida

Flujo Descripción La respuesta de esta solicitud es la imagen lista para aplicar binarización invertida sobre ella.



Nombre Flujo respuesta solicitud mezcla binarización

Flujo Descripción Este flujo entrega el resultado de mezclar la imagen binarizada normal y binarizada invertida, por lo tanto se genera una nueva imagen.





140

Nombre Flujo Datos Imagen binarizada

Flujo Descripción Entrega la imagen mezclada (Binarización Normal-Binarización Invertida) al siguiente proceso que es la transformación morfológica


Destino Proceso 2: Transformación Morfológica

Flujo de Entrada en el proceso 1.3 de Realizar Meanshift Nombre Flujo Dato Imagen Binarizada Inversa

Flujo Descripción Datos resultantes de la aplicación de la binarización invertida


Destino Proceso 1.3: Realizar Meanshift

Nombre Flujo Respuesta Solicitud Umbral Binarización Invertida.

Flujo Descripción Estos datos desplegados en una pantalla del sistema muestra el resultado del valor ingresado por el usuario al momento de cambiar el nivel de umbral, por medio del slider


Destino Proceso 1.3: Realizar Meanshift

Flujo de salida del proceso 1.3 Realizar Binarización Invertida

Nombre Flujo solicitud umbral binarización Invertida

Flujo Descripción Enviá una solicitud al usuario respecto al valor del nivel de umbral que se le debe aplicar a la binarización invertida

Origen Proceso 1.3 Realizar Binarización Invertida


Nombre Flujo Datos Imagen Binarizada invertida

Flujo Descripción Corresponde a los datos de la imagen a la cual se le aplico la binarización invertida, por lo cual esta lista para ser mezclada.

Origen Proceso 1.3 Realizar Binarización Invertida




141

Flujo de Entrada en el proceso 1.4 de Realizar Binarizacion Normal

Nombre Flujo Respuesta Solicitud Umbral Binarización Normal.

Flujo Descripción Estos datos desplegados en una pantalla del sistema muestra el resultado del valor ingresado por el usuario al momento de cambiar el nivel de umbral, por medio del slider


Destino Proceso 1.4: Realizar binarizacion normal

Nombre Flujo Datos Imagen a binarizar Normal

Flujo Descripción Imagen binarizada con un valor de umbral por defecto el cual se despliega en el sistema con un slider para cambiar su valor de umbral de binarización


Destino Proceso 1.4: Realizar binarizacion normal

Flujo de salida del proceso 1.4 Realizar Binarización Normal

Nombre Flujo solicitud umbral binarización normal

Flujo Descripción Enviá una solicitud al usuario respecto al valor del nivel de umbral que se le debe aplicar a la binarización normal

Origen Proceso 1.4 Realizar Binarización Normal


Nombre Flujo Datos Imagen Binarizada Normal

Flujo Descripción Corresponde a los datos de la imagen a la cual se le aplico la binarización normal, por lo cual esta lista para ser mezclada.

Origen Proceso 1.4 Realizar Binarización Normal




142




143

Transformación morfológica Nivel 2

Numero 2,1

Nombre Realizar Erosión

Parte-de Transformación morfológica

Descripción Narrativa Proceso por el cual la imagen previamente binarizada se le aplica erosión para poder juntar partes de la imagen que no se encuentran bien juntas debido posiblemente a la elección del umbral.

Flujo de Entrada Datos imagen Binarizada

Flujo de Salida Datos imagen Erosionada

Nivel 2

Numero 2,2

Nombre Realizar Dilatación

Parte-de Transformación morfológica

Descripción Narrativa Proceso por el cual la imagen previamente a sido erosionada por lo que mediante a la dilatación se volverá a la normalidad los pixeles que han aumentado su tamaño.

Flujo de Entrada Datos imagen Erosionada

Flujo de Salida Datos imagen Imagen Transformada

Flujo de Entrada en el proceso 2.1 de Realizar Erosión. Nombre Flujo Datos Imagen Binarizada

Flujo Descripción Datos correspondientes a la imagen ya binarizada, osea enviada en blanco, para aplicar el procesos de erosión

Origen Proceso 1: Segmentar Imagen

Destino Proceso 2.1: Realizar Erosión



144

Flujo de Salida en el proceso 2.1 de Realizar Dilatación. Nombre Flujo Datos Imagen erosionada

Flujo Descripción Datos correspondientes a la imagen erosionada, que ya se encontraría en condiciones optimas para ser dilatada

Origen Proceso 2.1: Realizar Erosión

Destino Proceso 2.2: Realizar Dilatación

Flujo de Salida del proceso 2.2 Realizar Dilatación

Nombre Flujo Datos Imagen Transformada

Flujo Descripción Una vez aplicada la dilatación a la imagen se enviá esta a la siguiente etapa donde se analizaran los objetos.

Origen Proceso 2.2 Realizar Dilatación

Destino Proceso 3: Análisis Objeto Flujo de Entrada del proceso 2.2 Realizar Dilatación

Nombre Flujo Datos Imagen Erosionada

Flujo Descripción Una vez aplicada la erosión a la imagen se enviá esta a la siguiente etapa donde se dilatara.

Origen Proceso 2.1 Realizar Dilatación

Destino Proceso 2.2 Realizar Dilatación



145

5.3.1.6 DFD Nivel Detalle Proceso 3



146

Analizar Objeto Nivel 2

Numero 3,1

Nombre Realizar Búsqueda de contornos

Parte-de Analizar objeto

Descripción Narrativa Obtiene todo los contornos a partir de la imagen previamente binarizada, procesándola y obteniendo de cada uno de los contornos el los rectángulos que componen al contorno correspondiente, guardándolo en el almacén lista de objetos

Flujo de Entrada Dato imagen transformada contornos

Flujo de Salida Datos rectángulo del contorno,datos contorno,datos rectangulo del contorno.

Nivel 2

Numero 3,2

Nombre Calcular centroides


Descripción Narrativa Calcular los centroide mediante la imagen binarizada y el rectángulo correspondiente al área justa del contorno de cada objeto.

Flujo de Entrada Dato imagen transformada centroide,Datos rectángulo del contorno

Flujo de Salida Datos centroide

Nivel 2

Numero 3,3

Nombre Identificación Objetos


Descripción Narrativa Proceso en el que se muestra por pantalla los centroides correspondientes a cada objetos, posteriormente se despliega cada uno de los botones que están asociado a su contorno para poder pincharlos y así seleccionar el objeto a ser capturado.

Flujo de Entrada Solicitud selección objeto,respuesta solicitud lista objeto

Flujo de Salida Respuesta Solicitud selección objeto, solicitud lista objeto, datos centroide pixel X objeto seleccionado,datos centroide pixel Y objeto seleccionado.



147

Nivel 2

Numero 3,4

Nombre Identificación Destino Objetos


Descripción Narrativa Proceso en donde el usuario hace un click sobre la posición destino, identificando las coordenadas posteriormente al scorbot.

Flujo de Entrada Solicitud destino objeto,Respuesta solicitud información lista objetos

Flujo de Salida Respuesta Solicitud destino objeto,datos centroide pixel X posición destino,datos centroide pixel Y posición destino, solicitud información lista objetos

Flujo de Entrada en el proceso 3.1 de Realizar Búsqueda de Contorno. Nombre Flujo Datos Imagen Transformada Contornos.

Flujo Descripción Datos correspondientes a la imagen ya binarizada, osea enviada en blanco, pero aplicado los procesos de dilatación y de emocionar, generando producto de ello una nueva imagen que se transmite

Origen Proceso 2: Transformación Morfológica

Destino Proceso 3.1: Realizar búsqueda Contornos

Flujo de Salida del proceso 3.1 Realizar Búsqueda de Contornos

Nombre Flujo Datos del rectángulo del contorno

Flujo Descripción Almacena información referente al rectángulo de contornos de la imagen

Origen Proceso 3.1 Realizar Búsqueda de Contornos

Destino Almacén de datos : Lista Objetos

Nombre Flujo Datos contorno

Flujo Descripción Enviá la información de los contornos detectados en la imagen





148

Nombre Flujo Datos Rectángulo del contorno

Flujo Descripción Contornos relevantes para calcular el centroide del objeto en la imagen obtenida desde la cámara.


Destino Proceso 3.2 calcular centroides

Flujo de Entrada en el proceso 3.2 de Calcular Centroides. Nombre Flujo Datos Imagen Transformada Centroide.

Flujo Descripción Datos correspondientes a la imagen ya binarizada aplicado las transformaciones morfológicas de erosionar y dilatar

Origen Proceso 2: Transformación Morfológica

Destino Proceso 3.2: Calcular Centroides

Nombre Flujo Datos Rectangulo del Contorno

Flujo Descripción Datos correspondientes al rectángulo del objeto, utilizado como dato para obtener su centroide.

Origen Proceso 3.1: Realizar búsqueda Contornos

Destino Proceso 3.2: Calcular Centroides

Flujo de Salida del proceso 3.2 Calcular Centroide

Nombre Flujo Datos Centroide

Flujo Descripción Se almacenan las coordenadas del centroide del objeto en el almacén para que posteriormente sean consultadas.

Origen Proceso 3.2 calcular centroides




149

Flujo de Entrada en el proceso 3.3 de Identificar Objetos. Nombre Flujo Respuesta Solicitud lista Objetos

Flujo Descripción Datos de los objetos almacenados para poder desplegarlos por pantalla, con sus respectivos botones.

Origen Almacén de datos: Lista Objetos

Destino Proceso 3.3: Identificar Objetos

Nombre Flujo Solicitud selección Objetos

Flujo Descripción Dato entregado por el usuario correspondiente a la coordenadas para obtener un objeto a partir de los objetos que aparecen por pantalla

Origen Usuario

Destino Proceso 3.3: Identificar Objetos

Flujo de Salida del proceso 3.3 Identificar Objetos

Nombre Flujo Respuesta solicitud selección objeto

Flujo Descripción Comprende al cuadro de dialogo que le muestra al usuario que desea hacer al haber seleccionado el objeto, este posee tres opciones: si: tomar el objeto seleccionado no: volver a la pantalla de selección de onjetos para escoger uno nuevo ver detalle:muestra el centroide del objeto.

Origen Proceso 3.3 Identificar Objetos


Nombre Flujo Solicitud Lista Objetos

Flujo Descripción Solicita la información al almacén perteneciente a la imagen





150

Nombre Flujo Datos centroide pixel X objeto seleccionado

Flujo Descripción Flujo de información que representa la ubicación del objeto en la coordenada X, del objeto seleccionado.


Destino Proceso 5 Analizar Coordenadas

Nombre Flujo Datos centroide pixel Y objeto seleccionado

Flujo Descripción Flujo de información que representa la ubicación del objeto en la coordenada Y, del objeto seleccionado.


Destino Proceso 5 Analizar Coordenadas

Flujo de Entrada en el proceso 3.4 de Identificar Destino Objetos.

Nombre Flujo Respuesta Solicitud Información lista Objetos

Flujo Descripción Datos correspondientes a los datos guardados en la lista de objetos que contiene los centroides, contorno y rectángulo del objeto.

Origen Almacén de datos: Lista Objetos

Destino Proceso 3.3: Identificar Destino Objeto

Nombre Flujo Solicitud Destino Objetos

Flujo Descripción Dato entregado por el usuario correspondiente a la coordenadas para dejar el objeto seleccionando la pantalla con el mouse a partir de un click.

Origen usuario

Destino Proceso 3.3: Identificar Destino Objeto



151

Flujo de Salida del proceso 3.4 Identificar Destino Objeto

Nombre Flujo Respuesta solicitud destino Objeto

Flujo Descripción Después de procesar la posición de destino del objeto, se enviá la respuesta de este análisis al usuario

Origen Proceso 3.4 Identificar Destino Objeto

Destino Entidad: Usuario

Nombre Flujo Datos centroide pixel X posición destino

Flujo Descripción Corresponde a la posición destino de la coordenada X en la superficie del espacio de trabajo, que contiene a los demás objetos.


Destino Proceso 5 Analizar Coordenada

Nombre Flujo Datos centroide pixel Y posición destino

Flujo Descripción Corresponde a la posición destino de la coordenada Y en la superficie del espacio de trabajo, que contiene a los demás objetos.


Destino Proceso 5 Analizar Coordenada

Nombre Flujo Solicitud Información lista de Objetos

Flujo Descripción Corresponde a los solicitud de los datos necesarios para analizar la posición de destino del objeto en la superficie de trabajo.





152




153

Obtener output cámara web Nivel 2

Numero 4,1

Nombre Transmisión Video Aplicación

Parte-de Obtener output cámara web

Descripción Narrativa Obtiene la salida que obtiene la cámara web hacia el sistema, mostrando al usuario lo que ocurre en el campo de vision.

Flujo de Entrada Respuesta Solicitud video, solicitud imagen

Flujo de Salida Respuesta Solicitud Imagen, Solicitud video

Nivel 2

Numero 4,2

Nombre Captura imagen del video

Parte-de Obtener output cámara web

Descripción Narrativa Obtiene una imagen del video que es transmitido en el sistema a través de la cámara web, esta instrucción la solicita el usuario

Flujo de Entrada Respuesta Solicitud Imagen,solicitud captura imagen

Flujo de Salida solicitud imagen,respuesta solicitud captura imagen

Flujo de Entrada en el proceso 4.1 de Transmisión Video Aplicación. Nombre Flujo Solicitud Imagen

Flujo Descripción Información de petición de la Imagen a Obtener de la webcam

Origen Proceso 4.2: Captura imagen de video

Destino Proceso 4.1: Transmisión video Aplicación

Nombre Flujo Respuesta Solicitud Video

Flujo Descripción Datos de video de salida obtenida de la cámara ser procesados

Origen Entidad: Cámara Web.

Destino Proceso 4.1: Transmisión video Aplicación



154

Flujo de Salida del Proceso 4.1 Transmisión Video Aplicación

Nombre Flujo Solicitud Video

Flujo Descripción Enviá la sugerencia a la cámara web, que se necesita la utilización del video que esta nos entrega.

Origen Proceso 4.1 Transmisión Video Aplicación

Destino Entidad: CamaraWeb

Nombre Flujo Respuesta Solicitud imagen

Flujo Descripción Enviá los datos de la imagen que se capturo, estos datos representan la imagen de la superficie.

Origen Proceso 4.1 Transmisión Video Aplicación

Destino Proceso 4.2 Capturar imagen del video

Flujo de Entrada en el proceso 4.2 de Captura imagen del video. Nombre Flujo Solicitud Captura Imagen

Flujo Descripción Información de petición de captura de una imagen asociado al video transmitido por la webcam


Destino Proceso 4.2: Captura imagen de video

Nombre Flujo Respuesta Solicitud Imagen

Flujo Descripción Dato de la imagen pedida por el usuario,tratada desde la webcam

Origen Proceso 4.1: Transmisión video Aplicación

Destino Proceso 4.2: Captura imagen de video



155

Flujo de Salida del proceso 4.2 Capturar imagen del video

Nombre Flujo Respuesta solicitud captura imagen

Flujo Descripción Es la información referente a la captura de la imagen, es decir se muestra por pantalla la imagen capturada del video emitido por la cámara.

Origen Proceso 4.2 Capturar imagen del video

Destino Entidad: Usuario

Nombre Flujo Solicitud Imagen

Flujo Descripción Enviá la solicitud de la necesidad de obtener una imagen desde el video entregado por la cámara de la superficie actual donde se encuentran los objetos.

Origen Proceso 4.2 Capturar imagen del video

Destino Proceso 4.1 Transmisión Video Aplicación



156




157

Analizar coordenadas

Nivel 2

Numero 5,1

Nombre Conversión a décimas de milímetros

Parte-de Analizar Coordenadas

Descripción Narrativa Proceso realizado para convertir los pixeles enviados correspondientes al centroide del objeto en cuestión, o de la nueva localización de este a tener a décimas de milímetros.

Flujo de Entrada Datos centroide pixel X objeto seleccionado,Datos centroide pixel Y objeto seleccionado,Datos centroide pixel Y posición destino,Datos centroide pixel X posición destino

Flujo de Salida Coordenada X depositar objeto,Coordenada Y depositar objeto, coordenada X centroide objeto seleccionado,coordenada Y centroide objeto seleccionado

Nivel 2

Numero 5,2

Nombre Maquina Difusa


Descripción Narrativa Proceso que le confiere cierto grado de conocimiento al sistema, mediante la introducción de los centroides establecidos se calcula el porcentaje de desplazamiento que se debe mover.

Flujo de Entrada coordenada X centroide objeto seleccionado,coordenada Y centroide objeto seleccionado, nueva posición Scorbot en Y,nueva posición Scorbot en X.

Flujo de Salida Margen de error eje X,Margen de error eje Y.



158

Nivel 2

Numero 5,3

Nombre Interpretación valores maquina difusa


Descripción Narrativa Interpretación que se le da al porcentaje que se debe realizar del movimiento obtenido de la maquina difusa, enviando estos valores al proceso de comunicación scorbot

Flujo de Entrada Margen de error eje X,Margen de error eje Y.

Flujo de Salida Desplazamiento en coordenada X,Desplazamiento en coordenada Y

Flujo de Entrada en el proceso 5.1 de Conversión a décimas de milímetros. Nombre Flujo Datos centroide pixel X objeto seleccionado

Flujo Descripción Conversión de los pixeles obtenidos del centroide del objeto correspondientes al pixel X origen para pasarlos a décimas de milímetros y poder trabajar en las mismas medidas que trabaja el Scorbot

Origen Proceso 3: Análisis Objeto

Destino Proceso 5.1: Conversión a Décimas de Milímetros

Nombre Flujo Datos centroide pixel Y objeto seleccionado

Flujo Descripción Conversión de los pixeles obtenidos del centroide del objeto correspondientes al pixel Y origen para pasarlos a décimas de milímetros y poder trabajar en las mismas medidas que trabaja el Scorbot



Nombre Flujo Datos centroide pixel X posición destino

Flujo Descripción Conversión de los pixeles obtenidos del centroide del objeto correspondientes al pixel Y destino para pasarlos a décimas de milímetros y poder trabajar en las mismas medidas que trabaja el Scorbot





159

Nombre Flujo Datos centroide pixel Y posición destino

Flujo Descripción Conversión de los pixeles obtenidos del centroide del objeto correspondientes al pixel Y destino para pasarlos a décimas de milímetros y poder trabajar en las mismas medidas que trabaja el Scorbot



Flujo de Salida del Proceso 5.1 Conversión a décimas de milímetros

Nombre Flujo Coordenada X centroide objeto seleccionado

Flujo Descripción Corresponden a la coordenada X del objeto trasformada a décimas de milímetros

Origen Proceso 5.1 Conversión a décimas de milímetros

Destino Proceso 5.2 Maquina Difusa

Nombre Flujo Coordenada Y centroide objeto seleccionado

Flujo Descripción Corresponden a la coordenada Y del objeto trasformada a décimas de milímetros


Destino Proceso 5.2 Maquina Difusa

Nombre Flujo Coordenada X posición destino

Flujo Descripción Corresponden a la coordenada X donde se va a desplazar el objeto trasformada a décimas de milímetros


Destino Proceso 6 Comunicación Scorbot



160

Nombre Flujo Coordenada Y posición destino

Flujo Descripción Corresponden a la coordenada Y donde se va a desplazar el objeto trasformada a décimas de milímetros



Flujo de Entrada en el proceso 5.2 de Maquina Difusa. Nombre Flujo Coordenada X centroide objeto seleccionado

Flujo Descripción Dato correspondiente a el eje X del centroide expresado en décimas de milímetros para ser procesado por la maquina difusa

Origen Proceso 5.1: Conversión a Décimas de Milímetros

Destino Proceso 5.2: Maquina Difusa

Nombre Flujo Coordenada Y centroide objeto seleccionado

Flujo Descripción Dato correspondiente a el eje Y del centroide expresado en décimas de milímetros para ser procesado por la maquina difusa

Origen Proceso 5.1: Conversión a Décimas de Milímetros


Nombre Flujo Nueva Posición Scorbot en X

Flujo Descripción Dato correspondiente a la posición del scorbot una vez desplazado en el eje X, utilizándose para ser procesado por la maquina difusa y obtener de ellos nuevas posiciones de salida en conjunto con el eje Y

Origen Proceso 6: comunicación Scorbot


Nombre Flujo Nueva Posición Scorbot en Y

Flujo Descripción Dato correspondiente a la posición del scorbot una vez desplazado en el eje Y , utilizándose para ser procesado por la maquina difusa y obtener de ellos nuevas posiciones de salida, en conjunto con el eje X

Origen Proceso 6: comunicación Scorbot




161

Flujo de Salida del Proceso 5.2 Maquina Difusa

Nombre Flujo Margen error eje X

Flujo Descripción Es el valor porcentual que nos indica cuanto y hacia donde debemos mover la celda flexible en su coordenada X

Origen Proceso 5.2 Maquina Difusa

Destino Proceso 5.3 Interpretación valores maquina difusa

Nombre Flujo Margen error eje Y

Flujo Descripción Es el valor porcentual que nos indica cuanto y hacia donde debemos mover la celda flexible en su coordenada Y

Origen Proceso 5.2 Maquina Difusa

Destino Proceso 5.3 Interpretación valores maquina difusa

Flujo de Entrada en el proceso 5.3 de Interpretación de Valores Maquina Difusa. Nombre Flujo Margen Error eje X

Flujo Descripción Dato correspondiente al margen de error en la coordenada X obtenido de la maquina difusa, a ser procesada

Origen Proceso 5.2: Maquina Difusa

Destino Proceso 5.3: Interpretación valores Maquina difusa

Nombre Flujo Margen Error eje Y

Flujo Descripción Dato correspondiente al margen de error en la coordenada Y obtenido de la maquina difusa, a ser procesada

Origen Proceso 5.2: Maquina Difusa

Destino Proceso 5.3: Interpretación valores Maquina difusa



162

Flujo de Salida del Proceso 5.3 Interpretación valores maquina difusa

Nombre Flujo Desplazamiento en coordenada X

Flujo Descripción Es el valor que nos indica cuanto y hacia donde debemos mover la celda flexible en su coordenada X.

Origen Proceso 5.3 Interpretación valores maquina difusa




163




164

Comunicación Scorbot Nivel 2

Numero 6,1

Nombre Escritura en puerto Serial

Parte-de Comunicación Scorbot

Descripción Narrativa Proceso correspondiente a enviar instrucciones en ACL para establecer una comunicación con el Scorbot a través de puerto serial

Flujo de Entrada Comando Tomar Objeto,comando desplazar objeto.

Flujo de Salida Solicitud finalización celda, envío de comandos, inicialización celda flexible.

Nivel 2

Numero 6,2

Nombre Lectura del puerto Serial


Descripción Narrativa Se establece la recepción de los mensajes obtenidos del scorbot de todas las respuestas de los mensajes enviados hacia el.

Flujo de Entrada Respuesta inicialización celda flexible,Respuesta envío comando, respuesta finalización celda.

Flujo de Salida Respuesta comando desplazar objeto,respuesta comando tomar objeto.

Nivel 2

Numero 6,3

Nombre Tomar Objeto


Descripción Narrativa Proceso que interpreta las coordenadas obtenidas y transformarlas a instrucciones ACL.

Flujo de Entrada Desplazamiento en coordenada X,Desplazamiento en coordenada Y,Nueva Posición Scorbot en X,Nueva Posición Scorbot en Y.

Flujo de Salida Comando Tomar Objeto



165

Nivel 2

Numero 6,4

Nombre Desplazar Objeto


Descripción Narrativa Proceso en el que recibe la posición a la cual se tiene que desplazar el objeto, realizando un proceso para enviar instrucciones en ACL y lograr su cometido.

Flujo de Entrada Respuesta Comando desplazar Objeto, coordenada X posición destino,coordenada Y posición destino.

Flujo de Salida Comando desplazar Objeto

Flujo de Entrada en el proceso 6.1 de Escritura en Puerto Scorbot. Nombre Flujo Comando Tomar Objeto

Flujo Descripción Instrucciones necesarias para tomar el objeto, de tipo move position, siento estas a una posición en décimas de milímetros , escritas en ACL

Origen Proceso 6.3: Tomar Objeto

Destino Proceso 6.1: Escritura en el puerto Serial

Nombre Flujo Comando Desplazar Objeto

Flujo Descripción Instrucciones necesarias para desplazar el objeto,hasta un lugar de destino,con instrucciones escritas en ACL

Origen Proceso 6.4: Desplazar Objeto

Destino Proceso 6.1: Escritura en el puerto Serial

Flujo de Salida del Proceso 6.1 Escritura en el Puerto serial

Nombre Flujo Solicitud de finalizacion celda

Flujo Descripción Se le indica al scorbot que la trasmisión de comandos ha finalizado, por lo tanto se le indica que se abandonara en seguida el puerto serial.

Origen Proceso 6.1 Escritura en el Puerto serial

Destino Entidad : Scorbot



166

Nombre Flujo Envío de comandos

Flujo Descripción Entrega a la celda flexible instrucciones en su lenguaje ACL, que el controlador las procesara y ejecutara a continuación de esta operación.



Nombre Flujo Inicializacion celda flexible

Flujo Descripción Se le indica al brazo robótico que a continuación del comando enviado se procederá a enviar una serie de comandos, para que el controlador interno de la celda este atento a recibir cualquier instrucción.



Flujo de Entrada en el proceso 6.2 de Lectura en Puerto Serial. Nombre Flujo Respuesta iniciación celda flexible

Flujo Descripción Respuesta a la inicialización enviadas por el scorbot, para de esta forma poder comunicarnos con el mediante instrucciones en ACL

Origen Scorbot

Destino Proceso 6.2: Lectura en puerto Serial

Nombre Flujo Respuesta envio Comandos

Flujo Descripción Es la respuesta que entrega el scorbot al comando previamente enviado.

Origen Scorbot


Nombre Flujo Respuesta finalización celda flexible

Flujo Descripción Respuesta a la finalización del ocupar el scorbot, y asi liberarlo para que pueda ser ocupado por otras personas.

Origen Scorbot




167

Flujo de Salida del Proceso 6.2 Lectura en el puerto serial

Nombre Flujo Respuesta comando tomar objeto

Flujo Descripción Enviá la información pertinente a la respuesta que se analizo al ser leída del puerto serial, en base a tomar el objeto.

Origen Proceso 6.2 Lectura en el puerto serial

Destino Proceso 6.3 Tomar Objeto

Nombre Flujo Respuesta comando desplazar objeto

Flujo Descripción Enviá la información pertinente a la respuesta que se analizo al ser leída del puerto serial en base a desplazar el Objeto.

Origen Proceso 6.2 Lectura en el puerto serial

Destino Proceso 6.4 Desplazar Objeto

Flujo de Entrada en el proceso 6.3 de Toma Objeto.

Nombre Flujo Desplazamiento en coordenada X

Flujo Descripción Es el valor que nos indica cuanto y lo que se debe mover la celda flexible a su coordenada X

Origen Proceso 5: Análisis Coordenadas

Destino Proceso 6.3: Toma Objeto

Nombre Flujo Desplazamiento en coordenada Y

Flujo Descripción Es el valor que nos indica cuanto y lo que se debe mover la celda flexible a su coordenada Y



Nombre Flujo Respuesta Comando tomar Objeto

Flujo Descripción Dato relacionado a con la realización del comando enviado, para ir a tomar el objeto

Origen Proceso 6.2: Lectura Puerto Serial




168

Flujo de Salida del Proceso 6.3 Tomar Objeto

Nombre Flujo Comando Tomar Objeto

Flujo Descripción Se enviá el comando para que sea escrito en el puerto serial

Origen Proceso 6.3 Tomar Objeto.

Destino Proceso 6.1 Escritura en el puerto serial.

Nombre Flujo Nueva posición del scorbot en Y

Flujo Descripción Una vez calculada la nueva posición del scorbot se analiza y se enviá a esta nueva posición en la coordenada Y para que sea analizada en el proceso correspondiente.


Destino Proceso 5 Analizar coordenadas.

Nombre Flujo Nueva posición del scorbot en X

Flujo Descripción Una vez calculada la nueva posición del scorbot se analiza y se enviá a esta nueva posición en la coordenada X para que sea analizada en el proceso correspondiente.


Destino Proceso 5 Analizar coordenadas.

Flujo de Entrada en el proceso 6.4 de Toma Objeto. Nombre Flujo Coordenada X posición destino

Flujo Descripción Coordenada enviada para el desplazar al objeto hasta una posición señalada por el usuario, siendo esto correspondiente en el eje X y procesado para enviar las correspondientes instrucciones en ACL





169

Nombre Flujo Coordenada Y posición destino

Flujo Descripción Coordenada enviada para el desplazar al objeto hasta una posición señalada por el usuario, siendo esto correspondiente en el eje Y y procesado para enviar las correspondientes instrucciones en ACL



Flujo de Salida del Proceso 6.4 Desplazar Objeto

Nombre Flujo Comando desplazar objeto

Flujo Descripción Corresponde al comando de la posición de destino a donde se debe llevar el objeto.

Origen Proceso 6.4 Desplazar Objeto.

Destino Proceso 6.1 Escritura en el puerto serial.

5.4 Integración

En esta sección se tratan los temas de integración para las distintas fases de desarrollo, lo que

deseamos es poder explicar como se traducen los salidas de una fase en entradas para otra, por ejemplo

la salida de la fase de análisis de la imagen nos entrega valores en píxeles, que deben ser traducidos

para que la fase que utiliza la celda flexible pueda interpretar estos valores, por lo tanto esa conversión

es la integración de ambas fases.

También el proceso de ingresar los valores a la maquina difusa e interpretar los valores que nos

entrega esta, es otro proceso de integración, donde las fases de la maquina difusa se unen con la fase

del brazo Robótico.

El tema de integración de la aplicación como tal, se vera en la parte del diseño físico, donde se

integran los conceptos del entorno de desarrollo, OpenCv, Dev-C++.



170

5.4.1 Conversión de Escalas: Píxeles a Décimas de Milímetros

El objetivo de la etapa de análisis de la imagen es obtener los centroides de todos los objetos

detectados dentro de la superficie de trabajo indicada, bueno estos centroides están en píxeles debido a

la imagen y necesitamos saber su ubicación en décimas de milímetros, porque esa es la unidad de

medida en que opera el Scorbot ER-V Plus, para ello debemos hacer una correlación entre los píxeles

de la imagen y las posiciones del Scorbot, por lo tanto seguimos los siguientes pasos:

Primera Parte “Conversión para el eje X”

1.- Lo primero es colocar dos objetos dentro de la superficie de trabajo, objeto A y objeto B

2.- Luego con el Teach Pendant del Scorbot nos movemos hacia el objeto A hasta situarnos encima de

el, una vez encima bajamos lentamente con la pinza abierta y cuando estemos en condiciones de tomar

el objeto dejamos de bajar y cerramos la pinza, capturándolo, sin haberlo movido de su posición, a

continuación en el computador abrimos el modo de operación ATS y escribimos el comando

“listpvposition” ( Figura 4-1) para ver la posición actual del Scorbot en décimas de milímetros, esta

posición corresponde al centroide del objeto dentro de la superficie, las coordenadas cartesianas que

nos interesan son los valores en X e Y que nos entrega ATS, pero en esta primera parte solo nos

centraremos en el valor de X, con esto ya sabemos la posición cartesiana del objeto, por lo tanto

hacemos lo mismo para el objeto B.



171

Figura 4-1: Modo ATS, comando “listpvposition”

3.- Una vez obtenidas las coordenadas cartesianas tanto del objeto A como del B, procedemos a tomar

una imagen de estos dos objetos con la cámara web a través del programa que hemos creado (Figura 4-

2), la cámara ya se encuentra instalada en la posición que se utilizara en la estación de trabajo, por lo

tanto ya esta calibrada, luego la imagen la llevamos al Programa “Paint” donde obtenemos el centroide

(primero para la coordenada X) de cada objeto en píxeles. Con esto estamos en condiciones de realizar

la conversión de píxeles a décimas de milímetros para la componente “X”.

Figura 4-2: Captura realizada a la superficie de trabajo, para eje “X”.



172

4.- Por lo tanto ya tenemos las coordenadas de los centroides en décimas de milímetros y pixeles para

cada objeto, con ello podemos realizar la siguiente comparación:

Figura 4-3: De Píxeles a Décimas de Milímetros para eje X

Como indica la Figura 4-3, el centroide del objeto A se encuentra en el pixel X=82 de la imagen

y según las coordenadas obtenidas en el modo ATS el objeto en esa misma posición se encuentra en la

coordenada cartesiana X=2592 décimas de milímetros, lo mismo ocurre para el objeto B que su

centroide en la imagen esta en el pixel X=144 y según modo ATS esa misma posición corresponde a

X=3372 décimas de milímetros, con esta información podemos decir que desde el objeto A al objeto B

hay una diferencia de 62 pixeles (144-82=62), o una diferencia de 780 décimas de milímetros (3372-

2592=780) , estos valores van a ser nuestro rango de equivalencia para trasformar los pixeles a décimas

de milímetros. A continuación veremos un par de ejemplos de esta transformación:

Como referencia para toda transformación en eje X tomaremos el valor que conocemos del

centroide del objeto A (centroide en: pixel X=82 que es equivalente a la posición X=2592 décimas de

milímetros).



173

-Ejemplo: Píxel X=110

Lo primero es preguntar si el pixel que queremos transformar es mayor igual o menor a nuestro píxel x

de referencia (píxel x=82), como es mayor entonces realizamos la siguiente operación:

Como

resultado de las operaciones anteriores para el píxel X=110, indicaron que este correspondería

aproximadamente a la coordenada cartesiana X=2944 dm.

-Ejemplo Píxel X= 60

Al comparar si es mayor igual o menor que el píxel X=82 de referencia, resulto ser menor, por lo tanto

seguimos estos pasos:



174

En consecuencia obtenemos que el píxel X=60 correspondería aproximadamente a X=2315

décimas de milímetros.

Segunda Parte “Conversión para el eje Y”

Para obtener la escala de conversión para el eje Y los pasos a seguir son muy similares a los del eje X,

solo tienen algunas modificaciones.

1.- Nuevamente colocamos dos objetos en la superficie de trabajo, objeto C y objeto D.

2.- Acá realizamos los mismos pasos indicados en el punto dos, pero de la “Primera Parte Conversión

para eje X”, en resumen con el Teach tomamos primero el objeto C y sin moverlo de su posición,

registramos su ubicación a través del modo ATS, esto es valido también para el objeto D, la posición

que nos interesa es la coordenada cartesiana del eje Y que esta en décimas de milímetros. Por lo tanto

ya tenemos el centroide de ambos objetos.

3.- Con las coordenadas del eje Y en unidades cartesianas lo que hacemos a continuación es tomar una

imagen de los objetos (Figura 4-4) y llevarla al programa “Paint”, acá registramos el valor en píxeles

de la coordenada “Y” del centroide de ambos objetos, entonces con los valores del centroide de lo s dos

objetos en décimas de milímetros y píxeles, podemos realizar la conversión de escala para el eje Y.



175

Figura 4-4: Captura realizada a la superficie de trabajo, para eje “Y”.

4.- En resumen ya tenemos las coordenadas de los centroides en décimas de milímetros y píxeles para

cada objeto, por lo que estamos en condiciones de realizar la conversión de escala para el eje Y.

Figura 4-5: De Píxeles a Décimas de Milímetros para eje Y

En la Figura 4-5, el centroide del objeto C se encuentra en el píxel Y=87 de la imagen obtenida

por el programa que hemos diseñado y según las coordenadas obtenidas en el modo ATS el objeto en



176

esa misma posición se encuentra en la coordenada cartesiana Y=0 décimas de milímetros, lo mismo

ocurre para el objeto D que su centroide en la imagen esta en el píxel Y=151 y según modo ATS esa

misma posición corresponde a Y=693 décimas de milímetros, con esta información podemos decir que

desde el objeto C al objeto D hay una diferencia de 64 píxeles (151-87=64), o una diferencia de 693

décimas de milímetros (693-0=693) , estos valores van a ser nuestro rango de equivalencia para

trasformar los píxeles a décimas de milímetros en el eje Y. A continuación veremos un par de ejemplos

de esta transformación:

Como referencia para toda transformación en el eje Y tomaremos el valor que conocemos del

centroide del objeto C (centroide en: píxel Y=87 que es equivalente a la posición Y=0 décimas de

milímetros).

-Ejemplo: Píxel Y=125

Lo primero es preguntar si el píxel que queremos transformar es mayor igual o menor a nuestro píxel

“Y” de referencia (píxel y=87), como es mayor entonces realizamos la siguiente operación:

Como resultado de las operaciones anteriores para el píxel Y=125, indicaron que este

correspondería aproximadamente a la coordenada cartesiana Y=411 dm.



177

-Ejemplo: Píxel Y=55

Al comparar si es mayor igual o menor que el píxel Y=87 de referencia, como vemos resulto ser menor,

por lo tanto seguimos estos pasos:

En consecuencia obtenemos que el píxel Y=55 correspondería aproximadamente a Y=-347

décimas de milímetros.

5.4.2 Interpretación de los valores entregados por “Lógica Difusa”

Como vimos anteriormente en el capítulo correspondiente a la maquina de lógica difusa, esta

recibe como variables de entrada el margen de error, tanto del eje X, como del eje Y, y tras la aplicación

de esta maquina se obtiene como resultado un porcentaje para el eje X y otro para el eje Y, ese

porcentaje nos indicara hacia donde movernos, para conseguir esto debemos interpretar estas salidas,

pero antes debemos tener muy claro la utilización de esta maquina difusa, por lo que hemos preparado

un pequeño ejemplo al momento de ingresar los margenes de error a la maquina difusa.

Sabemos de ante mano que la posición de inicio del scorbot, es conocida por nosotros, es decir

antes de comenzar a ingresar los margenes de error en la maquina difusa, el scorbot ya se encuentra en

esta posición, la cual es en el eje X=2799, eje Y=90.



178

Ahora también conocemos el centroide del objeto en décimas de milímetros, debido a la

conversión realizada en el punto anterior de este capítulo, por lo tanto podemos establecer una

diferencia de error respecto de ambas posiciones (entre la del scorbot y la del objeto). Entonces este

margen de error es el que entra en la maquina difusa y nos entrega como salidas un % para cada eje que

nos indica hacia donde tenemos que movernos para estar mas cerca del objeto, este procedimiento se

repite hasta que se logre situar la celda flexible sobre el centroide del objeto, una vez en ese lugar se

encuentra en condiciones de bajar el brazo y tomar el objeto.

Lo primero antes de obtener las salidas es calcular los márgenes de error de ambos ejes y para

ello presentamos la figura 4-6, donde se muestra la posición de inicio del scorbot representada por la

letra “A” y la posición del objeto que se desea tomar con la celda flexible, que correspondería a la letra

“B”:

Figura 4-6: Representación Cartesiana.



179

Por lo tanto independiente de la posición del objeto en el plano cartesiano, estando dentro de los

limites establecidos en la superficie de trabajo, el calculo del margen de error seria de esta manera:

Donde el margenErrorX corresponde a la diferencia entre la posición actual del Scorbot

(posición conocida y registrada por nosotros) y la posición del centroide del objeto (posicionObjetoX),

recordemos que esta posición es el resultado de la fase de desarrollo de análisis de la imagen y se

encuentra en píxeles, por lo que fue necesario pasarla a décimas de milímetros como explicamos

paginas anteriormente, entonces ya se encuentra en décimas de milímetros, este calculo y explicación

también es valido para margenErrorY, pero con la diferencia que es representativo para la coordenada

cartesiana Y.

Siguiendo el ejemplo propuesto los valores de lo margenes de error serian los siguientes:

Con el concepto de las variables de entradas ya claras podemos interpretar las salidas, que a

partir de los margenes de errores ingresados serian, 88,1538% y -88,1538% correspondientes cada una

al eje X y al eje Y respectivamente.

Como sabemos las salidas nos indican hacia donde tenemos que mover la celda flexible,

entonces para el eje X, si ingresamos un error de -744, nuestra maquina difusa interpreta este valor y

nos indica que estamos situado muy a la Izquierda del objeto, entonces este valor linguístico se lleva a

una representación en una escala porcentual arrojando un valor de 88.1538%, esto quiere decir que

debemos movernos muy a la derecha en un 88,1538% de nuestro margen de error, para estar de esta

forma mas cerca del objeto, de la misma forma ocurre para el eje Y. Entonces la nueva posición del

scorbot se compone de estos valores ya calculados.



180

Esta operación anterior se repite hasta que el margen de error para cada eje sea cero, esto quiere

decir que nos encontramos justo sobre el centroide del objeto, por lo cual debemos bajar el brazo

robótico y tomar el objeto seleccionado.

5.5 Diseño Físico

Lo correspondiente al diseño físico son temas relacionados en primer lugar con la elección del

lenguaje de programación de la interfaz gráfica para nuestro sistema, y para ello debemos tomar en

cuenta las fases, ya que en cada una se desarrolla un prototipo , de acuerdo a la metodología escogida

para este proyecto, por lo tanto esta interfaz debe ser capaz de integrar estos prototipos y mejorarlos,

también otro aspecto a considerar es que para efectos del sistema según los requerimientos no es una

aplicación que maneje base de datos, por que no compete con el objetivo del proyecto, ni tampoco

incluir tantos componentes visuales, debe ser una interfaz simple que valla mostrando paso a paso lo

que va sucediendo hasta seleccionar el objeto, encapsulando todos los métodos internos activados al

producirse un evento, en la cual el usuario debe conocer previamente el tema del proyecto, de acuerdo

a que no es una sistema para que un usuario común y corriente pueda usarlo, debido al nivel de

complejidad que trata el tema propuesto. Con lo anterior mencionado, consideramos que la mejor

opción era trabajar bajo el lenguaje C++, por que nos permite flexibilidad en la integración de todas las

fases, además de su eficiencia.

Esta sección por lo tanto da a conocer las librerías para el desarrollo de la interfaz gráfica, su

IDE, la importancia de este, ventajas que nos entrega, entre otros conceptos. También se ha incluido la

integración, por decir física de las diferentes bibliotecas empleadas para la programación de cada fase

de desarrollo, y como todas estas se integran en un solo IDE de desarrollo. También se incluye una

representación de diagrama de clases para ver en forma global la implementación del sistema en si,

hasta llegar al diseño de interfaces, que muestra gráficamente como es el sistema y su funcionalidad.



181

5.5.1 QT

Qt representa una biblioteca para el desarrollo de interfaces en “lenguaje C++” que ocuparemos

para la programación y diseño de la interfaz gráfica de la aplicación del sistema, a continuación se

presentara con mas detención, explicando en que consiste, su estructura de desarrollo, su IDE y las

ventajas que nos entrega este.

5.5.2 ¿Que es Qt? Qt corresponde a un conjunto de librerías o también llamada biblioteca que tiene la

característica de ser multiplataforma, la cual esta implementada para desarrollar interfaces gráficas de

usuario principalmente, pero además podemos realizar aplicaciones completas sin interfaces gráficas

haciendo sólo uso de éstas librerías, como aplicaciones de consola entre otras.

Como nombramos que esta librería es multiplataforma, queremos destacar que se encuentra

disponible tanto para:

• Microsoft Windows: En sus variadas versiones.

• Unix/X11 Linux, Sun Solaris, HP-UX, HP Tru64 UNIX, IBM AIX, SGI IRIX y muchas otras

• Mac OS X

• Windows CE

• Embedded Linux

De este modo podemos ver que en diferentes plataformas es totalmente compatible y se

encuentra listo para migrar. Qt es una librería totalmente Orientada a Objetos, es por ello que la API

cuenta con diferentes métodos, soporta el uso de diferentes motores de Base de Datos entre ellos SQL y

el uso de archivos XML, además de otras estructuras de datos tradicionales.



182

Qt en su forma originaria trabaja con el lenguaje de programación C++, pero existen módulos

para otros lenguajes de programación gracias a una adaptación o referencia (bindings), entre los cuales

tenemos Python (PyQT), Java (QT Jambi), Perl (PerlQT) , Ruby (QTRuby), PHP (PHP-QT), entre los

más reconocidos.

Hay que destacar que Qt fue credo por Trolltech, que es una compañía de software fundada en

el año 1994, posteriormente esta compañía es comprada por Nokia en el año 2008, y es de donde

actualmente se dirige su desarrollo. Hoy en día Qt cuenta con tres tipos diferentes de licencias, una para

el desarrollo de software de código abierto (open source) y software libre, llamada GPL v2/v3, la

siguiente es una licencia para el desarrollo de aplicaciones comerciales (licencia de pago QPL), y a

partir de la versión 4.5 una licencia gratuita que esta recomendada para aplicaciones comerciales,

LGPL.

Como referencia, podemos enmarcar la presencia del uso de Qt en el entorno de escritorios

KDE, presentes en sistemas como GNU/Linux o el proyecto FreeBSD desarrollado por la Universidad

de California, Berkeley, también Qt ha sido utilizado para realizar aplicaciones como, Google Earth

(simulador de mapas), Skype (realiza llamadas sobre internet), VLC Media Placer (reproductor

multimedia), Last.fm Player y Qt Creator, que es un entorno de desarrollo integrado, software libre y

multiplataforma desarrollado por Nokia y este corresponde al que utilizamos para realizar la aplicación

del Proyecto.

5.5.3 Estructura de Qt Dentro de la estructura de Qt, tenemos varias características como “look an feel” variable

dependiendo del Sistema Operativo, para parecerse a estilos ya existentes (Windows, Mac, Motif…),

Internacionalización a través de QString y Unicote, OpelGL multiplataformas, Parser XML integrado,

manejo de Base de Datos SQL, además de Herramientas de generación automática Qt Designer.



183

Su estructura de librerías esta descrita de la siguiente forma:

Modulo I:

QtCore: Clases básicas, no GUI, usadas por todos los módulos.

QtGui: Componentes GUI (lo útil para gráficos)

QtNetwork: Clases para programación de redes

QtOpenGL: Clases para soporte OpenGL

QtSql: Clases para integración de bases de datos SQL

QtSvg: Clases para integración de dibujos vectoriales SVG

QtScript: Expone las aplicaciones a scripting con un lenguaje ECMAscript.

QtScriptTools: In depurador de QtScript.

Modulo II:

QtWebKit: Es el popular motor Web, con Qt

QtXml: Clases para manejar XML.

QtXmlPatterns: Un motor de XQuery 1.0 y XPath 2.0 y parcialmente Xslt.

Phonon: el Framework multimedia.

QtDesigner: API para Qt Designer.

QtUiTools: Clases para manejar los formularios .ui del Designer.

QtAssistant: Soporte para línea online.

Qt3Support: Clases para compatibilidad Qt3.

Otros: QtHealp, QtTest, QtDBus(Solo Unix), y a partir de Qt 4.6 QtOpenVG y QtMultimedia.



184

Figura 4-7: Conjunto de Características de QT.

5.5.4 ¿Por qué usar QT?

• QT es un proyecto de Código Abierto y gratuito de libre distribución.

• Otra de las principales ventajas que nos ofrece QT es que es multiplataforma, una aplicación

desarrollada utilizando estas librerías se podría compilar tanto en linux como en Windows, Mac

OS o inclusive en un dispositivo móvil, sin necesidad de hacer ningún cambio en el código.

• La diferencia entre Qt y otras soluciones multiplataforma es que no esta basada en una maquina

virtual tal como Java, .NET. Sino que su compilación es totalmente a un código nativo con



185

instrucciones maquina y no en código intermedio con instrucciones para la maquina virtual. Lo

cual se refleja en un mejor desempeño en comparación con otras soluciones.

• Otra ventaja es que nos permite construir interfaces de usuario complejas de una forma visual y

rápida, lo que nos deja más tiempo para centrarnos en la parte más importante de todo

programa.

• Al utilizar el lenguaje de programación C++, podemos hacer uso del potencial de la

programación orientada a objetos, además de la compatibilidad que debe existir ya que estamos

trabajando con OpenCV.

• Podemos construir interfaces gráficas visualmente muy atractivas en poco tiempo.

• Otra característica que nos llamó la atención es que nos da la posibilidad de integrar nuestro

código desarrollado bajo QT, y agregarlo a un proyecto en Dev-C++ (gracias al Makefile

generado del código QT), que es donde tenemos integrado OpenCV, por lo que al final podemos

compilar desde Dev-C++ aplicación en Qt y mezclarlas con funcionalidades de OpenCV.

5.5.5 Qt Creator

Es un IDE multiplataformas para desarrollar aplicaciones en C++ de manera sencilla y rápida.

Como su nombre lo indica, está basado en la librería Qt y cuenta con las siguientes características

principales:

• Editor avanzado para C++.

• Interfaz agradable y fácil de adaptar.

• Diseñador de formularios (GUI) integrado.

• Herramientas para la administración y construcción de proyectos.

• Es rápido.

• Completado automático.



186

• Depurador visual.

Figura 4-8: Entorno de Desarrollo QT Creator.

5.5.6 Integración de QT y OpenCV en Dev-c++

La primera etapa en nuestro proyecto es el tratamiento de la imagen y para ello escogimos por

las diversas razones mencionadas anteriormente OpenCV, para esto previamente se debe instalar Dev-

C++ que va ser quien albergar tanto a OpenCV y Qt.

Una vez instalado Dev-C++, se procede con la instalación de OpenCV, a continuación debemos

modificar las opciones del copilador de Dev-C++, agregando en esta parte un nuevo compilador y los

correspondientes directorios de OpenCV que hacen referencia a Binarios, Librerías y Cabeceras



187

C/C++, previo esto ya estamos en condiciones de trabajar con las librerías de OpenCV.

El paso siguiente es instalar Qt Creator, este instala Qt por defecto, finalizado lo anterior

podemos ejecutar Qt Creator y programar nuestra aplicación con este IDE, cuando tengamos el

proyecto Qt prácticamente desarrollado, lo que debemos hacer es compilarlo en Dev-C++ para

integrarlo con las funciones de OpenCV, pero para compilar el proyecto Qt debemos asegurarnos que

las variables de entorno estén debidamente configuradas, una vez verificado lo anterior, en la consola

nos ubicamos donde tenemos el proyecto Qt y realizamos qmake –project y luego qmake, generando

así un archivo .pro con el nombre de la carpeta donde tenemos el proyecto, este archivo .pro debemos

modificarlo agregando en INCLUDEPATH += los directorios de OpenCV, además de agregar LIBS

+= que corresponden a las librerías de OpenCV, aparte del archivo .pro, nos genera también un

Makefile y este lo ocuparemos cuando abramos el proyecto en Dec-C++ y modifiquemos en opciones

del proyecto marcando en Archivo MAKEFILE su uso. Con todos estos pasos ya estamos en

condiciones de compilar nuestro proyecto integrado desde Dev-C++.

5.5.7 Diagrama de Clases

Un diagrama de clases describe gráficamente las especificaciones de las clases de software en

una aplicación. Para la creación del diagrama de clases se identifican todas las clases que participan en

la solución y se agregan los atributos encontrados, y los métodos que hacen relación a cada clase, por

lo tanto a continuación se muestra el diagrama de clases de nuestro sistema presentado en el ultimo

Anexo al final del informe.



188



189

5.5.8 Diseño Físico de Interfaces

Como sabemos el diseño de la aplicación debe ser simple, no se necesitan muchos componentes

visuales, como se especifico en los requerimientos, solo se necesita que la interfaz sea intuitiva para

alguien que conozca el tema que se trata en este proyecto, así podrá efectuar un mayor provecho de

este. Encapsulando todos los métodos que están compuestos de algoritmos que procesaran cada etapa

en el sistema, en donde veremos solo los resultados de este procesamiento en la interfaz, abstrayendo

totalmente al usuario de la implementación interna de la aplicación

A continuación se ira presentando la interfaz, que va etapa a etapa en el desarrollo de los temas

propuestas en este proyecto, para que el usuario conocedor del tema valla asimilando y sacando sus

propias conclusiones a lo largo del sistema.

Al iniciar el programa se despliega la pantalla principal, mostrando de esta forma la temática del

proyecto. Para dar inicio al funcionamiento de la aplicación nos dirigimos al menú archivo donde

seleccionamos la opción captura imagen.



190

Figura 4-8: Pantalla Principal.

A partir de la selección realizada anteriormente se muestra la siguiente ventana que es donde

podemos ver la cámara en vivo de la superficie de trabajo donde se encuentran los objetos, una vez

listos los objetos dentro de la superficie realizamos la captura de la imagen a través de la webcam, y

para ello se presiona en el botón Capturar Imagen, esta captura es visualizada en la siguiente pantalla

(Figura 4-9), por lo tanto ya tenemos nuestra imagen de la superficie donde se encuentra los objetos,

por lo que estamos en condiciones de comenzar el procesamiento de la imagen en mas profundidad y



191

detalle, ya que para comenzar era primordial tener la imagen de los objetos, también se debe dejar claro

que una vez tomada la imagen y comenzado el proceso de análisis no se podrán mover los objetos de su

posición, ya que si esto ocurre al final del análisis y cuando se desee tomar el objeto y si estos han sido

movidos de su posición de donde estaban inicialmente al tomar la imagen, la fase de demostración

queda anulada, ya que las coordenadas no corresponderían con las del objeto en su nueva posición, por

lo tanto esta posición no debe cambiar durante el análisis de la imagen.

Figura 4-9: Imagen capturada desde la webcam.

Como ejemplo de implementación la forma de realizar la captura es gracias a las librerías que



192

nos ofrece OpenCV, por lo que mostramos un fragmento de código en el cual se captura una imagen de

un video, añado que este fragmento es solo un ejemplo, el que realmente esta presente en nuestra

implementación es algo mas complejo, debido a las trasformaciones de formatos de imagen tanto de

OpenCv a Qt,entonces para efecto de esto se a creado una clase llamada QOpenCVWidget que se

puede ver en el diagrama de clases que se encuentra en el anexo donde esta representa gran parte de la

captura de la imagen. Sin dejar de lado lo anterior los dejamos con el fragmento de código:

Este código muestra una variable capture, la cual es la encargada de tener la referencia a la

cámara web ya que se inicializa esta mas abajo con cvCaptureFromCAM(0) y frame va a corresponder

a la imagen obtenida de la cámara, para que el efecto sea de video se crea un ciclo while donde frame =

cvQueryFrame(capture), para obtener una imagen de la webcam y a continuación la mostremos a través

de la ventana creada con cvShowImage, esta aplicación finaliza cuando se presiona la letra “q”, para

salir del ciclo while.

La Figura siguiente corresponde a la aplicación del algoritmo MeanShift a la imagen obtenida

desde el video que nos proporciono la cámara, para aplicar el algoritmo presionamos el botón

Meanshift y veremos los resultados a continuación en la siguiente figura que nos muestra la pantalla de

esta etapa (Figura 4-10), pero primero queremos que mas o menos vean como se aplica el algoritmo

meanshift a nuestra aplicación.



193

Figura 4-10: Aplicación de algoritmo MeanShift a la Imagen.



194

Como vemos al presionar sobre el botón MeanShift se activo el botón Siguiente, por lo que

estamos en condiciones de pasar a la siguiente etapa que corresponde a la binarización de la imagen,

acá podremos realizar en primer lugar una binarización normal de la imagen a la cual se le aplico el

algoritmo meanshift, para posteriormente realizar una binarización inversa de esta.

Para realizar la binarización normal se debe presionar el único botón activado que se encuentra

en la pantalla de binarización, que corresponde a binarización 1 como veos a continuación:

Figura 4-11: Pantalla Binarización.



195

Como vemos si presionamos este boton binarización 1 se genera una nueva ventana que

muestra la imagen meanshift pero lista para ser binarizada según el umbral de binarización que le

apliquemos al deslizar el slider, al realizar el movimiento del Slider podemos cambiar los niveles de

binarización de la imagen (Figura 4-12), este proceso termina cuando logramos encontrar el resultado

deseado y presionamos en el botón listo para enviar la imagen al form de Binarización principal, para

continuar con el siguiente paso que es la generación de una Binarización 2 en donde realizamos la

aplicación de una Binarización inversa a la imagen meanshift para obtener la forma completa del objeto

requerido. Para ello presionamos el botón Binarización 2 del form de Binarización principal y este

genera un nuevo form de Binarización inversa (Figura 4-13), también posee un slider donde

modificamos los niveles de umbralización hasta encontrar el adecuado y presionamos el botón finalizar

para enviar esta imagen al form de binarización principal.

Figura 4-12: Binarización Normal.



196

Figura 4-13: Binarización Inversa.

Cada vez que binarizamos estamos aplicando el siguiente método a nuestra imagen al modificar

cada valor de umbral entregado por el slider:

Con las dos imágenes binarizadas, una binarizada normal y la otra binarizada inversamente,

podemos mezclar ambas para encontrar un resultado optimo que nos permita identificar completamente

a los objetos, si al mezclar el resultado no es el que estamos buscando entonces podemos volver a la las

ventanas mostradas en la figura 4-12, 4-13 y modificar los niveles de optimización hasta encontrar el



197

deseado, una vez encontrado se presiona en el botón listo para cargar las imágenes en la pantalla de

binarización principal, y volvemos a mezclar, obteniendo de esta forma una solo imagen a partir de las

dos que teníamos, con ello podemos ver que las figuras están totalmente identificados (Figura 4-14),

por lo que entonces continuamos con la siguiente etapa al presionar el botón siguiente.

Antes queremos mostrar un fragmento de como se realiza la mezcla entre ambas binarizaciones,

normal e inversa.

Figura 4-14: Binarización, Imagen Mezclada.



198

Al presionar siguiente el posterior paso es aplicar un proceso de deformación de la imagen, el

primero es una erosión de ella para rellenar los bordes faltantes y luego aplicar una dilatación, con estas

operaciones estamos en condiciones optimas de poder calcular los centroides de los objetos detectados,

debido a que los objetos se encuentran bien definidos respecto a su forma original, estos se aprecia en

la figura 4-15, a parte se introduce un código en OpenCv que detalla esta operación de trasformación

morfológica de la imagen a nivel de implementación.

Figura 4-15: Transformación Morfológica.



199

A continuación al presionar el botón siguiente de esta interfaz realizamos la detección de bordes

de los objetos y la identificación del centroide de ellos, para detectar el centroide de los objetos se

implemento el siguiente método, que recibe como parámetro de entrada la imagen y un rectángulo, que

corresponde al rectángulo que rodea al objeto. Y como resultado nos entrega el centróide de este mismo

objeto.

La operación anterior es aplicable a todos los objetos detectados en la imagen que se tomó

inicialmente de la cámara web, por lo tanto si el objeto esta identificado, se le calcula de esta manera su

centroide, con lo que ya estaríamos cumpliendo gran parte del trabajo propuesto, debido a todo el

análisis realizado,de esta forma estamos identificando el centro de gravedad de cada uno de los objetos,

que es justo el valor que necesitamos para pasar a la fase de la celda flexible.

Ademas de la implementación, se da a conocer la interfaz donde se muestran gráficamente los

centroides de cada objeto detectado en la imagen resultante de la trasformación morfológica ver figura

4-16 .



200

Figura 4-16: Detección de Centroides.

Una vez identificado el centroide de la imagen podemos mostrar los bordes de ella encerrando

cada objeto en un rectángulo seleccionable en la imagen original, para que de esta forma podamos

escoger el objeto que queremos tomar con la celda flexible. En seguida se muestra la pantalla que

indica estos pasos.



201

Figura 4-17: Selección de Objetos.

Al seleccionar un objeto el mensaje que nos aparece es el que veremos mas abajo, este mensaje

nos pregunta si estamos seguro si deseamos tomar el objeto que seleccionamos, si presionamos el

botón ver detalle mostrara el centroide del objeto que se selecciono, en cambio si presionamos el botón

no, este nos retornara a la pantalla seleccionar objetos para que de esta forma podamos escoger otro, y

si presionamos el botón si, pasamos a la etapa de selección de destino de objetos, en esta muestra la

misma pantalla de objetos detectados pero nos indica que debemos hacer click sobre la posición dentro

de los limites de la imagen, donde deseamos trasladar el objeto que escogimos, al seleccionar la

posición esta se verificara y nos retornara un mensaje si fue correcta o no, en caso de ser no, puede que

se aya escogido una posición fuera de los limites de alcance del scorbot o esta posición entre en

conflicto con alguna posición donde ya se encuentre un objeto ubicado, pero si es si, quiere decir que la



202

posición esta libre por lo tanto podemos mover el objeto hacia ella, es justo en este momento donde se

lanza la aplicación de la lógica difusa y el puerto serial, que tiene como valores de entrada la posición

del objeto en pixeles y su ubicación de destino, por lo que de aquí en adelante el procesamiento es solo

de la maquina difusa y la celda flexible, son procedimientos internos de la aplicación.

Figura 4-18: Mensaje Selección de Objetos.

5.6 Problemas surgidos y dificultades de esta “Capítulo”

Este es el capítulo decisivo donde todo lo estudiado a lo largo del proyecto y prototipos

construidos de acuerdo a la metodología se deben integrar en una solo solución representada a través de

una aplicación que contemplo todas las capítulos anteriormente descritas, por lo tanto es claro que

tuvimos muchos inconvenientes en el camino, como por ejemplo desde el primer minuto que se

realizaron los requerimientos y casos de uso, ya teníamos una idea de como se debía armar estas piezas

(fases) pero solo a nivel conceptual, las preocupaciones vinieron cuando necesitamos llevarlas a la

implementación, entonces para ver como interactúan cada proceso del sistema fue fundamental el

apoyo del diagrama de flujo de datos, que nos mostraba cada vez que estábamos confundidos que debía

hacer el sistema y que no debía hacer, por lo que estos nos brindaron un gran apoyo.

Unos de los problemas mas complicados fue plantearnos que haría nuestro sistema a través del

diagrama de flujo de datos, por lo que le dedicamos bastante tiempo a detallar esta parte para después

de realizar todo este análisis lógico debíamos continuar con la integración propia, es decir de que



203

manera ivamos a realizar el enfoque de la trasformación de pixeles, por ello tomamos varias muestras a

las posiciones del scorbot y la ubicación de este en la imagen hasta que logramos llegar a una

correlación que nos sirviera aproximadamente para la gran mayoría de las posiciones dentro de los

limites de la superficie en la imagen, esta tarea fue complicada. También el tema de interpretar los

valores que nos entregaba la maquina difusa fue difícil al principio por la poca experiencia practica

sobre el tema, si conocíamos teóricamente su funcionamiento pero nunca habíamos programado una

concretamente, solo lo habíamos realizado a nivel escrito en ejercicios prácticos en clases, por lo tanto

fue parte fundamental aplicar todos nuestros conocimientos sobre esta área y así logramos obtener los

resultados deseados.

En la parte de la implementación física a nivel de integración de librerías tanto las de QT,

Opencv en Dev-C++, fue complicado debido a la escasa documentación, que solo la encontramos en

Internet, pero lo poco que recolectamos nos sirvió de mucho para lograr configurar estas librerías hasta

poder tenerlas funcionando correctamente, así proporcionamos el tema de la interfaz gráfica que

integraba las demás fases propuestas.

El diseño de la interfaz se rigió por la simplicidad que debe tener este frete a temas de mayor

complejidad como Inteligencia artificial, visión artificial, robótica, comunicación serial entro otros, por

lo tanto al final de todo sacamos cuentas alegres de todo lo aprendido en este capítulo.


Conclusión

204

Conclusión del Proyecto

El tema propuesto en este proyecto trata áreas muy complejas que no son estudiadas

específicamente a profundidad a lo largo de nuestra malla curricular, por ello mas que todo lo que

significaba realizar un proyecto de titulo , nosotros escogimos un reto, algo en lo que debiéramos

aplicar mas que conocimientos específicos, si no que debían ser conocimientos que representaran la

suma de todos estos años de estudio, en el cual los profesores de nuestra universidad nos formaron

para se ingenieros, para pensar como tales, para ser capaces de enfrentarnos a cualquier situación, y

plantear una solución concreta a esta.

Este proyecto trato temas relacionados con la robótica, la visión artificial, la inteligencia

artificial, en el cual nosotros como futuros Ingenieros Civiles en Informática, construimos prototipos

de cada una de estos capítulos a partir de la metodología propuesta para enfrentarnos a la problemática

descrita en los capítulos preliminares y logramos realizar la integración de cada una de estas en un

sistema que pudiera ser capaz de cumplir con los objetivos propuestos que era en conclusión “Tomar

un objeto cilíndrico con un celda flexible dentro de un plano determinado a partir de las coordenadas

obtenidas mediante visión artificial y desplazarlo”.

Esto no fue fácil, tuvimos muchos inconvenientes pero no nos dejamos avasallar, en primera

instancia se le dedico una buena parte de nuestro tiempo a estudiar cada unas de estas áreas debido a

que no están contempladas en nuestro plan de estudios, pero para efecto de nuestro proyecto debíamos

comenzar por ahí, lograr adquirir dominio del tema, para pasar a la siguiente instancia que fue

comenzar a plantearnos como dar solución y cumplimento a los requerimientos expuestos, por lo tanto

la etapa de análisis y diseño cumplieron un rol fundamental para que en ningún momento perdiéramos

de vista el objetivo del proyecto, así logramos realizar una representación del sistema a través de

distintos tipos de diagramas que fueron explicados a lo largo del informe.


Conclusión

205

Por lo tanto la forma en que se abordo cada capítulo, en resumen fue correcta, ya que estas se

tomaron como procesos que a partir de los datos de entradas se debían generan salidas que servirían

para el siguiente proceso, por lo tanto entre proceso y proceso debían haber integraciones ya que se

deben establecer compatibilidades entre cada uno de ellos, entonces a lo largo del estudio se plantearon

distas forma de integración que fueran detalladas en el informe, que en resumidas cuentan sirvieron

como puentes entre cada fase hasta lograr una comunicación de todas ellas que entregaron como

resultado la creación de una aplicación.

Los resultados obtenidos de esta aplicación fueron satisfactorios debido a todo el esfuerzo

plasmado en su desarrollo y pruebas realizadas, afinando los máximos detalles para lograr que a partir

de una simple imagen tomada con una cámara web, a través de nuestro programa, se pudiera analizarla

hasta llegar a identificar los centroides de cada objeto y con esta información le indicamos al usuario

que objeto desea seleccionar, y a partir de su respuesta le ofrecemos donde quiere trasladarlo, por lo

tanto le damos la libertad de tomar y mover estos objetos con la celda flexible dentro del área de

trabajo disponible.

Con el aprendizaje de todos estos conceptos nos dimos cuenta de la importancia de la

informática en la automatización del procesos en el área de la industria y como nuestro país se atreve a

abrir nuevos mercados e invertir en tecnología de la cual necesita profesionales como nosotros para

manejara y entregar de esta manera su máximo provecho en vías para el desarrollo de la empresa.

Para finalizar, esta fue la experiencia que nos permitió simular el área de trabajo facilitada por

el Laboratorio CIMUBB de nuestra Universidad del Bio-Bio, junto a nuestro profesor Guiá Doctor

Juan Carlos Parra y Don Christían Aguilera Carrasco Director del centro CIMUBB.


Bibliografía

206

Bibliografía

CIMUBB: Laboratorio de Sistemas Automatizados de Producción.

[on line] http://www.cimubb.ubiobio.cl

Laboratorio CIMUBB: Manuales operacionales y funcionales del Robot Scorbot ER-V Plus,

facilitados por el Ingeniero de soporte a cargo Don Luis Vera : Scotbot-ER VpLus Manual

de Usuario Nº Cat 100265 Rev.A; ACL Lenguaje de Control avanzado versión 1.43, F44

Guiá de Referencia Para Controlador-A; ATS Software Terminal Avanzado versión 1.44 Guiá

de Referencia Para Controlador-A; Scorbase Para Windows SCORBASEpro, Manual de

Usuario Nº Cat. 100268 Rev.A; ACLoff-line Software version 1.67 Manual de Usuario

Nº Cat. 100273 Rev.01.

FLEB: Libro Electrónico sobre Lógica Difusa - Andrés Bermúdez, Angel Barriga, Iluminada

Baturone, Santiago Sánchez - Instituto de Microelectrónica de Sevilla

[on line] (http://www.imse.cnm.es/online/Articulos/671.pdf ).

Visión por Computador, Imágenes digitales y aplicaciones :Libro de la Biblioteca de Nuestra

Universidad, Autores Gonzalo Pajares y Jesús M. de la Cruz .

Inteligencia Artificial Un Enfoque Moderno , Libro de la Biblioteca de Nuestra Universidad,

Segunda Edición. Stuart Russell (Prentice Hall).

QT: La Pagina Oficial de la librería de desarrollo de interfaces graficas Qt, donde obtuvimos la

documentación de referencia [on line] (http://qt.nokia.com/).


Bibliografía

207

Learning OpenCV, Computer Vision with the OpenCV Library: Libro que enseña a programar

usando las librerias de OpenCV, escencial para cualquiera que necesite trabajar en vision por

computador, o la vision artificial mediante C y/o C++, Autores Gary Bradski and Adrian

Kaehler.

LearningOpenCV_Code (codigos de ejemplos de OpenCv): Documentation y ejemplos detallados

del Libro Learning OpenCV.

Matlab: Pagina oficial con la documentacion necesaria de este software, se consulto la

documentacion [on line] http://www.mathworks.com/

LnxComm: Libreria del puerto serial, que nos entrega el conocimiento necesario para manipular el

puerto. [on line] http://zsoluciones.com/datos/?page_id=11

Introducción a la Robotica: Libro que introduce a la robotica de forma experimenta desde

cualquier nivel inicial.Autor Jose Maria Angulo, Susana Yesa Romero, editorial Paraninfo

Digital image processing: Libro de procesamiento de imagenes.Autor González, Rafael C.

Digital image processing using MATLAB: Libro de procesamiento de imagenes usando matlab.

Autor González, Rafael C.

Volumetric image analysis: analisis de imagenes volumetricas. Autor Lohmann, Gabriele


“desarrollo de interfaz para el traslado de un objeto...

Documents