4.3.5 Selección de las articulaciones a utilizar

INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA

“BRAZO ROBÓTICO CONTROLADO MEDIANTE SENSOR KINECT”

TESIS

QUE PARA OBTENER EL TÍTULO DE INGENIERO EN COMUNICACIONES Y ELECTRÓNICA

PRESENTA:

FRANCISCO JAVIER VÁZQUEZ VÁZQUEZ

ASESOR:

ING. ARMANDO MANCILLA LEÓN

MÉXICO, D.F. 2013

INSTITUTO POLITÉCNICO NACIONAL ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELECTRICA

UNIDAD PROFESIONAL "ADO LFO LÓPEZ MATEOS"

TEMA DE TE S I S

INGENIERO EN COMUNICACIONES Y ELECTRÓNICA QUE PARA OBTENER EL TITU LO DE TESIS Y EXAMEN ORAL INDIVIDUAL POR LA OPCI Ó N DE TITULACIÓN

DEBERA(N) DESARRO LLA R C. FRANCISCO JAVIER V ÁZQUEZ V ÁZQUEZ

"BRAZO ROBÓTICO CONTROLADO MEDIANTE SENSOR KINECT"

CONSTRUIR EL PROTOTIPO DE UN BRAZO ROBÓTICO INTEGRADO POR TRES GRADOS DE LIBERTAD Y UNA PINZA DE SUJECIÓN, PROGRAMADO PARA MOVERSE DE ACUERDO A LOS MOVIMIENTOS HECHOS POR EL

BRAZO DEL USUARIO DE FORMA SIMULTANEA, DICHOS MOVIMIENTOS DEL USUARIO SERÁN ADQUIRIDOS A TRAVÉS DEL SENSOR MICROSOFT KINECT .

• :. INTRODUCCIÓN . • :. ESTADO DEL ARTE. .:. MARCO TEÓRICO. • :. DESCRIPCIÓN DEL HARDWARE. .:. DISEÑO DEL SOFTWARE. .:. PRUEBAS y RESULTADOS . • :. • :. • :.

CONCLUSIONES . BIBLIOGRAFÍA . ANEXOS.

JEFE DEL DEPA INGENIERÍA EN COM

MÉXICO D. F., A 10 DE JUNIO DE 2013.

i

Índice general Introducción .......................................................................................................................... 1

Definición del problema ............................................................................................................. 1

Justificación ............................................................................................................................... 2

Objetivos del proyecto ............................................................................................................... 3

General .................................................................................................................................. 3

Específicos ............................................................................................................................. 3

Capítulo 1 Estado del arte ......................................................................................................... 4

1.1 Control de un Robot ABB con Kinect ..................................................................................... 4

1.2 Brazo robótico controlado mediante gestos a través de Kinect ............................................. 5

1.3 Uso médico del Kinect .......................................................................................................... 5

1.4 Perro robot guía para ciegos ................................................................................................. 6

Capítulo 2 Marco teórico .......................................................................................................... 7

2.1 Sistemas en tiempo real ....................................................................................................... 7

2.1.1 Sensores ........................................................................................................................ 9

2.1.2 Acondicionamiento de la señal ....................................................................................11

2.1.3 Conversión analógica a digital .......................................................................................11

2.1.4 Procesamiento digital ...................................................................................................14

2.1.5 Clasificación de los sistemas en tiempo real ..................................................................16

Capítulo 3 Descripción del Hardware ....................................................................................... 17

3.1 Sensor de movimiento y obtención de datos ..................................................................... 18

3.1.1 Sensor de profundidad .................................................................................................21

3.1.2 Detección y seguimiento de usuario .............................................................................25

3.1.3 Librerías de libre acceso para la programación de Kinect ..............................................29

3.2 Dispositivos de procesamiento digital ................................................................................. 33

3.2.1 Descripción de los dispositivos de procesamiento .........................................................33

3.2.2 Comunicación entre la computadora y microcontrolador PIC18F4550 ..........................35

3.3 Servomotores .................................................................................................................... 36

ii

3.3.1 Principio de funcionamiento .........................................................................................37

3.3.2 Control de un servomotor ............................................................................................38

3.4 Tarjeta de control para los servomotores ........................................................................... 39

3.4.1 Diagrama esquemático del circuito impreso para la tarjeta de control .........................39

Capítulo 4 ............................................................................................................................... 43

Diseño del software ................................................................................................................ 43

4.1 Descripción del software .................................................................................................... 43

4.2 Inicialización del Kinect ..................................................................................................... 46

4.3 Software para adquisición de datos .................................................................................... 50

4.3.1 Imagen de profundidad ................................................................................................51

4.3.2 Imagen en el espacio RGB .............................................................................................54

4.3.3 Imagen de puntos infrarrojos........................................................................................56

4.3.4 Proceso de calibración ..................................................................................................56

4.3.5 Selección de las articulaciones a utilizar ........................................................................60

4.3.6 Cálculo de movimientos del brazo del usuario ..............................................................61

4.3.7 Detección de gesto de finalización ................................................................................73

4.3.8 Detección de dedos para apertura y cierre de la pinza ..................................................75

4.3.9 Interfaz gráfica de usuario ............................................................................................82

4.4 Programación del microcontrolador PIC18F4550 ................................................................ 83

Capítulo 5 Pruebas y resultados .............................................................................................. 90

5.1 Estructura del brazo robótico ............................................................................................. 90

5.1.1 Cálculo del torque para los motores .............................................................................92

5.2 Resultados de la detección de dedos .................................................................................. 97

5.3 Resultados de movimiento del robot .................................................................................. 98

5.4 Pruebas del brazo robótico ................................................................................................. 99

Conclusiones ........................................................................................................................ 103

Observaciones ........................................................................................................................104

Limitaciones ............................................................................................................................104

Mejoras del proyecto y trabajo a futuro ..................................................................................104

Bibliografía ........................................................................................................................... 106

iii

Anexo 1 ................................................................................................................................ 108

1.1 Análisis de costos ..............................................................................................................108

Anexo 2 ................................................................................................................................ 112

2.1 Características del PIC18F4550 ..........................................................................................112

2.2 Terminales PIC18F4550 .....................................................................................................113

2.3 Registros transmisión UART ...............................................................................................114

2.4 Registros Timer2 ...............................................................................................................116

Anexo 3 ................................................................................................................................ 118

3.1 Gráficas de descarga de la batería de ácido-plomo ............................................................118

3.2 Plantilla del archivo xml para OpenNI ................................................................................118

Anexo 4 ................................................................................................................................ 119

4.1 Plantilla del archivo xml para programación del sensor .....................................................119

4.2 Código para obtener imagen de profundidad ....................................................................120

4.3 Código para obtener imagen RGB ......................................................................................121

4.4 Código para obtener imagen infrarroja ..............................................................................121

4.5 Código para calibración de usuario ....................................................................................122

4.6 Cálculo de ángulo entre dos joints .....................................................................................123

4.7 Cálculo del ángulo de rotación ...........................................................................................124

4.8 Código detección de dedos ................................................................................................125

4.9 Código de la interrupción UART del PIC18F4550 ................................................................126

4.10 Código de la interrupción Timer2 del PIC18F4550 ............................................................127

Anexo 5 Imágenes ................................................................................................................ 128

5.1 Imagen de habitación no apta para funcionamiento del sensor .........................................128

5.2 Imágenes de los usuarios controlando el brazo robótico ...................................................128

5.2.1 Usuario número 2 5.2.2 Usuario número 3................................................................ 128

5.2.3 Usuario número 4 5.2.4 Usuario número 5 ............................................................... 128

Anexo 6 Diagrama de clases de la aplicación ............................................................................. 2

iv

ÍNDICE DE FIGURAS Figura 1.1 Robot ABB moviendo piezas de madera, controlado por Kinect [1]. ................................................ 4

Figura 1. 2 Prototipo de perro robot guiando a persona invidente [1]. .............................................................. 6

Figura 2.1 Diagrama a bloque de un sistema de procesamiento digital. ........................................................... 7

Figura 2.2 Diagrama a bloques de un sistema en tiempo real. .......................................................................... 9

Figura 2. 3 (a) Señal original [3]...................................................................................................................... 12

Figura 2. 4 Multiprogramación......................................................................................................................... 15

Figura 3. 1 Diagrama de casos de uso para el sistema. .................................................................................... 17

Figura 3.2 Principales componentes del sensor Kinect [5]. ............................................................................... 18

Figura 3. 3 Ángulo de movimiento para la base [6].......................................................................................... 20

Figura 3. 4 Línea de vista vertical [6]. ............................................................................................................... 20

Figura 3. 5 Línea de vista horizontal [6]........................................................................................................... 20

Figura 3.6 Triangulación en visión estéreo [8]. ................................................................................................ 21

Figura 3.7 Imagen que muestra la proyección de puntos sobre una superficie [9]. ........................................ 22

Figura 3.8 Cada punto es distinguible de otro dentro del patrón proyectado [9]. .......................................... 22

Figura 3.9 Imagen de profundidad capturada por la cámara [9]. ................................................................... 23

Figura 3.10 Δx es proporcional para el punto proyectado [9]. ....................................................................... 23

Figura 3. 11 Proceso de segmentación y obtención de articulaciones a partir de imágenes de profundidad

[11]. .................................................................................................................................................................. 25

Figura 3. 12 Articulaciones del cuerpo del usuario, de las cuales se puede realizar un seguimiento (x,y,z). .... 26

Figura 3.13 Imagen que muestra cuando el sensor se encuentra sobre una superficie móvil, algunos objetos

son detectados como usuarios siendo marcados con determinado color [12]. ............................................... 28

Figura 3.15 Imagen 1 ........................................................................................................................................ 29

Figura 3.16 Imagen 3 ........................................................................................................................................ 29

Figura 3.14 Imagen 2 ........................................................................................................................................ 29

Figura 3.17 Representación abstracta del concepto de OpenNI dividido en tres capas [14]. .......................... 31

Figura 3.18 Diagrama de comunicación entre los dispositivos de procesamiento. .......................................... 35

Figura 3. 19 Módulo serial bluetooth. .............................................................................................................. 35

Figura 3.20 Pines para transmisión y recepción de datos a través del modulo serial bluetooth [15]. ............. 36

Figura 3.21 Elementos que conforman un servomotor [16]. ............................................................................ 37

Figura 3.22 Cables de un servomotor [16]. ....................................................................................................... 37

Figura 3.23 Ciclos de trabajo para posicionar un servomotor estándar [16]. .................................................. 38

Figura 3.24 Diagrama de simulación para movimiento de los servomotores. ................................................. 39

Figura 3.25 Diagrama esquemático de tarjeta controladora para los servomotores. ..................................... 40

Figura 3. 27 Capa superior del circuito impreso. .............................................................................................. 40

Figura 3. 26 Capa inferior del circuito impreso. ................................................................................................ 40

Figura 3.28 Tarjeta de control para los servomotores. .................................................................................... 41

Figura 3.29 Batería de acido-plomo. ................................................................................................................ 41

Figura 4.1 Diagrama de flujo del software del sistema. ................................................................................... 44

Figura 4.2 Diagrama a bloques de las etapas del sistema. ............................................................................. 45

Figura 4.3 Diagrama de clases del software diseñado para la computadora. ................................................ 50

Figura 4.4 Mapa de bits a utilizar para copiar imágenes entregadas por el sensor. ........................................ 51

Figura 4.5 Algoritmo para obtener una imagen de profundidad. .................................................................... 52

v

Figura 4. 6 Imagen de profundidad y color del usuario a una distancia de 2metros utilizando el nodo

“Generador de profundidad”. ........................................................................................................................... 53

Figura 4.7 Imagen de profundidad y color cuando el usuario extiende la mano a una distancia menor de 15

cm. .................................................................................................................................................................... 53

Figura 4. 8 Algoritmo para obtener imagen a color. ........................................................................................ 55

Figura 4. 9 Imagen RGB obtenida con el nodo "generador de imagen". ......................................................... 55

Figura 4. 10 Imagen del patrón infrarrojo emitido por el sensor de profundidad, obtenida a través del nodo

“Generador Infrarrojo”. .................................................................................................................................... 56

Figura 4.11 Algoritmo para calibración de usuario. ......................................................................................... 58

Figura 4. 12 Pose "Psi" para llevar a cabo el proceso de calibración [14]. ....................................................... 58

Figura 4.13 Alineación de las articulaciones adquiridas con imagen RGB. ...................................................... 60

Figura 4. 14 Representación de un vector formado por un punto o articulación del usuario dentro del plano

del sensor. ......................................................................................................................................................... 62

Figura 4.15 Ángulo formado por dos vectores proyectados en las articulaciones del usuario. ........................ 64

Figura 4. 16 Ángulos a calcular para el movimiento del brazo. ........................................................................ 65

Figura 4. 17 Ángulo formado por dos vectores en un espacio tridimensional. ................................................. 66

Figura 4. 18 Traslación de un vector hacia el origen. ...................................................................................... 67

Figura 4. 19 Cálculo de ángulo entre dos vectores. .......................................................................................... 67

Figura 4.20 Ángulos que forma la rotación de un cuerpo en un sistema de coordenadas con respecto a otro

[17]. .................................................................................................................................................................. 69

Figura 4. 21 Sistema de rotación de un cuerpo con referencia a un plano. ...................................................... 70

Figura 4. 22 Pose T que es el sistema de referencia para la rotación de una articulación [13]. ...................... 71

Figura 4. 23 Sistema de referencia para la rotación del hombro derecho........................................................ 71

Figura 4. 24 Algoritmos para obtener el ángulo de rotación de una articulación. ........................................... 72

Figura 4. 25 Diagrama de flujo para la detección de gestos con OpenNI. ........................................................ 74

Figura 4. 26 Distancia de la cabeza al cuello, similar a la distancia de lo largo de la mano. ........................... 76

Figura 4. 27 Región de interés(amarillo) de la imagen de profundidad. .......................................................... 77

Figura 4. 28 Pixeles que serán tomados en cuenta para la forma de la imagen. ............................................. 78

Figura 4. 29 Figura 49 Forma convexa X, y forma no convexa Y [18]. ............................................................ 79

Figura 4. 30(a) Rectángulo que cubre el área................................................................................................... 80

Figura 4. 31 Interfaz gráfica de usuario de la aplicación. ................................................................................. 82

Figura 4.32 Diagrama de flujo de la programación del PIC18F4550. ............................................................... 85

Figura 4. 33 Diagrama de flujo de la interrupción generada por la recepción de datos a través del modulo

UART. ................................................................................................................................................................ 86

Figura 4. 34 Diagrama de flujo de la rutina de interrupción del temporizador 2(Timer2). .............................. 88

Figura 4.35 Ciclo de trabajo para movimiento de servomotores en 0 grados (amarillo) ,45 grados (azul) ,90

grados (morado) y 180 grados(verde). ............................................................................................................. 89 Figura 5. 1 Configuración de un brazo robótico antropomórfico o angular. .................................................... 90

Figura 5. 2 Soporte para el servomotor utilizado. ............................................................................................ 91

Figura 5. 3 Servomotor utilizado. ..................................................................................................................... 91

Figura 5. 4 Medidas de los tubos de aluminio utilizados. ................................................................................. 91

Figura 5.5 Medidas del eslabón para movimiento angular número 2. ............................................................. 92

Figura 5. 6 Medidas del eslabón para movimiento angular número 1. ............................................................ 93

Figura 5. 7 Diseño final del prototipo del brazo robótico. ................................................................................ 95

vi

Figura 5. 8 Medidas del prototipo final. ........................................................................................................... 95

Figura 5.9 Máxima apertura de la pinza. ......................................................................................................... 96

Figura 5. 10 Área de trabajo del brazo robótico. .............................................................................................. 96

Figura 5.11 Formas convexas detectadas. ....................................................................................................... 97

Figura 5. 12 Resultado de la detección de dedos. ............................................................................................ 97

Figura 5. 13 Resultado de la detección de dedos ............................................................................................. 97

Figura 5. 14 Posición con brazo estirado. ......................................................................................................... 98

Figura 5. 15 Posición con brazo flexionado. ..................................................................................................... 98

Figura 5. 16 Posición con brazo semi -flexionado. ............................................................................................ 99

Figura 5. 17 Modelo de pieza cilíndrica para pruebas del brazo robótico. ....................................................... 99

Figura 5.18 Distribución de las piezas sobre mesa de madera. ...................................................................... 100

Figura 5. 19 Gráfica del tiempo en completar la prueba. ............................................................................... 101

Figura A. 1 Habitación con condiciones no aptas para el funcionamiento del sensor. ................................... 128

Figura A. 2 Usuario 3 (1.62metros)................................................................................................................. 128

Figura A.3 Usuario 2 (1.51metros) ................................................................................................................. 128



ÍNDICE DE TABLAS Tabla 3. 1 Características del sensor. ............................................................................................................... 19

Tabla 3. 2 Datos de profundidad en espacio de color RGBA. ............................................................................ 24

Tabla 3. 3 Datos de profundidad en espacio de color YUV. .............................................................................. 24

Tabla 3. 4 Comparación de librerías de libre acceso. ....................................................................................... 30

Tabla 3. 5 Características técnicas de la batería acido-plomo. ........................................................................ 41

Tabla 4. 1Ventajas del software de Microsoft para Kinect y OpenNI ............................................................... 47

Tabla 4. 2 Desventajas del software de Microsoft para Kinect y OpenNI. ........................................................ 47

Tabla 4. 3 Puntos utilizados del usuario. .......................................................................................................... 60

Tabla 4. 4 Vectores utilizados para el cálculo de los ángulos. .......................................................................... 68

Tabla 4. 5 Prioridades del sistema en tiempo real. ........................................................................................... 84

Tabla 5. 1 Medidas y pesos del eslabón para movimiento angular número 2. ................................................ 92

Tabla 5. 2 Medidas y pesos del eslabón para movimiento angular número 1. ................................................ 93

Tabla 5. 3 Diseño final del prototipo del brazo robótico. ..................................... ¡Error! Marcador no definido.

Tabla 5. 4 Resultados de las pruebas realizadas con el brazo robótico. ......................................................... 101

Tabla anexo 1 Costo total del proyecto. ........................................................................................................ 111

vii

Prólogo

Existen procesos industriales o laboratorios de investigación química donde al realizarse determinados trabajos, el personal o científico, transporta y mueve sustancias u objetos peligrosos con las manos exponiéndolo de forma peligrosa al entrar en contacto directo.

El objetivo de esta tesis consiste en construir el prototipo de un brazo robótico que realice movimientos similares a los realizados por el brazo de un usuario, utilizando los datos capturados por el sensor Microsoft Kinect.

Este prototipo pretende asistir en el trabajo en donde comúnmente el usuario pone en riesgo las manos al entrar en contacto con el objeto o sustancia. También puede contribuir en asistir operaciones quirúrgicas o procesos industriales de control. El proyecto es desarrollado usando un dispositivo de última tecnología como lo es Kinect.

1

Introducción

Los brazos robóticos (también llamados brazos manipuladores) son comúnmente utilizados dentro de la industria en diferentes actividades como la transportación de piezas, ensamblado o diseño de componentes electrónicos. En el campo de la medicina también se ha trabajado con brazos robóticos, facilitando el trabajo a los médicos en operaciones quirúrgicas. Los brazos manipuladores pueden ser controlados mediante interfaces de usuario (palancas, botones, interfaces gráficas, etc.) o funcionar de forma autónoma. En el caso de los brazos autónomos se requiere conocer las coordenadas dentro de un plano, del objeto que se quiera transportar para implementar algún algoritmo que realice dicha labor. Para los robots que se controlan mediante interfaces de usuario se requiere un tiempo de respuesta favorable y precisión del robot para realizar una labor como la transportación de piezas.

Definición del problema

Existen procesos industriales o laboratorios de investigación donde se requiere utilizar brazos manipuladores que sean controlados por el usuario mediante interfaces que puedan ser utilizadas por cualquier persona, con un tiempo de respuesta favorable en el movimiento del brazo y buena precisión, esto debido a que existe la necesidad de sustituir el trabajo de transportación de objetos que comúnmente es realizada por el personal que utiliza las manos para realizar la mencionada tarea. Debido a lo anterior surge la necesidad de innovar las interfaces de usuario que comúnmente se utilizan para brazos manipuladores y se requiere facilitar la forma en la que se controlan dichos robots mejorando el tiempo de respuesta del robot.

2

Justificación

La presente tesis propone la construcción y programación del prototipo de un brazo robótico que sea controlado mediante el movimiento del brazo del usuario a través de una interfaz de usuario basada en el dispositivo Microsoft Kinect, el brazo robótico debe imitar en tiempo real el movimiento del brazo del usuario, mejorando el tiempo de respuesta, precisión y facilidad para controlar los brazos manipuladores. El brazo robótico es construido para ayudar en tareas que sustituyan el trabajo que comúnmente es realizado por el contacto directo de la mano del usuario y el objeto, en una determinada labor, evitando así accidentes que son causados por dicha actividad. El brazo robótico también ayudará a realizar trabajos que tal vez no sean peligrosos pero dependen de una herramienta que realice movimientos similares a los ejecutados por el brazo del cuerpo humano, siendo el brazo del usuario el control para colocar el brazo robótico al punto deseado, además se pretende innovar el control de brazos manipuladores utilizando un dispositivo de última tecnología como Kinect, remplazando dispositivos que requieren mas recursos o son difíciles de trabajar en forma conjunta.

3

Objetivos del proyecto

General

Construir el prototipo de un brazo robótico integrado por tres grados de libertad y una pinza de sujeción, programado para moverse de acuerdo a los movimientos hechos por el brazo del usuario de forma simultanea, dichos movimientos del usuario serán adquiridos a través del sensor Microsoft Kinect .

Específicos

El diseño, construcción y programación del brazo robótico en conjunto, es considerado un sistema en tiempo real, por lo que el movimiento del brazo debe realizarse en un tiempo que sea visualmente paralelo al tiempo en el que se mueve el brazo perteneciente al usuario. Los objetivos específicos establecidos para realizar el trabajo se definen a continuación:

• Adquisición de datos de profundidad y de usuario por medio del sensor Kinect, utilizados para procesar y capturar cada movimiento que realiza el usuario con el brazo derecho.

• Desarrollar una interfaz gráfica de usuario que permita visualizar la ejecución del brazo del usuario, desplegando los grados desplazados por cada articulación.

• Construcción del prototipo del brazo robótico utilizando servomotores para el movimiento, permitiendo tres grados de libertad.

• Establecimiento de comunicación del sistema a través del protocolo RS232 utilizado para el envío de datos desde la computadora hacía un microcontrolador.

• Programación del microcontrolador PIC18F4550 dedicado a recibir los datos de la computadora, datos que contienen los grados a desplazarse de cada motor y poder así generar el movimiento de cada uno de los motores, de forma simultanea, bajo el concepto de sistema multitarea.

4

Capítulo 1 Estado del arte Desde que fueron liberadas las diferentes librerías de programación para el sensor Kinect en una computadora personal, el sensor ha sido utilizado en robots de uso medico e industrial [1]. Los proyectos se han desarrollado utilizando desde los más simples mecanismos de robótica hasta robots con mayor grado de complejidad en cuanto a mecánica y programación.

1.1 Control de un Robot ABB con Kinect Estudiantes de Ingeniería Robótica que en el verano de 2011, en Suecia, usaron el software de seguimiento de esqueleto del Kinect, para controlar un brazo robótico ABB [1]. En la figura 1.1 se puede ver como manejan el robot con el Kinect, en donde apilan una serie de bloques de madera para después escribir utilizando el robot.

Figura 1.1 Robot ABB moviendo piezas de madera, controlado por Kinect [1].

5

1.2 Brazo robótico controlado mediante gestos a través de Kinect

En la Universidad Tsukuba (Ibaraki, Kanto, Japón), fue presentado el “Sistema de Brazo Robot Controlado por Gestos”, que tiene la capacidad de comprender los movimientos tanto del brazo en general, como de la mano y sus dedos. El sistema necesita de dos cámaras, encargadas de transmitir en tiempo real información sobre el movimiento y la forma de la mano, para después ser duplicados en la réplica robótica. Un detalle el cual ya parece haber sido resuelto por sus desarrolladores es que no todas las manos humanas son iguales, por esta razón cargaron al sistema con una gran base de datos repleta de manos, de forma que sólo es necesario encontrar una mano similar en forma y tamaño para que el brazo robot pueda operar sin inconvenientes [1].

1.3 Uso médico del Kinect

Estudiantes de la Universidad de Washinton (EE.UU.) han querido ir más allá. Han adaptado la tecnología para realizar cirugías robóticas asistidas en la vida real. Este método implica el uso de Kinect para ayudar a los cirujanos a utilizar las herramientas cuando realicen una cirugía. En la actualidad, los cirujanos suelen utilizar la robótica para intervenciones quirúrgicas mínimamente invasivas. El principal problema, con los métodos actuales, es que los cirujanos no tienen ninguna forma de palpar lo que están haciendo. Si se mueve un instrumento quirúrgico en algo sólido, el instrumento se detendrá pero el mando de control sigue en movimiento. El equipo de ingeniería eléctrica de la universidad ha resuelto este problema gracias al código abierto de Kinect para asignar y reaccionar a los entornos en tres dimensiones y enviar la información sobre el entorno al usuario. Al usar Kinect se establecen "espacios electrónicos" que restringen el movimiento de la herramienta quirúrgica, es decir, si la herramienta toca un hueso se deja de mover. En cambio, si el instrumento se mueve a lo largo de un hueso, el joystick sigue el mismo camino. Incluso es posible definir las zonas de acceso restringidas para proteger los órganos vitales. El equipo espera que esta cirugía robótica sea fiable y práctica a largo plazo, permitiendo así a los médicos llevar a cabo fácilmente en las principales ciudades cirugías en pacientes

6

en pueblos pequeños y aislados. Chizeck asegura que esta idea se puede extrapolar en catástrofes o guerras. En un hospital de Canadá han mostrado un nuevo ejemplo del uso de Kinect para mantener la sala de operaciones como un entorno esterilizado. La idea es que se realicen determinadas tareas sin salir del quirófano, como puede ser la búsqueda de información sobre el estado de un paciente en un ordenador. La realización de un escáner por rayos X, ya que podría manejar de forma remota el ordenador que controla el aparato. Además de eso, se evitaría tener que lavarse y desinfectarse, como sucede ahora cada vez que utiliza esa máquina [1].

1.4 Perro robot guía para ciegos

Un inteligente diseño de perro-robot le saca bastante provecho a la tecnología del Kinect, ya que su capacidad de reconocer el espacio y las distancias le convierte en un preciso guía de ciegos. El uso es bastante sencillo, el usuario toma el mango del perro y lo presiona, entonces el robot avanza mientras da indicaciones de voz y describe el entorno para situar mejor y ayudar a su “dueño”. También sube y baja escaleras si es necesario, por lo que es bastante versátil. Está desarrollado por la Universidad de Electro-comunicaciones (Tokio) [1]. El plan es seguir mejorando el perro-robot, incluir comandos de voz y agregarle GPS para mejorar la navegación.

Figura 1. 2 Prototipo de perro robot guiando a persona invidente [1].

7

Capítulo 2 Marco teórico 2.1 Sistemas en tiempo real

Es un sistema electrónico de procesamiento que interactúa con el medio, controla procesos, y entrega resultados dentro de tiempos establecidos de manera confiable y segura.

El principal objetivo de un sistema en tiempo real es controlar o realizar varios procesos de forma simultánea, lo que se conoce como multitarea. Estos procesos o tareas duran un tiempo determinado, dependiendo la aplicación o la determinación del usuario, y son atendidos por un mismo procesador o CPU (unidad central de procesamiento). Al tiempo que dedica el procesador a cada tarea se le conoce como prioridad, esta se define dependiendo la aplicación o el uso que tenga [2].

La figura 2.1 muestra la representación de forma general de un sistema de procesamiento digital, en el cual intervienen mínimo dos variables y se obtiene una respuesta en un tiempo acorde a la necesidad del usuario.

Figura 2.1 Diagrama a bloque de un sistema de procesamiento digital.

8

En el primer bloque se representa todas las variables que interactúan con el sistema, en el caso de un sistema electrónico, estas variables pueden ser sensores debido a que estos interactúan con la naturaleza o el medio, y además dependen del tiempo. El segundo bloque representa el proceso que se encarga de controlar todas las variables del sistema y realizar determinados procesos. El último bloque representa la respuesta del sistema, la cual debe ser entregada por el sistema en un tiempo que no afecte algún proceso o sea catastrófico para el sistema.

En un sistema en tiempo real intervienen los siguientes factores para el tiempo de respuesta:

• Físicos -Capacitancias, inductancias, resistencias de los circuitos, etc -Velocidad de propagación de los medios de comunicación digital -Velocidad de procesamiento -Etapas del sistema

• Software -Algoritmo -Nivel de lenguaje(c++,asm,etc.) -Compilador

Para los tipos de comunicación digital en un sistema en tiempo real, los más comunes son los siguientes:

• Serie -USB -RS232 -RS485 -Ethernet

• Paralelo -ICE -PCI -DB25

• Inalámbricos -Bluetooth -Wifi

9

Para entregar resultados al usuario, los sistemas en tiempo real realizan diferentes procesos que determinan el tiempo de respuesta. En la figura 2.2 se muestra el diagrama a bloques de los procesos que realiza un sistema en tiempo real para entregar una respuesta o resultado, cada bloque representa un proceso que tiene determinada duración en el sistema. El tiempo total de respuesta del sistema esta dado por la suma de los tiempos correspondientes a cada etapa, como se determina en la ecuación 2.1.

Figura 2.2 Diagrama a bloques de un sistema en tiempo real.

ΔtT = ∑ Δt�� (Ecuación 2.1)

En donde:

ΔtT = tiempo total de respuesta del sistema

Δ� = tiempo de etapa de procesamiento número �

2.1.1 Sensores Una parte fundamental en todo sistema de adquisición de datos es el elemento encargado de percibir la magnitud a medir. Los sensores son dispositivos capaces de convertir una magnitud física como puede ser temperatura, presión, etc., en una diferencia de potencial o una variación de intensidad de corriente, es decir, realizan una conversión de energías y suministran información sobre el estado y tamaño de la magnitud. Los sensores informan de su entorno y además esa información es cuantificable, es decir, medible por algún instrumento.

10

La posibilidad de que un sensor perciba una determinada magnitud depende de:

• Que exista una propiedad en algún material que cambie en función de esa magnitud Preferiblemente esa función debe ser lineal para el rango en el que estemos interesados, por ejemplo la relación que se da en los conductores entre su resistencia al paso de la corriente eléctrica y la temperatura, es decir a mayor resistencia, mayor temperatura.

• En otras ocasiones existe una relación entre una magnitud y un fenómeno físico Si la relación es predecible y estable, el fenómeno se puede usar como base para la determinación de la magnitud. En muchas ocasiones la dificultad está en conseguir que la propiedad o fenómeno esté en función únicamente de la magnitud que queremos evaluar. Suele ocurrir que la medida es función de varios factores, de tal manera que cualquier variación en alguno de ellos altera el resultado final.

En la actualidad, la mayor parte de los sensores generan una salida en voltaje o corriente, o bien modifican una propiedad que puede ser evaluada de forma eléctrica. De esta manera, y con el debido acondicionamiento, la señal de salida puede ser tratada por un equipo digital de adquisición de datos. Las señales del mundo real son, en general, analógicas y varían de manera continua en el tiempo, para que una computadora sea capaz de procesarla se debe convertir a datos digitales. Cada uno de estos sensores tiene unas características propias y genera una tensión o intensidad determinada, por lo que estas señales tienen que ser adaptadas para ser tratadas en una tarjeta de adquisición de datos. En el tratamiento de imagen y sonido, los sensores más utilizados son:

• Micrófono : Capta la información sonora que se propaga por el aire y la convierte a una señal eléctrica.

• Cámara : Capta la información visual y convierte la información en datos digitales.

11

2.1.2 Acondicionamiento de la señal El objetivo del acondicionador de señal es generar a partir de lo obtenido por los sensores, una señal que sea aceptable por las tarjetas de adquisición de datos. Las funciones principales que va a tener que realizar el acondicionador de señal son las siguientes:

• Amplificación: La señal proporcionada por los sensores suele ser de un valor muy pequeño, por lo que debe ser amplificada con el fin de que pueda ser detectada correctamente por la tarjeta de adquisición de datos. La amplificación debe ser tal que las variaciones de la señal recorran todo el margen de la tarjeta de adquisición de datos. La amplificación de las señales, en su origen, reduce el ruido que les puede afectar en su transmisión hasta la computadora.

• Filtrado : Con el filtrado se pretende eliminar ruidos de frecuencia que pueden hacer perder exactitud al sistema de adquisición de datos. Lo ideal es transportar la señal del sensor lo más limpia posible a la tarjeta de adquisición.

• Excitación : Hay algunos sensores que necesitan de una excitación en corriente o voltaje, para producir la variación proporcional a la magnitud a medir.

• Linealización : No todos los sensores tienen una variación lineal con respecto a las variaciones de la magnitud que se miden; a veces es necesario convertir la respuesta del sensor en lineal.

2.1.3 Conversión analógica a digital Un conversor analógico-digital, es un dispositivo electrónico capaz de convertir una entrada analógica de voltaje en un valor binario, Se utiliza en equipos electrónicos como computadoras, grabadores de sonido y de vídeo. Como características más relevantes de un convertidor analógico a digital están:

• Número de canales analógicos : Nos indica la cantidad de magnitudes

distintas que podemos adquirir con el mismo convertidor analógico-digital. Generalmente disponen de un único ADC y los diferentes canales se generan por medio de un multiplexor analógico.

• Velocidad de muestreo : Cuanto mayor sea la velocidad de muestreo mejor representación obtendremos de la señal analógica, en cualquier caso la velocidad de muestreo debe ser siempre mayor que el doble de la frecuencia de la señal que queremos muestrear, según el “Teorema de Nyquist”. El Teorema de Nyquist indica que la frecuencia de muestreo mínima que tenemos que utilizar debe ser mayor que (2 · fmax), siendo

12

fmax es la frecuencia máxima de la señal. Si utilizamos esa frecuencia de muestreo, podremos reproducir posteriormente la señal a partir de las muestras tomadas.

Consideremos una señal con una frecuencia de 100 Hz. El Teorema de Nyquist indica que debemos utilizar una frecuencia de muestreo mayor que 200 Hz. Si utilizáramos una frecuencia más alta que la que nos dice Nyquist obtendríamos una representación más exacta de la señal de entrada. Sin embargo, cuanta más alta es la frecuencia de muestreo más alto es el número de muestras por segundo que se deberán procesar, por lo que los procesadores de señal deberán ser más potentes o realizar menos procesamiento en cada muestra.

(Ecuación 2.2)

Si utilizamos una frecuencia inferior aparece un fenómeno llamado” Aliasing”. Esto significa que cuando intentamos reconstruir la señal aparece una señal de frecuencia más baja. Este fenómeno se presenta por el hecho de que las muestras se pueden unir para crear una forma de onda de frecuencia más baja que es totalmente diferente de la onda original. La velocidad de muestreo depende de los canales que queramos tener activos. Las especificaciones de los convertidores analógico-digital suelen indicar la velocidad de muestreo del ADC, a medida que aumenta el número de canales que este debe atender disminuirá el número de muestras por segundo que podemos obtener en cada canal.

• Resolución: Viene dada por el número de bits del ADC que se utilizan para representar cada muestra, a mayor número de bits del ADC la tarjeta será capaz de detectar variaciones menores en la señal. El número de distintos niveles en que se divide la señal a convertir viene dada por 2n, siendo n la

(a) (b)

Figura 2. 3 (a) Señal original [3].

(b) Muestreo de señal utilizando teorema de Nyquist [3].

13

longitud de palabra del conversor. Por ejemplo un conversor de 8 bits tendrá 256 niveles distintos, suponiendo un rango de entrada de 10V proporcionaría una resolución de:

Resolución =�� (.�� )

�� (Ecuación 2.3)

• Rango de entrada: Indica los márgenes entre los que debe estar la señal

de entrada para que pueda ser convertida. Las tarjetas de adquisición de datos suelen dar varias posibilidades que se pueden seleccionar por hardware o por software.

Estas 4 características vienen a determinar la capacidad y la precisión de la tarjeta de adquisición:

� A mayor número de canales mayor capacidad. � A mayor velocidad de muestreo mayor capacidad � A mayor resolución mayor precisión � A menor rango de entrada mayor precisión, ya que se con los mismos bits

de resolución se tendrá que representar un menor rango.

El tiempo de conversión es el tiempo que tarda un ADC en muestrear, sintetizar y entregar en el bus de datos el resultado de la conversión. El tempo de conversión delimita la frecuencia máxima de muestreo:

Tmuestreo ≥ Tconversión (Ecuación 2.4)

Existen diversos tipos de ADC disponibles actualmente, la mayoría de los cuales también contienen el circuito para digitalizar señales analógicas. Los cuatro tipos más populares son:

• ADC de aproximación sucesiva: Este tipo de ADC compara la forma de onda de la entrada de información con la salida de un DAC dentro del dispositivo. Repetidamente dividen el voltaje de entrada por la mitad produciendo una salida de n bits en n ciclos de su reloj. Los ADC de aproximación sucesiva son generalmente precisos y rápidos, y relativamente baratos de producir. Sin embargo, pueden ser lentos al responder a cambios repentinos en la señal de entrada y son sensibles a voltajes picos en la propia señal de entrada.

Tconversión= (n+1) (Tck) (Ecuación 2.5)

Tck= periodo de reloj utilizado en el ADC

14

• ADC de rampa: Los ADC de rampa utilizan un capacitor conectado a un voltaje de referencia. Este se carga durante un tiempo determinado a través del voltaje de entrada y después se descarga a través del voltaje de referencia. El tiempo para descargarse se alacena utilizando un contador digital, y es proporcional al voltaje de entrada. Esto produce resultados muy precisos, pero es muy lento y generalmente costoso.

Tconversión= (2n) (Tck) (Ecuación 2.6) Tck= periodo de reloj utilizado en el ADC

• ADC Flash : Este tipo de ADC compara el voltaje de entrada con un

conjunto de voltajes de referencia creados por una escala de resistencias de igual valor. Se utilizan comparadores entre cada nivel de voltaje y la salida digital decodificada. Este proceso es muy rápido pero requiere 2n resistencias exactas para un ADC de n bits. Esto hace el ADC flash caro, y comercialmente no práctico para utilizar una exactitud de 8 bits. El tiempo de respuesta esta dado por el hardware (normalmente picosegundos a nanosegundos).

2.1.4 Procesamiento digital En esta etapa se implementa algún tipo de proceso o algoritmo computacional que modifique la señal recibida. Una de las ventajas de utilizar sistemas computacionales es que la mayor parte del procesamiento de la señal reside en la programación, permitiendo realizar modificaciones de forma más rápida y económica sobre el algoritmo, ya que si se requiere realizar cambios, estos se ejecutan dentro del programa o algoritmo de procesamiento y no en el hardware, ahorrando recursos y tiempo que podrían ser consumidos en la modificación de las partes tangibles del sistema.

Ventajas de utilizar sistemas de procesamiento digital:

-Fáciles y confiables para el procesamiento digital

-Mayor inmunidad al ruido

-Solo se requiere modificar el software y no el hardware

15

Multiprogramación

Es la ejecución de dos o más procesos de manera aparentemente simultánea utilizando un CPU y sus periféricos. En la figura 2.4 se muestra un diagrama en donde se muestra como los datos de entrada deben ser procesados y entregados de forma simultánea utilizando un solo CPU.

Sistema operativo

Se encarga de administrar los recursos de cada proceso, tiempo de ejecución de cada proceso, espacio de memoria, etc. También es la capa que permite al usuario ejecutar aplicaciones sin necesidad de conocer y programar la capa física(hardware), un sistema operativo en tiempo real es comúnmente utilizado en dispositivos de procesamiento como microcontroladores, DSP, FPGA, normalmente se denota con las siglas RTOS(sistema operativo en tiempo real).

Figura 2. 4 Multiprogramación

16

2.1.5 Clasificación de los sistemas en tiempo real

Los sistemas en tiempo real se pueden dividir según los errores que se puedan presentar:

� Críticos: si no se cumplen con los tiempos establecidos se destruye el sistema y/o causa una catástrofe al medio o al usuario.

� No críticos: es aquel en el que se puede tolerar que en algunas ocasiones los resultados no se obtengan en los tiempos establecidos, ya que no se degrada el servicio o el proceso que esta controlando el sistema, en este tipo se especifica una tasa de probabilidad que permite tolerar las fallas en los tiempos de respuesta.

� Inflexibles: no se cumplen con tiempos de respuesta, no ocurre daño al sistema, pero la aplicación queda inservible.

El sistema desarrollado en la presente tesis es clasificado dentro de la categoría de sistemas en tiempo real no críticos, debido a que el sistema puede tolerar que los resultados no se obtengan en los tiempos establecidos, en este caso las imágenes que entrega el sensor son enviadas a la computadora 30 veces en un segundo, por lo cual si alguna imagen no es procesada por la computadora, no afecta sobre el sistema debido a que el sensor genera las imágenes con un tiempo superior a los movimientos del usuario, los cuales son capturados a través del Kinect.

17

Capítulo 3 Descripción del Hardware El proyecto tiene como base al sensor Microsof Kinect, el cual envía datos que se actualizan constantemente, los cuales determinan los movimientos del brazo robótico cuya estructura cuenta con tres grados de libertad. Cada grado está limitado por el movimiento máximo de un servomotor (0-180 grados) y al ángulo de los movimientos del brazo del usuario, mismos que se encuentran normalmente dentro del mismo rango.

El diagrama de casos de uso que se muestra en la figura 3.1 representa como debe el usuario interactuar con el sistema.

Figura 3. 1 Diagrama de casos de uso para el sistema.

18

La figura 3.1 muestra el diagrama de casos de uso para el sistema del brazo robótico, el usuario debe interactuar con el sistema en todo momento, realizando alguna de las siguientes tareas:

• Pose de calibración: es necesaria para poder iniciar el movimiento del brazo y poder controlarlo.

• Movimiento del brazo derecho: es el control del brazo robótico, el cual realiza los movimientos en tiempo real que sean realizados por el usuario.

• Apertura o cierre de la mano izquierda: movimiento establecido para tomar (cerrar la mano), o dejar objetos (abrir la mano) utilizando la pinza del brazo robótico.

• Gesto de finalización: gesto predeterminado para finalizar el movimiento del brazo.

3.1 Sensor de movimiento y obtención de datos Kinect es un dispositivo electrónico que se constituye de dos sensores: una cámara infrarroja utilizada para la detección de profundidad, y una cámara RGB para imágenes a color [4]. La resolución para las cámaras es de 640*480 pixeles con 11bits de resolución y 640*480 pixeles con 32 bits de resolución para la cámara de profundidad y de color respectivamente. La velocidad de envío es de 30 tramas por segundo para ambas cámaras. La cámara de color RGB soporta alta resolución 1280*1024 pero la velocidad de envío disminuye a 15 tramas por segundo. En adición, el sensor Kinect contiene un arreglo de cuatro micrófonos, además de una base motorizada que puede rotar el sensor hacia arriba o hacía abajo. En la figura 3.2 se muestra de manera general los componentes que conforman al Kinect, indicando el nombre de cada uno de ellos.

1.-Sensor de profundidad

2.-Cámara RGB

3.-Arreglo de micrófonos

4.-Base

Figura 3.2 Principales componentes del sensor Kinect [5].

19

1. Sensor de profundidad que consiste en un proyector láser infrarrojo y un sensor monocromático, ambos trabajan en conjunto para obtener imágenes de profundidad en un espacio 3D bajo condiciones donde no exista luz ambiental.

2. Cámara RGB con 32 bits de resolución de 640*480 pixeles a 30 tramas por segundo. Esta cámara obtiene imágenes a color en dos dimensiones.

3. Arreglo de cuatro micrófonos localizados en la parte baja del sensor, de forma horizontal. Estos micrófonos son utilizados para el reconocimiento de voz, ya que cuentan con herramientas de gran ayuda para el tratamiento de audio como lo son: localización de la fuente acústica, supresión de ambiente de ruido, y cancelación del eco. La trama de datos para audio en los cuatro micrófonos es de 16 bits a 16khz.

4. Base motorizada que sirve para establecer la línea de vista del sensor, el rango de movimiento de la base motorizada es de ±27 grados de forma vertical.

El sensor entrega los siguientes datos utilizando los componentes:

• Sensor de profundidad: mapas de profundidad que permiten obtener la distancia en milímetros de objetos o personas con referencia al sensor. También permite detectar a usuarios (máximo 6), dentro del rango del alcance del sensor, y obtener las coordenadas dentro del plano 3D comprendido por el área que cubre del sensor, de las coordenadas (x,y,z) de diferentes puntos o articulaciones del cuerpo humano.

• Cámara RGB: permite capturar imágenes a color en un espacio 2D con resolución de 640*480 pixeles.

• Arreglo de micrófonos: capturan audio que se encuentre dentro del entorno del sensor, permitiendo anular ecos u otro tipo de ruido que afecte el reconocimiento de voz.

La tabla 3.1 muestra las características para el correcto funcionamiento del sensor.

Tabla 3. 1 Características del sensor.

Línea de vista horizontal 57◦ Línea de vista vertical 43◦ Rango de movimiento de la base motorizada

±27◦

Rango del sensor de profundidad 1.2m a 3.5m

20

Las características mencionadas en la tabla 3.1 se refieren a:

• Línea de vista horizontal: ángulo máximo de proyección que forman los vértices de la superficie que abarca el sensor de forma horizontal.

• Línea de vista vertical: ángulo máximo de proyección que forman los vértices de la superficie que abarca el sensor de forma vertical.

• Rango de la base motorizada: es el rango que puede rotar el motor de la base de forma vertical.

• Rango del sensor de profundidad : la distancia que tiene que mantener el usuario con respecto al sensor, para que el sensor pueda entregar datos correctos.

En la figura 3.5 se muestra la línea de vista del sensor de forma horizontal y vertical en la figura 3.4, también se observa la distancia mínima y máxima que cubre el sensor, estableciendo así el área que deberá ser ocupada por el usuario.

Figura 3. 4 Línea de vista vertical [6].

Figura 3. 3 Ángulo de movimiento para la base [6].

Figura 3. 5 Línea de vista horizontal [6].

21

3.1.1 Sensor de profundidad Basa su funcionamiento en una técnica llamada “luz estructurada”, la cual consiste en la proyección de un patrón de puntos infrarrojos sobre una superficie, al hacer corresponder la imagen captada con el patrón original, es posible triangular la posición de cada píxel y determinar su profundidad con respecto al plano perpendicular a la cámara [7] .

� Emisión del patrón de puntos infrarrojos

Cuando una superficie es iluminada por una onda de luz, cada punto actúa como una fuente de onda esférica. La luz en cualquier punto en el campo de luz dispersa, se compone de ondas que han sido emitidas desde cada punto de la superficie iluminada. Si la superficie es suficiente rugosa para crear longitud de trayectoria superior a la longitud de onda del punto, se da lugar a cambios de fase mayor que la amplitud, y por lo tanto la intensidad. La tecnología usada por Kinect para adquirir la imagen de profundidad es llamada “LightCoding”, la cual utiliza un emisor infrarrojo para la proyección del patrón de puntos, los cuales son invisibles para el ojo humano. Cada punto del patrón esta hecho para que sea diferente a los demás, de esta forma, la cámara infrarroja lee la luz codificada y ejecuta un sofisticado algoritmo de procesamiento paralelo para descifrar el código de la luz y poder generar una imagen de profundidad. El método es sensible en luz ambiental [7].

� Triangulación

En visión por computadora, la triangulación se refiere a el proceso para determinar un la distancia de un punto en un espacio 3D a partir de la visión de dos o mas imágenes. La figura 3.6 muestra la geometría epipolar de un par de cámaras de visión estéreo.

Figura 3.6 Triangulación en visión estéreo [8].

22

Un punto “P” es proyectado en un espacio tridimensional, que pasa por el punto focal de cada cámara, lo que resulta en dos puntos correspondientes de imagen, si estos puntos son conocidos y la geometría de la imagen es conocida, la proyección de esas dos líneas puede ser determinada. Usando algebra lineal se puede determinar la distancia de ese punto. Esta técnica es empleada por el sensor Kinect para calcular la profundidad de los objetos y obtener una reconstrucción 3D, la triangulación es realizada por cada punto entre una imagen virtual y el patrón de observación [7]. El proceso de triangulación para obtener la profundidad de los objetos es mostrado a continuación:

1.- Patrones de luz son proyectados en la escena

2.- Los patrones son distinguibles uno de otro

Figura 3.7 Imagen que muestra la proyección de puntos sobre una superficie [9].

Figura 3.8 Cada punto es distinguible de otro dentro del patrón proyectado [9].

23

3.-Una imagen de profundidad es capturada para usarse como referencia

4.- ∆x es proporcional para la profundidad del objeto

Figura 3.9 Imagen de profundidad capturada por la cámara [9].

Figura 3.10 Δx es proporcional para el punto proyectado [9].

24

Imágenes de profundidad

El sensor Kinect entrega imágenes de profundidad a una velocidad de 30 tramas por segundo, con una resolución de 640*480 pixeles. Los datos de profundidad son representados en un espacio de color RGB o YUV (dependiendo la configuración), en 16bits de datos. Para el caso del espacio RGB se utilizan 16 bits para establecer los datos de profundidad, los cuales corresponden al canal R(rojo) y al canal G(verde), el canal B(azul) se utiliza para establecer datos de usuario, por ejemplo cuando un pixel corresponde a los datos de usuario, este es establecido en el octeto del canal azul, por último el canal A es establecido en 255. Cuando se utiliza el espacio de color YUV (espacio en frecuencia) se utilizan 4 bytes por cada dos pixeles, por lo tanto se pueden almacenar 16 bits en datos de profundidad, pero valores adicionales como el número de usuario detectado, no pueden ser incluidos [10].

Las tablas 3.2 y 3.3 muestran como se distribuyen los datos de profundidad utilizando los espacios de color RGBA y YUV.

Tabla 3. 2 Datos de profundidad en espacio de color RGBA.

R G B A 3 bits de 8 8 bits 0 ó ID de usuario 255

Tabla 3. 3 Datos de profundidad en espacio de color YUV.

YUV( 2 bytes por pixel)

11bits/16bits valores

25

3.1.2 Detección y seguimiento de usuario Cuando se adquieren datos a través de la cámara de profundidad, imagen con la información de la distancia de los objetos o usuario, esta imagen es analizada para extraer información que esté relacionada con el usuario, su posición y la pose realizada. El sensor contiene dentro de su software un algoritmo de detección que consiste en dividir el cuerpo del usuario en 31 partes que son reconocidas en un plano tridimensional. Una representación del proceso de detección de usuario se muestra en la figura 3.11.

El análisis de imágenes de profundidad tiene ventajas sobre el análisis de imágenes a color, las imágenes de profundidad proporcionan mayor calidad en condiciones de ambiente ligeras, es decir, en espacios en donde la luz solar no afecte de forma directa. Esto hace que el sensor realice muestras de dichas imágenes a través de la cámara de profundidad y estas sean más fáciles de analizar que las imágenes a color. Para segmentar la imagen del cuerpo del usuario en diferentes imágenes se utiliza en clasificador de imágenes, cuyo

Figura 3. 11 Proceso de segmentación y obtención de articulaciones a partir de imágenes de profundidad [11].

26

algoritmo esta basado en un árbol de decisiones. Este algoritmo utiliza una base de datos con una similar pose para cada imagen, con aproximadamente 100 000 poses para cada imagen. Para establecer la decisión de que imagen corresponde a la imagen del usuario se establecen diferentes características. Una característica esta definida como una función f(I,x) que define una imagen I y una posición x, además de un parámetro � que describe las características de la imagen dentro del espacio tridimensional, a través de estas características, el algoritmo detecta que imagen se asemeja a la imagen almacenada dentro de la base de datos. A partir de este algoritmo el sensor obtiene articulaciones o puntos específicos del cuerpo del usuario.

Para obtener las articulaciones del cuerpo del usuario se llevan a cabo tres pasos:

1. Un estimador de densidad por cada parte del cuerpo del usuario, basado en la probabilidad de la superficie del área de cada pixel.

2. Técnica para encontrar eficiencia en la densidad. 3. Algoritmo que obtiene la aproximada localización de los puntos o

articulaciones.

La detección de articulaciones es demasiado precisa, con un 91.4 % de probabilidad de ser localizados correctamente dentro del plano tridimensional.

Las articulaciones o puntos del cuerpo, de los cuales se puede realizar un seguimiento dentro del plano que abarca el sensor, son los siguientes:

Figura 3. 12 Articulaciones del cuerpo del usuario, de las cuales se puede realizar un seguimiento (x,y,z).

27

Limitaciones de la detección de usuario

La detección y seguimiento de usuario que proporciona Kinect es precisa y de cierta forma confiable, aunque también sufre algunas limitaciones. Estas limitaciones son insignificantes cuando la aplicación del sensor es exclusivamente en software, pero cuando se aplica a campos como el de la robótica, estas limitaciones pueden ser vitales para la aplicación. Las principales limitaciones en cuanto a la detección y seguimiento de usuario son las siguientes:

• No trabaja bajo la luz solar (hardware) El sensor Kinect proyecta una luz infrarroja a través de su emisor de 60mW (mili Watts) con una longitud de onda de 830nm (nano metros). La luz solar tiene un ancho espectro de luz infrarroja que afecta a la luz proyectada por el sensor, la luz proyectada es blindada por el brillo de la luz solar, entonces la cámara que detecta la proyección de puntos infrarrojos es deshabilitada para poder detectar los patrones emitidos por el emisor. Esto propicia que exista una muy pobre detección de profundidad en áreas que están expuestas a la luz solar.

• No detecta usuarios dentro de superficies transparentes y reflejantes (hardware) La detección en superficies reflejantes o transparentes es también difícil cuando se utilizan sensores ópticos, como es el caso del sensor Kinect. Este factor se debe a que la mayoría de los sensores ópticos reflejan la luz sobre la superficie, esta reflexión puede ser alta o baja y puede afectar en las lecturas del sensor.

• La resolución de la cámara limita el reconocimiento de gestos demasiados precisos, como pueden ser gestos realizados con los dedos a determinada distancia (hardware) La resolución de la cámara de profundidad se limita a 640*480 pixeles con pocos centímetros de resolución, esta limitante determina que algunos gestos no puedan ser reconocidos por el sensor. Dentro de los gestos que no son complicados y pueden ser detectados por el sensor Kinect se encuentran: realizar un movimiento de onda con la mano, levantar y agitar la mano o realizar un círculo con la misma. Sin embargo si una pequeña área del cuerpo es observada, por ejemplo la mano del usuario, gestos tan específicos como los realizados por esta , no pueden ser reconocidos

28

debido a que la región de interés de la imagen que debe ser analizada, es pequeña en comparación con la imagen del cuerpo.

• El Kinect debe de mantenerse fijo sobre una base o superficie (hardware) Para simplificar la detección y seguimiento de usuario, el sensor debe estar totalmente fijo, esto debido a que cuando el sensor se encuentra sobre una superficie móvil, puede detectar determinados objetos como si estos estuvieran en movimiento y/o confundirlos con siluetas humanas para después entregar resultados incorrectos. La figura 3.13 muestra los datos erróneos que entregaría el sensor Kinect cuando se encuentre montado sobre una superficie móvil, algunos objetos son detectados como usuarios debido a que cuando el sensor se mueve, la imagen obtenida aparenta el movimiento del objeto.

La solución a este problema es la calibración que lleva a cabo el usuario para confirmar que se trata de una silueta humana.

• La inicialización para la detección y seguimiento de usuario toma determinado tiempo (software) Otro problema importante es la inconsistente detección de usuario. El problema consiste que cuando el seguimiento de un usuario es perdido por una trama de la imagen de profundidad y el usuario es recuperado por otra imagen, es detectado como si se tratara de otro usuario aunque se trate del mismo. La imagen 3.14 muestra la perdida de un usuario por una trama de profundidad, en la tercera trama (figura 3.16), se recupera la imagen del usuario, pero se determina como un segundo usuario.

Figura 3.13 Imagen que muestra cuando el sensor se encuentra sobre una superficie móvil, algunos objetos son

detectados como usuarios siendo marcados con determinado color [12].

29

3.1.3 Librerías de libre acceso para la programación de Kinect

Cuando el sensor Kinect salió a la venta, no existían controladores ni librerías para habilitar el uso del sensor en una computadora personal, el uso de este sensor se aplicaba exclusivamente a la consola Xbox360. Fue hasta el 2010 que Microsoft liberó el SDK (Kit de desarrollo de software) para Kinect, el cual permite acceder a todas las funciones del sensor: sensor de profundidad, seguimiento de usuario, cámara RGB y acceso al arreglo de micrófonos. Debido a que Microsoft no fue el creador del controlador principal del sensor Kinect, se han desarrollado diferentes librerías de programación de libre acceso compatibles con el sensor Kinect.

En la tabla 3.4 se muestran las diferentes librerías de libre acceso que se han desarrollado para el sensor Microsoft Kinect, algunas son compatibles con distintos lenguajes de programación y plataformas de desarrollo.

En la primera figura (3.14) se detecta al usuario iluminado con rojo, en la segunda trama (figura 3.15) el usuario es perdido, por último en la tercera trama (figura 3.16) se recupera la detección de usuario, a diferencia que se ilumina de color azul, debido a que el sensor asume que es un nuevo usuario.

Figura 3.15 Imagen 3 Figura 3.16 Imagen 2 Figura 3.14 Imagen 1

30

Tabla 3. 4 Comparación de librerías de libre acceso.

Nombre Lenguajes Plataformas Características Open Kinect/ Libfreenect

C,Python, ActionScript, C#,C++, Java JNI and Java JNA, JavaScript, Com-monLisp

Linux, Windows, Mac OS X

Imágenes de color y profundidad, control de la base motorizada y del led.

CL SDK NUI and driver

C, C# Windows Imágenes de color y profundidad, control del led y de la base motorizada.

Robot Operating System

Pyhon, C++ UNIX Imágenes de color y profundidad. Acceso a base motorizada.

OpenNI/NITE Middle-ware

C,C++,C#, Java Windows, Linux, Ubuntu, Mac OS X

Identificación de usuario, detección de gestos, seguimiento y orientación de articulaciones de usuario, imágenes de color y profundidad.

SDK Microsoft Kinect

C++,C#, Visual Identificación de usuario, detección de gestos, seguimiento de articulaciones de usuario, imágenes de profundidad y de color.

Trabajando con ejemplos de las librerías de OpenNI y las librerías de desarrollo de Microsoft para Kinect, se optó por elegir a OpenNI para la programación del sensor. Aunque la información para la programación de Kinect con OpenNI es escaza, contiene ventajas al lado del software de Microsoft para Kinect tales como: seguimiento de movimiento independiente de las manos, seguimiento de la rotación de las articulaciones del usuario detectado, instalación en plataformas como Windows y Mac, distintos lenguajes de programación (Java, C++, C#) y libre uso de las librerías de programación para cualquier implementación comercial. La programación entre estas dos librerías es totalmente diferente, pero se mantienen los mismos conceptos cuando se trabaja con Kinect como lo son: imágenes de profundidad, imágenes a color y seguimiento de usuario.

31

Descripción de las librerías de uso libre para programar el sensor

OpenNI (Interfaz natural de uso libre) es un conjunto de librerías multiplataforma y multilenguaje para desarrollar aplicaciones utilizando interfaces naturales como e sensor Kinect. Las librerías fueron desarrolladas por una organización llamada “OpenNI” que fue fundada por la empresa Israelí “PrimeSense”, la compañía que otorgó la licencia a Microsoft para construir el sensor Kinect [13]. El principal propósito de OpenNI es establecer un desarrollo de software estándar que habilite la comunicación con:

• Sensores de audio y visión: en esta tesis de utiliza el sensor Microsoft Kinect, pero OpenNI puede utilizarse con el sensor desarrollado por “PrimeSense” llamado “XAzus”.

• Percepción de audio y video(los componentes del software analizan los datos de audio y video que son capturados a través de las imágenes), por ejemplo software que recibe datos visuales como imágenes, regresando la localización de la palma de la mano.

El estándar de OpenNI es aplicado al desarrollo de aplicaciones de interacción natural para realizar un seguimiento dentro de una escena tridimensional, estos datos son capturados por medio de las imágenes de profundidad obtenidas por el sensor. Las librerías de programación de OpenNI se puede describir en tres capas (véase figura 3.17), en donde cada una representa un elemento integro. La capa inferior contiene el hardware o dispositivos que adquieren los datos del mundo real. La segunda capa contiene los componentes de las librerías que interpretan y analizan los datos del sensor. Finalmente la capa superior contiene el software que implementa las aplicaciones de interacción natural.

.

Figura 3.17 Representación abstracta del concepto de OpenNI dividido en tres capas [14].

32

La forma en la que trabaja OpenNI es a través de la producción de nodos. La producción de nodos es el establecimiento de componentes que forman los datos del sensor que serán utilizados en las aplicaciones.

OpenNI clasifica la producción de nodos en dos categorías:

• Producción de nodos relacionada con el sensor • Producción de nodos relacionada con las librerías

Los nodos relacionados con el sensor son los siguientes:

• Dispositivo: Un nodo que representa un dispositivo físico (por ejemplo un sensor de profundidad o una cámara RGB), el principal objetivo de este nodo es habilitar el dispositivo que se utilizará.

• Generador de profundidad: Genera mapas de profundidad, este nodo debe ser implementado en algún sensor que capture imágenes en tercera dimensión y esté certificado por la compañía OpenNI.

• Generador de imágenes: Nodo que genera imágenes a color, debe ser implementado en algún sensor que obtenga imágenes a color y esté certificado por la compañía OpenNI.

• Generador infrarrojo: Nodo que genera imágenes infrarrojas. • Generador de audio: Genera cadenas de audio.

Los nodos relacionados con las librerías de OpenNI son los siguientes:

• Generador de gestos: genera eventos en la aplicación cuando determinados gestos son detectados.

• Analizador de escena: separa el fondo de una escena de un objeto o imagen de usuario, permitiendo trabajar los pixeles de fondo de forma independiente.

• Generador de puntos en la mano: permite reconocer la palma de la mano de un usuario y realizar un seguimiento cuando la mano cambia de posición.

• Generador de usuario: representación del cuerpo(o parte del cuerpo) en una escena tridimensional.

Calibración

Para la producción del nodo de generación de usuario es necesaria una pose por parte del usuario, debido a que antes de realizar este proceso, los datos del usuario que proporciona la cámara de profundidad no están alineados con

33

respecto a los datos de la cámara de color. La calibración se utiliza para poder utilizar los datos de profundidad, junto con los de la imagen de color. También optimiza el seguimiento de usuario, debido a que ofrece una mayor precisión a diferencia de no utilizar la mencionada calibración.

3.2 Dispositivos de procesamiento digital Para poder programar el sensor Kinect se requiere el uso de una computadora personal, debido a que la mayor parte de los datos, se adquieren, procesan y muestran en forma de video (datos digitales), lo cual demanda velocidades de procesamiento altas como las que se llevan a cabo en computadoras personales de reciente tecnología, además de que la adquisición de datos que se obtiene del sensor es a través del puerto USB(bus serial universal) y todas las librerías de desarrollo son únicamente compatibles con sistemas operativos que se ejecutan en computadoras personales y entornos de desarrollo para las mismas (Visual Studio, NetBeans, Eclipse, etc.).

A diferencia del procesamiento para el sensor Kinect, el brazo robótico requiere de un dispositivo ajeno a la computadora personal para generar el movimiento de los servomotores (modulación por ancho de pulso) que conforman la estructura del robot, este dispositivo debe contar con algún protocolo de comunicación que facilite la recepción de datos desde la computadora y los procese para poder generar el movimiento de los servomotores bajo el concepto de sistema multitarea, es decir, de forma simultánea.

3.2.1 Descripción de los dispositivos de procesamiento

� Computadora personal para procesamiento de datos del sensor

De acuerdo con las especificaciones de los desarrolladores de las librerías utilizadas para la programación del sensor Kinect [13], las características de procesamiento para la computadora que se utilice para tratar los datos del sensor deben de ser las siguientes:

• Sistemas operativos basados en arquitectura de 32 bits ó 64 bits • Procesadores Pentium 4 a 1.4 GHz o posteriores

34

Para el presente proyecto se utilizó una computadora personal con procesador Intel i7 a 2.20 GHz, y sistema operativo Windows 7 edición Ultímate, debido a que es la computadora personal con la que se cuenta y cumple las exigencias para la programación del sensor.

� Microcontrolador PIC18F4550

Como se mencionó anteriormente el control del robot requiere un dispositivo de procesamiento que sea capaz de establecer una comunicación con la computadora para la recepción de datos, y de forma simultanea genere el movimiento de los motores, los cuales ejercen la fuerza sobre la estructura del brazo y producen su movimiento. A partir de estas necesidades se propone el uso del microcontrolador PIC18F4550, este microcontrolador fabricado por Microchip, cuenta con recursos que cumplen con las características que se requieren para la recepción, procesamiento, y generación de señal de movimiento de los motores, añadiendo que se cuenta con experiencia en la programación y recursos de este dispositivo, basada en los cursos tomados y trabajos desarrollados a lo largo de la carrera.

En el anexo 2.1 se muestran las características del PIC18F4550 y a continuación se describen los recursos del PIC que se utilizan en el presente trabajo:

• Comunicación serial síncrona (USART): utilizada para establecer la recepción de datos que provienen desde la computadora a través del protocolo RS232, que corresponden a los grados de movimiento que deben realizar los servomotores.

• Puertos de salida (PORTB): permiten la salida de datos que son procesados por el microcontrolador y son enviados a un dispositivo electrónico externo, en nuestro caso se utilizan enviar los estados de voltaje alto y bajo para la señal de los servomotores.

• Temporizadores (TIMERS): un sistema multitarea requiere de rutinas de servicio que se ejecuten de forma administrada y con tiempo favorables para el sistema, los temporizadores del micro controlador son utilizados para generar el movimiento de los servomotores, y la recepción de datos provenientes de la computadora, en un tiempo que sea mínimo y contribuya a la rápida respuesta del movimiento del brazo robótico.

35

3.2.2 Comunicación entre la computadora y microcontrolador PIC18F4550 Un sistema en tiempo real necesita de un protocolo de comunicación que permita transportar los datos enviados hacia el dispositivo final (en nuestro caso micro controlador), desde la computadora. Este protocolo debe favorecer al rápido transporte de los datos para evitar retrasos en los tiempos de respuesta. El protocolo que establece la comunicación entre la computadora y el micro controlador, el cual es el encargado de mover el brazo robótico, es el protocolo RS232, dicho protocolo es uno de los mas usados dentro de los sistemas en tiempo real, además de que permite fácilmente transmitir datos como caracteres de forma rápida, eficiente y sin fallas. La figura 3.18 muestra el diagrama que representa la comunicación entre los dispositivos de procesamiento.

En este proyecto se utiliza comunicación serial RS232 para enviar los datos de la computadora al microcontrolador, pero se realiza de forma inalámbrica utilizando el módulo bluetooth de la computadora para el envío de datos y el modulo serial inalámbrico que se muestra en la figura 3.19 para la recepción por parte del PIC, módulo basa su funcionamiento en el protocolo bluetooth, pero entrega los datos de forma serial a una velocidad de 9600 baudios por segundo. La comunicación entre los dispositivos de procesamiento es totalmente inalámbrica como se ejemplifica en la figura 3.18, en donde se envían los datos por el módulo bluetooth de la computadora y ser reciben por el modulo serial que se encarga de entregar los datos al microcontrolador.

Figura 3.18 Diagrama de comunicación entre los dispositivos de procesamiento.

Figura 3. 19 Módulo serial bluetooth.

36

Este módulo se adapta a cualquier bluetooth de computadora como si se tratara de un dispositivo de este protocolo que se encuentra en celulares, cámaras, etc. Una vez que se lleva a cabo el proceso de “emparejamiento”, se crea un puerto virtual dentro de la computadora con la que se emparejó al módulo, como si se tratara de un puerto físico serial con conector DB9. Una vez que el puerto se ha creado de forma virtual, es posible enviar datos desde nuestro programa al puerto virtual, los cuales viajan mediante el protocolo bluetooth, pero son nuevamente entregados hacia el microcontrolador o dispositivo final de forma serial (RS332). Este tipo de comunicación ayuda en el proyecto para la supresión de cables en la comunicación entre la computadora y el PIC18F4550, además de que contiene todas las ventajas del protocolo bluetooth, como la distancia de alcance y la compatibilidad con cualquier dispositivo que maneje comunicación serial. Cabe destacar que aunque el módulo base su funcionamiento en el protocolo bluetooth, no es necesario conocer propiedades demasiado adentradas acerca del protocolo bluetooth, ni realizar ningún tipo de configuración en la programación interna del módulo. En la figura 3.20 se muestran los pines del modulo, los cuales corresponden a la conexión a VCC, GND y los pines de envío TX, y recepción RX, de datos para el dispositivo final, que en nuestro caso es el PIC18F4550.

3.3 Servomotores Es un motor de corriente continua que tiene la capacidad de ser controlado en una determinada posición. El motor es capaz de ubicarse en cualquier posición dentro de un rango de operación (generalmente de 180º) y mantenerse estable en dicha posición. Los servomotores se suelen utilizar en robótica, automatización, debido a su gran precisión en el posicionamiento. En general, los servomotores suelen estar compuestos por 4 elementos fundamentales:

• Motor de corriente continua (DC): Es el elemento que le brinda movilidad al servomotor. Cuando se aplica un potencial a sus dos terminales, este

Figura 3.20 Pines para transmisión y recepción de datos a través del modulo serial bluetooth [15].

37

motor gira en un sentido a su velocidad máxima. Si el voltaje aplicado sus dos terminales es inverso, el sentido de giro también se invierte.

• Engranajes reductores: Tren de engranajes que se encarga de reducir la alta velocidad de giro del motor para incrementar su capacidad de torque.

• Sensor de desplazamiento: Suele ser un potenciómetro colocado en el eje de salida del servomotor que se utiliza para conocer la posición angular del motor.

• Circuito de control: Es una placa electrónica que implementa una estrategia de control de la posición por realimentación. Para ello, este circuito compara la señal de entrada de referencia (posición deseada) con la posición actual medida por el potenciómetro. La diferencia entre la posición actual y la deseada es amplificada y utilizada para mover el motor en la dirección necesaria para reducir el error. En la figura 3.21 se muestran los 4 elementos mencionados anteriormente, además se muestra la carcasa en donde vienen incluidos estos elementos y en conjunto forman al servomotor.

3.3.1 Principio de funcionamiento

Los servos disponen de tres cables (Figura 3.22): dos cables de alimentación (positivo y negativo) que suministran un voltaje 4.8-6V y un cable de control que indica la posición deseada al circuito de control mediante señales PWM (“Modulación por ancho de pulsos”).

Figura 3.21 Elementos que conforman un servomotor [16].

Figura 3.22 Cables de un servomotor [16].

38

Las señales PWM (modulación por acho de pulso) utilizadas para controlar los servos están formadas por pulsos positivos cuya duración es proporcional a la posición deseada del servo y que se repiten cada 20ms (50Hz). Todos los servos pueden funcionar correctamente en un rango de movimiento de 90º, que se corresponde con pulsos PWM comprendidos entre 0.9 y 2.1ms. Sin embargo, también existen servos que se pueden mover en un rango extendido de 180º y sus pulsos de control varían entre 0.5 y 2.5ms. Antes de utilizar un servo se debe comprobar experimentalmente su rango de movimiento para no dañarlo. Para mantener fijo un servo en una posición habrá que enviar periódicamente el pulso correspondiente; ya que si no recibe señales, el eje del servo quedará libre y se podrá mover ejerciendo una leve presión.

3.3.2 Control de un servomotor Para controlar un servo, se le ordena un cierto ángulo, medido desde 0 grados, enviándole una serie de pulsos. En un tiempo alto de pulso se le indica el ángulo al que debe posicionarse. Generalmente se considera que en 1.5ms está en el centro (90 grados) .Entre límites de 1 ~ 2ms son las recomendaciones de los fabricantes, normalmente se puede usar un rango mayor de 1.5ms para obtener un ángulo mayor e incluso de 2ms para un ángulo de rendimiento de 180 grados o más. El factor limitante es el tope del potenciómetro y los límites mecánicos construidos en el servo. Un sonido de zumbido normalmente indica que usted está forzando por encima al servo, entonces debe disminuir un poco. En la figura 3.23 se muestra el ciclo de trabajo o también nombrado pulso en alto para que un servomotor se posicione en 90 grados (posición neutra), 0 grados y 180 grados, el ciclo de trabajo para las posiciones de 0 y 180 grados depende del servomotor y del fabricante.

Figura 3.23 Ciclos de trabajo para posicionar un servomotor estándar [16].

39

3.4 Tarjeta de control para los servomotores La figura 3.24 muestra la conexión que se realizó para la simulación del movimiento de los motores, dentro del esquema se encuentra la conexión del puerto del microcontrolador del cual se utilizan los pines b0 a b3 para conectar los motores. La conexión al puerto DB9 (puerto serie), el cual sirvió de apoyo para crear un puerto virtual y simular la entra de datos desde la computadora hacia el PIC, recalcando que en este proyecto no se hace uso del conector DB9, el cual es remplazado por el modulo serial inalámbrico bluetooth.

3.4.1 Diagrama esquemático del circuito impreso para la tarjeta de control Una vez realizadas las pruebas correspondientes para el movimiento de los servomotores y recepción de datos a través del modulo UART, se implementó el siguiente diseño de la tarjeta controladora, la cual contiene el PIC18F4550 como unidad central de control y el modulo serial bluetooth para la recepción de datos.

El diseño del circuito esquemático y PCB, fue realizado con el software ALTIUM Designer, implementando un modelo de PCB de doble capa. La figura 3.25 muestra el diseño final de la tarjeta controladora.

Figura 3.24 Diagrama de simulación para movimiento de los servomotores.

40

En las figuras 3.26 y 3.27 se muestran las capas que forman el diseño del circuito impreso basado en el diagrama esquemático que corresponde a la tarjeta controladora de servomotores incluyendo las conexiones para los servomotores y el módulo de comunicación entre la computadora y el microcontrolador.

Figura 3.25 Diagrama esquemático de tarjeta controladora para los servomotores.

Figura 3. 27 Capa inferior del circuito impreso. Figura 3. 26 Capa superior del circuito impreso.

41

En la figura 3.28 se muestra el diseño físico del circuito impreso, indicando las medidas que corresponden a la tarjeta controladora para los servomotores del brazo robótico e indicando los componentes más importantes que constituyen a la tarjeta.

Batería para los servomotores

Los servomotores utilizados en el presente proyecto requieren una fuente de alimentación independiente al voltaje suministrado al PIC18F4550. La fuente de alimentación que se utiliza para alimentar a todos los motores que componen el brazo manipulador es una batería de acido-plomo. Las baterías de acido-plomo son confiables, de larga duración, además de que no requieren algún tipo de circuitería que represente mayores gastos o espacio dentro del circuito. La mayoría de las baterías tienen una determinada duración, dependiendo de la corriente y voltaje demandados por el circuito. En la figura 3.29 se muestra la batería utilizada para los servomotores, y en la tabla 3.5 sus características.

Tabla 3. 5 Características técnicas de la batería acido-plomo.

Sistema de protección para carga excesiva Terminales de 1. 06 cm Soporta hasta 300° Centígrados 0.78 kg 6v a 4Ampers/hora

Figura 3.28 Tarjeta de control para los servomotores.

Figura 3.29 Batería de acido-plomo.

42

La duración para la batería de forma continua es la indicada a continuación:

Duración = ��(�� !"�� #$%$&$ ��í$)��(�� (�%��"� �) = 3.3ℎ,-./ (Ecuación 3.1)

Para la duración de manera discontinua se tomó en cuenta la gráfica de descarga de la batería (ver anexo 3.1) donde indica que para una corriente de 1200mA de forma no constante se obtendrá una duración de 2 a 3 horas de forma no continua.

43

Capítulo 4

Diseño del software Como se mencionó anteriormente, el trabajo realizado en esta tesis es un sistema en tiempo real, el brazo robótico tiene que moverse en un determinado tiempo que asimile ser paralelo al tiempo en que el usuario mueve el brazo derecho. El funcionamiento del software se basa en el diagrama de flujo que se describe posteriormente, el cual muestra los diferentes procesos para que se ejecuten en los dispositivos de procesamiento.

4.1 Descripción del software En el diagrama mostrado en la figura 4.1 se marcan de color azul los procesos que serán ejecutados por la computadora, mientras que de color verde los procesos que ejecutará el microcontrolador PIC18F4550. A pesar de que algunos procesos son ejecutados por el mismo dispositivo (computadora o sensor Kinect), cada proceso depende de otro y tiene una prioridad asignada para su ejecución.

En nuestro primer proceso o inicio del algoritmo del sistema, se inicializa el sensor, en el segundo proceso se adquieren los datos de profundidad, después se entra en el proceso calibración de usuario, hasta que sea completado de forma correcta se puede trabajar con los datos de usuario. El siguiente paso es el cálculo del movimiento del brazo del usuario, es aquí donde se aplica el algoritmo de seguimiento del brazo que controla el robot. La segunda condición que existe dentro del sistema es la detección del gesto de finalización, dato que ordena al microcontrolador que realice la detención del brazo robótico, esta condición es aplicada dentro de cada ciclo del diagrama de flujo, y procesada antes de enviar el paquete de datos hacia el microcontrolador. El siguiente proceso en el diagrama de flujo es nuevamente la condición de finalización, la diferencia entre la condición marcada en verde y la marcada en azul, radica en que el proceso marcado de verde es aplicado por el microcontrolador, si ésta condición se cumple, el microcontrolador detiene el brazo robótico dando fin a la aplicación, en caso

44

contrario se genera el movimiento del robot, y después regresa nuevamente al proceso de adquisición de imágenes, que propicia la repetición del ciclo del algoritmo, el cual llega a su fin cuando el gesto de finalización es detectado.

Figura 4.1 Diagrama de flujo del software del sistema.

45

El sistema en tiempo real implementado en este trabajo, omite algunas etapas de proceso dentro de un sistema en tiempo real, debido a que parte de los datos que son adquiridos del ambiente a través del sensor Kinect, son procesados por el sensor y enviados a la computadora como datos digitales.

El diagrama de la figura 4.2 muestra las etapas que componen al sistema en tiempo real para el movimiento del brazo robótico y los procesos que son ejecutados dentro de cada etapa.

Figura 4.2 Diagrama a bloques de las etapas del sistema.

Las etapas del sistema mostradas en la figura 4.2 se resumen a continuación:

• Inicialización del Kinect : el sensor es la variable de entrada que interactúa con el ambiente y entrega datos del mismo (en nuestro caso usuario), además de que estos resultados dependen del tiempo, es por eso que se determinada como la primer etapa del sistema. A pesar de que solo se utiliza un sensor, se puede considerar la adquisición de múltiples variables, debido a los diferentes datos que entrega el Kinect.

• Adquisición de imágenes y datos de profundidad: se capturan todos los datos que envía el sensor hacia la computadora, permitiendo utilizarlos para la implementación de nuestro algoritmo de movimiento.

• Proceso de calibración: no todos los usuarios presentan el mismo tamaño de extremidades del cuerpo, motivo por el cual se realiza un proceso de calibración que permite la correcta lectura de los datos del usuario.

• Selección de articulaciones a utilizar: Microsoft Kinect entrega datos referentes a las articulaciones del cuerpo del usuario, sin embargo no todos

46

estos datos se utilizan en el proyecto, dentro de esta etapa se adquieren únicamente las articulaciones que servirán para realizar el cálculo del movimiento del brazo derecho y mano izquierda del usuario, las demás son descartadas.

• Cálculo de movimientos del brazo: se implementan los algoritmos basados en cinemática directa, que utilizan datos procesados por etapas anteriores y se calculan los datos finales que serán enviados a la siguiente etapa.

• Transductor o etapa del movimiento del brazo robótico: un sistema en tiempo real , aplica una acción en el ambiente después de procesar las variables de entrada, dentro de esta etapa se explica el movimiento del brazo robótico, el cual es efectuado a través del microcontrolador PIC18F4550.

4.2 Inicialización del Kinect Realizando investigación sobre las librerías mas utilizados para el desarrollo de aplicaciones con Kinect: el software de desarrollo de Microsoft para Kinect y OpenNI, se optó por elegir al segundo. A diferencia del software de Microsoft para Kinect, OpenNI fue desarrollado por la empresa que otorgó la patente a Microsoft para la construcción del dispositivo, por lo que estas librerías contienen herramientas que para este trabajo, representan una gran ventaja al lado del SDK de Microsoft. La licencia otorgada por Microsoft es exclusivamente para su uso no comercial, a diferencia del software utilizado en este proyecto, que sí permite el uso comercial de sus librerías, factor que puede contribuir en una futura implementación comercial.

Las principales ventajas entre OpenNI y el sotfware de Microsoft se muestran en la tabla 4.1. En relación al seguimiento de usuario, una de las ventajas de OpenNI que es factor en este trabajo, es la obtención de la rotación de las articulaciones del cuerpo del usuario, herramienta que el SDK de Microsoft no ofrece, otra ventaja de utilizar OpenNI, es un soporte basado en librerías para el seguimiento exclusivo de las manos y reconocimiento de gestos con las mismas. Algunos otros factores que también influyen en la elección de OpenNI son el menor consumo de CPU, uso de múltiples lenguajes de programación y de plataformas como Linux o Mac. En cuanto a las desventajas que pueden presentarse dentro de OpenNI se encuentran la pose de calibración que se necesita para trabajar con los datos de usuario y la confusa instalación y falta de información por parte de las librerías utilizadas. En la tabla 4.2 se enlistan las desventajas tanto del SDK de Microsoft y de OpenNI.

47

Tabla 4. 1Ventajas del software de Microsoft para Kinect y OpenNI

Tabla 4. 2 Desventajas del software de Microsoft para Kinect y OpenNI.

SDK de Microsoft OpenNI Soporte par audio Licencia de uso comercial

Soporte para motor Framework para seguimiento de manos independiente.

Seguimiento de usuario Seguimiento de usuario

Ventajas No necesita pose de calibración

Calcula rotación de las articulaciones

Mejor tratamiento de articulaciones ocluidas.

Soporta Windows, Linux y Mac.

Instalación simple Soporte para adquirir las imágenes infrarrojas

Sistema de reconocimiento de gestos con las manos.

Compatible con varios sensores.

SDK de Microsoft

OpenNI

Licencia únicamente para uso no comercial.

Carece de rotaciones para manos, pies y clavícula.

Seguimiento de usuario completo (no permite seguir únicamente las manos)

Articulaciones ocluidas no son compatibles.

Desventajas No calcula la rotación de las articulaciones.

Laboriosa instalación

Exclusivamente para Windows 7

Consume mas CPU que OpenNI

48

En OpenNI los recursos que se utilizan del sensor para el desarrollo de aplicaciones se dividen por nodos, estos dependen de que recursos se vallan a utilizar del sensor, por ejemplo: si se desea utilizar únicamente la cámara de color RGB, se debe utilizar el nodo denominado “Generador de Imagen” que permite generar las imágenes a color por parte de la cámara del sensor y adquirir las imágenes cuando el sensor realice una captura y esta puedan ser enviada hacia la computadora. Los nodos se pueden utilizar de forma individual o de forma conjunta. Para poder hacer uso de los nodos en OpenNI, se debe hacer uso de un archivo de configuración con extensión .xml, este archivo contiene los nodos que serán utilizados en la aplicación.

La configuración de un archivo .xml para iniciar el Kinect dentro de OpenNI debe tener la plantilla que se muestra en el anexo 3.2, las configuraciones dentro del archivo xml se refieren a los siguientes parámetros:

• <licencias> indica la licencia que se utilizada para el uso libre de OpenNI, la cual se obtiene de forma gratuita en la página de OpenNI , y permite el acceso a todos los nodos disponibles en las librerías.

• <Producción de nodos> en esta etiqueta se deben incluir todos los nodos que se desean producir a través del sensor, especificando las características deseadas.

• <Tipo de nodo =” nombre”> en esta sección se debe indicar el tipo de nodo que se va a utilizar (profundidad, imagen, imagen de infrarrojo, audio, etc), además de que se añade un nombre que identifica al nodo.

• <Configuración > la configuración de cada nodo es establecida a través de esta etiqueta, donde se indican las características de cada nodo, si se desea utilizar cualquiera de las cámaras del sensor, se debe establecer la velocidad de envío y la resolución.

En este trabajo se utilizan los siguientes nodos: profundidad (Generador de profundidad), imagen RGB(Generador de imagen), usuario(Generador de usuario) y gestos(Generador de gestos). La idea de trabajar con los datos del sensor de profundidad, es poder obtener la ubicación dentro del plano 3D de las articulaciones del usuario, motivo por el que se utiliza un nodo de profundidad. Debido a que el sensor detecta al usuario y accede a las articulaciones del mismo a través de imágenes de profundidad, se debe utilizar obligatoriamente el nodo de profundidad si se requiere utilizar el nodo de usuario (Generador de usuario). El nodo Generador de imagen es utilizado para visualizar la imagen a color, utilizada en el proyecto únicamente como referencia de los movimientos que ejecuta el usuario. Los siguientes nodos

49

(Generador de seguimiento de manos y Generador de gestos) sirven de apoyo para utilizar las librerías que proporciona OpenNI y dedicadas exclusivamente al seguimiento de manos y detección de gestos con las manos, herramienta que se implementara para definir un gesto de finalización del movimiento del brazo robótico.

En resumen: los nodos a utilizar y configurar dentro del archivo .xml son los siguientes:

• Generador de profundidad (utilizado para la imagen de profundidad) • Generador de imagen( datos sobre la imagen a color) • Generador de usuario (permite acceder a datos del usuario) • Generador de seguimiento de manos( realiza seguimiento exclusivo de

las manos) • Generador de gestos(detecta gestos hechos con las manos)

El archivo xml puede nombrarse de cualquier forma, lo importante de la configuración de este archivo es el establecimiento de los nodos a utilizar y sus propiedades, ya que de esto dependerá la velocidad de actualización de nuestra aplicación. La configuración final del archivo .xml utilizado en el proyecto es la mostrada en el anexo 4.1.

Algunos puntos importantes de observar en la configuración de este archivo son: el establecimiento de la resolución y velocidad de envío para las cámaras de profundidad y de color, los cuales son de 640*480 pixeles a un velocidad de 30 fps (30 tramas por segundo) para ambas cámaras.

Todos estos nodos deben ser iniciados y procesados computacionalmente a través de un principal objeto definido en las librerías de OpenNI, denominado “contexto”. Este objeto se encarga de inicializar, actualizar y detener todos los nodos producidos por el sensor, los cuales fueron también establecidos en el archivo .xml. Para poder trabajar con el objeto “contexto” en OpenNI, se deben tomar en cuenta los siguientes métodos que son la base para trabajar con los datos del sensor: “Iniciar generando todo”, “Esperar y actualizar”, “Detener todo”, métodos que son llamados a través del objeto “contexto”. El método “Iniciar generando todo” se encarga de inicializar todos los nodos que fueron escritos en el archivo xml, asegurando de que cada uno de ellos contenga las propiedades adecuadas para su funcionamiento. El método “Esperar y actualizar”, actualiza los datos de todos los nodos que se hayan generado, permitiendo que los nuevos datos capturados por el sensor puedan ser utilizados para su procesamiento, cuando se desea actualizar solo uno de los nodos inicializados se utilizan otros métodos como “Esperar por alguno y actualizar”, el cual espera por un nodo en

50

especifico sin tomar en cuenta que otros nodos hayan generado o no, nuevos datos. El método “Detener todo” se encarga de detener la generación de todos los nodos a través del sensor, este método puede utilizarse para dejar de utilizar alguna configuración de un archivo xml y poder utilizar otro archivo con la extensión indicada.

4.3 Software para adquisición de datos Para la programación del software se implementó un modelo basado en el diagrama de clases mostrado en la figura 4.3, ocupando un objeto por cada clase, con el objetivo de organizar los algoritmos implementados en cada clase y poder tener un control y acceso para las características que ofrece el sensor.

Figura 4.3 Diagrama de clases del software diseñado para la computadora.

El contenido de las clases se resume a continuación:

• Seguimiento: contiene los métodos para obtener todos los datos referentes al seguimiento de el usuario como las coordenadas (x,y,z) de las articulaciones y su rotación.

• Imágenes: realiza la adquisición y procesamiento de todas las imágenes con las que se trabajan como imagen de profundidad e imagen RGB.

• Cálculos: implementa todos los algoritmos matemáticos utilizados en el software.

51

• Detección de mano: procesa dentro de sus métodos la imagen que obtiene la forma de la mano del usuario y con ello determina su estado (abierto o cerrado).

• Programa principal: inicia todos los procesos a través de dos subprocesos que se ejecutan de forma paralela para el funcionamiento del programa.

4.3.1 Imagen de profundidad

Como se mencionó anteriormente, los datos y seguimiento de usuario, dependen de las imágenes de profundidad, estas son generadas a través del nodo “Generador de profundidad” y entregadas a una velocidad de 30 tramas por segundo. Una desventaja de OpenNI es que no genera ningún tipo de evento cuando una imagen ha sido producida y enviada por el sensor hacia la computadora, simplemente los datos son entregados a través del método “Obtener Metadatos”, el cual entrega los datos de profundidad, debido a esto, la velocidad de adquisición de la trama o imagen, dependerá del algoritmo implementado en la aplicación y el tiempo que se asigne para procesar cada imagen.

La adquisición y procesamiento de datos del sensor Kinect son desarrollados utilizando tecnología .Net, y lenguaje de programación C#, trabajando las imágenes como mapas de bits. Estos mapas permiten crear una imagen del tamaño de la imagen entregada por el sensor, bloquear la imagen durante el proceso de copiado de datos y una vez que se termina este proceso, mostrar la imagen. En la figura 4.4 se muestra una representación del mapa de bits que permite almacenar la cantidad exacta de datos entregados por el nodo de profundidad.

640 bytes

480 bytes

Figura 4.4 Mapa de bits a utilizar para copiar imágenes entregadas por el sensor.

52

Cada byte dentro del mapa contiene 8 bits, esto indica que solo se pueden almacenar datos con valor máximo de 255. Realizando el producto entre las filas y columnas del mapa de bits, obtenemos un total de 307200 bytes para cada canal utilizado en las imágenes. La representación de los datos en una imagen de profundidad en OpenNI es establecida en escala de grises. Normalmente el valor de un pixel en escala de grises se representa por un canal, y cuyo valor del pixel se encuentra en el rango de 0-255, el nodo de profundidad entrega normalmente valores de 0 a 10000 para cada pixel, este valor representa la distancia en cm que existe entre el sensor y las coordenadas del espacio3D que corresponden a ese pixel, pero para poder representarlo en escala de grises se normaliza al rango de 0-255. Perceptivamente dentro de la imagen de profundidad, este valor representa la intensidad de un pixel, graficándose en pantalla como un determinado color entre el blanco y el gris, por ejemplo: si el valor del pixel es 0, el color del pixel es negro, y de forma contraria, si el valor es 255 ,el color es blanco, si el valor se encuentra dentro de ese rango, obtendrá el color al cual su valor este mas cercano, ejemplo: 150 (obtenemos un color parecido al blanco), 30(obtenemos un color parecido al negro), el umbral establecido para definir la frontera de los valores de cada pixel es 128. Para poder obtener una imagen de profundidad y visualizarla dentro de una interfaz gráfica de usuario, se debe implementar un algoritmo que capture los datos de profundidad que entrega el sensor cada 30 milisegundos, y realice el proceso de copiado hacia el mapa de bits, para después mostrarlos de forma gráfica. El algoritmo de la figura 4.5 obtiene una imagen de profundidad y es implementado en el código del anexo 4.2.

Figura 4.5 Algoritmo para obtener una imagen de profundidad.

53

El objeto de tipo “Bitmap” sirve para poder almacenar los datos de profundidad obtenidos de la función “GetMetaData”, el cual debe ser bloqueado durante el proceso de copiado, para evitar que algunos datos sean sobre escritos. El objeto de tipo “DepthMetaData” es utilizado para almacenar todos los datos de profundidad en el caso de que se quiera trabajar con ellos. La figura 4.6 despliega la imagen de profundidad que se obtiene cada 30 milisegundos a una distancia de 2 metros. Curiosamente se puede observar en la imagen de profundidad que los contornos del usuario o de los objetos se visualizan de color negro, simulando una sombra, esto se debe a que los puntos infrarrojos son desviados por los contornos de un objeto o persona, por lo que el valor de esas regiones se establece en 0. Los valores de estos pixeles que se encuentran en la frontera entre el usuario y la imagen, no afectan de forma directa dentro de la detección de usuario, debido a que el contorno puede ser obtenido utilizando otros algoritmos de visión por computadora.

Figura 4. 6 Imagen de profundidad y color del usuario a una distancia de 2metros utilizando el nodo “Generador de profundidad”.

Figura 4.7 Imagen de profundidad y color cuando el usuario extiende la mano a una distancia menor de 15 cm.

54

En la figura 4.7 se observa otro detalle importante cuando se trabaja con el sensor de profundidad del Kinect, cuando algún objeto se encuentra dentro de una distancia menor a 15 cm delante del sensor, el valor de profundidad del pixel de este objeto siempre será nulo, debido a la arquitectura con la que cuenta el sensor de profundidad, en este caso el diseño de la cámara de profundidad, no es capaz de detectar los puntos infrarrojos que se proyecten en objetos que se encuentren a 15cm o a una menor distancia delante del sensor, por este motivo todos estos objetos o formas se visualizan de color negro en la imagen de profundidad.

4.3.2 Imagen en el espacio RGB La imagen RGB sirve de apoyo en este proyecto para que el usuario pueda referenciar y comparar el movimiento realizado por su brazo y el movimiento que ejecuta el brazo robótico, pero en el movimiento del robot, no afecta de ninguna manera. El nodo encargado de generar datos para adquisición de imágenes a color es “Generador de Imagen “. La composición de una imagen a color es diferente a una imagen de profundidad, un pixel de una imagen a color esta conformado por tres canales: R(rojo) ,G(verde)B(azul), los cuales contienen valores de 0 a 255. OpenNI permite alinear los datos de profundidad con los datos de la cámara RGB, permitiendo mostrar únicamente pixeles donde se muestre el usuario deseado.

El algoritmo para obtener imágenes a color es similar al de las imágenes de profundidad, la diferencia radica en los tipos que se manejan para obtener los datos del contexto y en la forma de copiarlos en una imagen, tomando en cuenta que en una imagen a color se obtienen tres canales y los valores de estos tres forman un color por cada pixel, el algoritmo para imágenes a color se muestra en la figura 4.8 y es implementado en el código del anexo 4.3.

55

En la figura 4.9 se muestra la imagen a color que se obtiene a través del nodo Generador de Imagen. La resolución de la imagen es normalmente de 640*480 pixeles, pero el sensor Kinect puede generar imágenes a color con una resolución de 1280*1024 reduciendo la velocidad de envío a 15 tramas por segundo.

Figura 4. 8 Algoritmo para obtener imagen a color.

Figura 4. 9 Imagen RGB obtenida con el nodo "generador de imagen".

56

4.3.3 Imagen de puntos infrarrojos Las imágenes de proyección del patrón de puntos infrarrojos que emite el sensor de profundidad del Kinect no son utilizadas para la implementación del proyecto, sin embargo se muestran como referencia para entender el desarrollo de la aplicación y el funcionamiento del sensor. La figura 4.10 muestra la imagen de puntos infrarrojos que emite el sensor sobre la superficie que cubre, estos son representados de forma visual a través de la intensidad de cada uno de los pixeles, como se mencionó en el capitulo dos, estos puntos cubren cada objeto que se encuentre dentro del área del sensor, permitiendo detectar la distancia de los objetos o usuario y generar el mapa de profundidad.

4.3.4 Proceso de calibración El sensor de profundidad detecta máximo a seis usuarios dentro del área que cubre, sin embargo, para realizar un mejor seguimiento de usuario, es recomendable trabajar con un máximo de dos usuarios, ya que el aumento de seguimiento de estos, provoca retardos en el procesamiento de datos de usuario por parte de la computadora. En el presente trabajo se propone a un solo usuario como operador del brazo robótico, pero también se consideran factores como la intromisión accidental o provocada de otra persona dentro del área del sensor.

OpenNI tiene la ventaja de generar eventos cuando se detecta o pierde un usuario, cuando se detecta un nuevo usuario asigna un número de identificación (ID) al usuario detectado, por ejemplo: si la aplicación es iniciada y entra un primer usuario al área que cubre el sensor, se le es asignado el número 1 como ID, si posteriormente ingresa otra persona se le asigna el ID número 2, continuando de esta manera sucesiva hasta llegar al máximo de usuarios que pueden ser detectados, si llegaran a ingresar mas usuarios dentro del área del sensor, estos

Figura 4. 10 Imagen del patrón infrarrojo emitido por el sensor de profundidad, obtenida a través del nodo “Generador Infrarrojo”.

57

no serian detectados o simplemente obtendríamos un error en tiempo de ejecución. Una pregunta común que puede llegar a surgir dentro de la detección de usuario es: ¿Qué pasa cuando un usuario es identificado, pero después sale del área del sensor y regresa nuevamente? , el sensor Microsof Kinect guarda los datos de un usuario cuando es perdido, es decir cuando abandona el rango que cubre el sensor, si un nuevo usuario es detectado posteriormente, el sensor compara los datos del usuario detectado, con los datos del usuario perdido, buscando semejanzas en cuando a la forma del cuerpo y tamaño, por lo tanto es posible que al usuario detectado se le asigne el ID del usuario perdido, si es que se tratara de la misma persona, en caso contrario se le asigna un nuevo ID , esto propicia algunos errores que pueden llegar a suceder durante la identificación, por ejemplo: que un usuario salga del área del sensor y otro entre, tomando el ID del primero debido a una posible similitud en las extremidades y forma del cuerpo entre ambos , lo cual es difícil que pueda suceder.

Otra ventaja de poder identificar mediante ID a los diferentes usuarios dentro del área del Kinect es que podemos utilizar los pixeles de profundidad que correspondan únicamente a ese determinado usuario, permitiendo realizar interfaces gráficas de usuario en donde solo se despliegue la imagen que corresponde al cuerpo del usuario, o en su defecto alinear los pixeles de usuario con los de la cámara RGB para obtener imágenes a color del cuerpo del usuario.

La diferencia para adquirir datos de usuario entre el SDK de Microsoft y las librerías de OpenNI para el seguimiento de usuario, radica en que OpenNI necesita una pose de calibración. Las librerías de Microsoft no requieren de una pose de calibración para acceder a las articulaciones del usuario, esto se debe a que la calibración que realiza el software de Microsoft se hace mediante un algoritmo que localiza el centro de masa del usuario detectado, y a partir de ahí, se localizan los puntos a los cuales se tiene acceso. OpenNI incluye una pose de calibración, la cual no impide que se puedan acceder a las articulaciones del usuario, pero se obtiene una mejor precisión del seguimiento realizando esta pose de calibración. El proceso de calibración también ayuda en el seguimiento de usuarios que estén dentro del área del sensor y tengan parecidas pero no idénticas formas en los sus cuerpos.

OpenNI contiene eventos que se generan cuando ocurren procesos relacionados con la detección y calibración de usuario. En la figura 4.11 se muestra el diagrama de flujo para poder realizar la correcta calibración del usuario, estos procesos son establecidos por OpenNI de forma general, sin poder ser modificados, implementando la calibración en el código del anexo 4.5.

58

Los procesos marcados de color azul dentro del algoritmo de calibración mostrado en la figura 4.11 representan los eventos que se generan cada que ocurre dicho proceso, los procesos de color verde representan métodos que deben ser llamados para realizar la tarea específica. El proceso de calibración debe ser realizado para cada usuario detectado, si es el caso que se requiera trabajar con los datos de un nuevo usuario. El proceso de calibración de un usuario se puede describir de la siguiente manera: un nuevo o primer usuario es detectado por el sensor generando el evento “Nuevo usuario” , a partir de este momento se realiza la petición para detectar una pose de calibración, es decir, se asume que el usuario detectado realizará la pose de calibración, el método que realiza esta petición es “Iniciar pose de detección”, este método recibe dos parámetros: el ID(número de usuario) del que se desea calibrar, y la pose de calibración a realizar, la cual esta definida de forma predeterminada en OpenNI y es la que se muestra en la figura 4.12 .

Figura 4.11 Algoritmo para calibración de usuario.

Figura 4. 12 Pose "Psi" para llevar a cabo el proceso de calibración [14].

59

La razón de la forma de la pose para calibrar al usuario se debe que a través de la pose se puede tomar una imagen donde se visualicen casi la mayoría de las articulaciones del usuario, o por lo menos la parte superior del cuerpo del usuario. Una vez que se realizó la petición de detección de pose de calibración y el usuario realizó la pose, se genera el evento “Pose detectada”, el cual indica que la pose ha sido detectada, dentro de este evento se debe llamar al siguiente método que indica el diagrama de flujo , “Petición de calibración”, el cual se encargará de realizar la petición para la calibración del usuario, este método recibe como argumento el ID del usuario que se requiera calibrar, antes de llamar a este método de petición de calibración se debe de llamar al método “Detener detección de pose”, ya que si no se hace, el proceso entra en un ciclo infinito porque el evento “Pose detectada” se genera constantemente. El siguiente evento que se genera es “Calibración completa”, evento que se genera cuando se completa la calibración, en este proceso se deben tomar en cuenta algunas consideraciones, el termino de la calibración no significa la correcta calibración de usuario, por ese motivo OpenNI cuenta con una bandera dentro de este evento que indica si la calibración se completo correctamente, a partir del valor de esa bandera se determina el comienzo del seguimiento de usuario y acceso a las coordenadas 3D del mismo, en el caso de que el valor de la bandera sea verdadero se asume la correcta calibración del usuario. El método encargado de comenzar el seguimiento de usuario es “Iniciar seguimiento”, método que de igual forma recibe el numero ID de usuario a seguir, si el valor de la bandera que indica la correcta calibración de usuario es establecido es erróneo, se debe repetir el proceso de calibración a partir de la petición de la detección de pose de calibración, llevándose a cabo este proceso de forma iterativa hasta obtener una correcta calibración del usuario. Los factores que influyen para que la calibración de usuario no se lleve a cabo de forma correcta se deben a una mala imitación de la pose de calibración o a que el usuario deje de realizar la pose de calibración antes de completarse el proceso, normalmente la calibración de usuario es completada de forma correcta en menos de dos segundos. La imagen 4.13 muestra la localización de cada uno de las articulaciones después del proceso de calibración, se puede observar que las coordenadas de localización de los articulaciones se encuentran alineadas con los pixeles de la imagen RGB, entonces surge una nueva pregunta: ¿como alinear las coordenadas de un pixel de la imagen RGB con las coordenadas de profundidad?, el sensor de profundidad entrega coordenadas dentro del plano tridimensional del mundo real( es decir del plano 3D en las superficie que se proyectan los puntos infrarrojo), estas coordenadas se alinean mediante el proceso de calibración.

60

4.3.5 Selección de las articulaciones a utilizar Una vez que se realiza el seguimiento de usuario se puede tener acceso a todos los datos que el sensor entrega para las articulaciones del usuario: coordenadas (x,y,z), y rotación de las articulaciones. En la tabla 4.3 se muestran las articulaciones o puntos seleccionados para trabajar únicamente con el movimiento del brazo derecho del usuario. El motivo de utilizar la extremidad derecha es debido a que la mayoría de personas son diestras, aunque sin ningún problema podría implementarse el control para personas zurdas. La selección de estas articulaciones es relacionada con el algoritmo para calcular los movimientos, lo que permite omitir las articulaciones sobrantes disminuyendo nuestro tiempo de procesamiento por cada trama adquirida del sensor, también se obtiene como ventaja la disminución de la distancia requerida del usuario con referencia al sensor, no necesitamos abarcar la línea de vista del sensor con todo el cuerpo, debido a que no se utilizan articulaciones de la parte inferior del cuerpo como rodillas o pies.

Tabla 4. 3 Puntos utilizados del usuario.

Hombro derecho Cadera derecha Codo derecho Mano derecha Mano izquierda Cuello Cabeza

Figura 4.13 Alineación de las articulaciones adquiridas con imagen RGB.

61

4.3.6 Cálculo de movimientos del brazo del usuario Identificar un usuario y poder realizar un seguimiento 3D de las articulaciones mencionadas contiene grandes ventajas dependiendo la aplicación que se esté desarrollando y dependiendo de los algoritmos que se realicen. El seguimiento de usuario se puede utilizar tanto para la detección de gestos realizados por el cuerpo o para imitar los movimientos que el usuario realiza y reproducirlos en tiempo real.

Para la implementación de nuestro brazo robótico, necesitamos enviar desde la computadora hacía microcontrolador, los datos de actualización de los movimientos de los motores por cada imagen recibida. Para obtener cada movimiento de las articulaciones del brazo del usuario se utiliza cinemática directa, la cual utiliza las coordenadas otorgadas por el sensor y calcula los movimientos del brazo.

Cinemática Directa para cálculo de dos grados de libertad

La 'cinemática' es una rama de la física que estudia las leyes del movimiento (cambios de posición) de los cuerpos, sin tomar en cuenta las causas (fuerzas) que lo producen, limitándose esencialmente, al estudio de la trayectoria en función del tiempo. La aceleración es el ritmo con que cambia su rapidez (módulo de la velocidad). La rapidez y la aceleración son las dos principales cantidades que describen cómo cambia su posición en función del tiempo. La idea principal de utilizar cinemática para los cálculos, es únicamente obtener los ángulos que forman las extremidades del brazo del usuario a partir de las articulaciones tomadas como referencia para el movimiento. La velocidad y aceleración de la trayectoria del brazo dependen de la rapidez con la que el usuario efectúa los movimientos.

Las articulaciones del usuario se pueden describir como un punto dentro de un espacio de coordenadas), el cual puede ser representado por un vector que contiene una posición y una orientación con respecto a un plano. En este caso el plano a considerarse es el plano 3D donde son proyectados los patrones del sensor de profundidad. La posición(x,y,z) de un punto ṕ dentro del plano 3D se puede expresar mediante la ecuación 4.1 .

ṕ= ṕx X + ṕy Y + ṕz Z (Ecuación 4.1)

62

Donde ṕx, ṕy y ṕz denotan los componentes del vector ṕ dentro del plano 3D, a

través de los ejes de referencia. La posición de ṕ puede ser compactada y representada como un vector 3*1, como se muestra en la ecuación 4.2.

0ṕ2ṕ3ṕ45 (Ecuación 4.2)

En la figura 4.14 se representa la posición y orientación de un punto ṕx dentro de un espacio 3D, y se proyecta un vector desde el origen (en este caso es el sensor Kinect) hacia la articulación o punto del cuerpo, se puede observar que la orientación del punto localizado dentro del rango del sensor, esta referenciado con respecto al eje z, que corresponde al eje que se representa la distancia entre el sensor y el usuario.

A1, A2 y A3 representan los ángulos que forma el vector con respecto a cada eje del plano 3D. Los puntos se relacionan con cada movimiento que ejecuta el usuario que a su vez se considera un cuerpo rígido debido a que las demás partes de su cuerpo se pueden mantener estáticas mientras alguna parte en especifica se mueve, que no es lo mismo que el usuario no pueda moverse de lugar dentro del plano 3D al estar controlando el robot. Utilizando este concepto se llegó a la conclusión de implementar cinemática directa para la obtención de los ángulos, esto implica que se debe realizar el cálculo de los movimientos de

Figura 4. 14 Representación de un vector formado por un punto o articulación del usuario dentro del plano del sensor.

63

nuestra estructura (brazo de usuario) para conocer la trayectoria y llegar a un punto desconocido, punto que se conoce normalmente en la mayoría de los brazos manipuladores pero se desconoce la trayectoria, misma que tiene que ser calculada y precargada dentro del robot para que cada grado de libertad ejecute el movimiento correspondiente. En nuestro código de aplicación, el punto final a donde debe llegar el brazo robótico es desconocido para el programa, debido a que el movimiento que realizará el brazo robótico será controlado por el usuario, siendo este quien determine a través de los movimientos, la posición final del brazo.

La cinemática directa es utilizada para determinar los ángulos de movimiento de cada grado de libertad del robot a partir de los movimientos del mismo, en nuestro caso inicialmente el robot no esta en movimiento, ya que no es un robot autónomo, entonces surge aquí la pregunta ¿Cómo se aplica la cinemática directa en el movimiento del brazo robótico?, para aplicar cinemática directa se emplea una analogía entre el brazo del usuario y el brazo robótico, una vez que el usuario lleve a cabo la pose de calibración el programa podrá realizar los cálculos del movimiento del robot, los cuales imitarán a los del usuario, es por eso que el usuario debe realizar el primer movimiento, que determina la posición inicial del robot, y a partir de ella poder conocer la posición de cada articulación del robot y seguir con el movimiento. Para mover una articulación del brazo robótico se toman como referencia tres articulaciones del usuario por cada grado de libertad, las cuales forman vectores, de los cuales se conoce la posición y orientación de cada uno de ellos mediante las coordenadas proporcionadas por el sensor y por lo tanto hacen posible la aplicación de formulas de cinemática directa.

La forma en la que se obtiene el movimiento del brazo del usuario utilizando cinemática directa se explica con siguiente ejemplo: supongamos que el usuario levanta la mano derecha a la altura de su hombro derecho, las coordenadas (x,y,z) de la mano forman un vector, el cual puede tomar como origen cualquier otro punto dentro del plano 3D, en este caso supongamos que el origen es el punto(x,y,z) que corresponde al punto de localización del hombro, la cinemática directa debe aplicarse tomando dos vectores como referencia y partir de ahí poder obtener el ángulo que existe entre ellos, entonces formamos un primer vector desde el hombro hasta la mano, después se debe tomar otro vector como referencia para encontrar el ángulo, el punto que se toma para referenciar el vector faltante es la posición (x,y,z) de la cadera, a partir de ahí se forma el nuevo vector cuyo origen debe ser el mismo que el primer vector para poder encontrar el ángulo que forman, de esta manera podemos deducir del ejemplo que el ángulo formado entre el brazo con la mano extendida y la cadera, es un ángulo de 90

64

grados, de esta misma forma si el usuario levanta la mano, el ángulo será afectado por dicho movimiento generando cambios en la posición de los vectores. En la figura 4.15 se ejemplifica el ángulo formado por dos vectores correspondientes a las articulaciones del usuario, el origen de ambos vectores es el hombro derecho del usuario, posición que puede cambiar pero no afecta el ángulo formado por los vectores si estos no cambian de posición, el único valor que puede afectar el ángulo formado por los vectores es el del codo derecho, debido a que cambia la posición del vector 1 y como consecuencia aumenta o disminuye el ángulo formado con el vector 2.

A partir de este ejemplo, podemos definir las articulaciones que formarán los vectores que darán movimiento al brazo robótico, el cual estará dotado de tres grados de libertad. La imagen 4.16 muestra los vectores que forman los puntos que serán tomados en cuenta para obtener dos vectores por cada grado de libertad y su respectivo ángulo, en la imagen solo se muestran dos ángulos encontrados, debido a que el tercer ángulo es obtenido con otro método que se explicará más adelante. Los puntos o articulaciones elegidos del esqueleto del usuario para formar los vectores de movimiento son: hombro derecho, cadera derecha, codo derecho y mano derecha. El motivo por el cual se eligen estos puntos es debido que la posición del vector que forma cada uno de ellos depende de la posición de otro, si la mano derecha del usuario es levantada,

Figura 4.15 Ángulo formado por dos vectores proyectados en las articulaciones del usuario.

65

automáticamente la posición tanto del codo y de la mano cambian de valor, como consecuencia el ángulo formado por ambos vectores cambia también de valor. Cabe destacar que todos los vectores formados se proyectan en un plano tridimensional, por lo tanto los ángulos calculados siempre cambiarán de referencia dependiendo el eje del plano al que estén orientados, debido a que la obtención del tercer ángulo es únicamente referenciado al eje z, esto impide la rotación del usuario dentro del plano 3D que proyecta el Kinect, lo que implica que el usuario en todo momento debe tener el cuerpo en posición de frente dirigida al sensor, sin poder girar hacia otro eje de referencia.

En la figura 4.16 se observa como se forman dos ángulos con tres vectores, los cuales tienen al hombro como origen, esto implica que el movimiento de los vectores puede desarrollarse dentro de todo el espacio 3D y no solo en un espacio 2D de frente al sensor, debido a que el punto que define el origen(hombro derecho) no cambia de posición mientras la mano o codo derecho si pueden hacerlo, otro punto que tampoco cambiará de posición es la articulación correspondiente a la cadera derecha, por lo cual los únicas articulaciones que influyen en el cambio del valor de ángulo que forman los vectores son los articulaciones correspondientes a la mano derecha y codo derecho.

El siguiente paso es calcular los mencionados ángulos que forman los vectores ya definidos. Las coordenadas proporcionadas por Kinect para el seguimiento de usuario varían acorde a la distancia en la que se encuentre el usuario, tanto para el eje x, y, z, es por eso que el cálculo de los ángulos del movimiento del brazo

Figura 4. 16 Ángulos a calcular para el movimiento del brazo.

66

debe contemplar que estas coordenadas no tendrán siempre un rango fijo de valores y no serán positivas en todos los casos. En la figura 4.17 se muestra la proyección de dos vectores dentro de un plano 3D y la formula definida dentro del cálculo vectorial para obtener el ángulo que se forma entre ambos.

La formula para calcular en ángulo formado por los vectores v y w se define a continuación:

�=cos-1 ⦁7│││7│ (Ecuación 4.3)

La ecuación corresponde al coseno inverso del producto punto de los vectores V y W, dividido entre el producto del modulo de ambos vectores. El valor de este ángulo es obtenido computacionalmente en radianes, por lo que se debe aplicar otra formula que permita generar el valor obtenido en grados. Esta formula es aplicada directamente en nuestro algoritmo para obtener los ángulos de movimientos formados por nuestros tres vectores ya establecidos, pero surge un nuevo problema: la formula es utilizada en vectores que son proyectados desde el origen hacia un punto p, retomando la figura 4.17 nuestros vectores dibujados dentro del esqueleto del usuario tienen como origen al hombro derecho del usuario, sin embargo el origen de referencia de las coordenadas que se adquieren esta determinado por la posición del Kinect debido a las coordenadas entregadas por el sensor tienen como origen al mismo, significa que los vectores no se encuentran proyectados desde el origen. La formula que resuelve este problema, es la traslación de vectores al origen, la cual se puede representar en la figura 4.18.

Figura 4. 17 Ángulo formado por dos vectores en un espacio tridimensional.

67

Como podemos observar, solo necesitamos realizar la resta de los vectores que se proyecten del origen hacia los puntos extremos del vector que necesitemos trasladar, en nuestra aplicación conocemos los puntos que forman cada uno de los vectores, además de que podemos proyectar vectores desde el origen hacia el punto que forma nuestro vector deseado, por lo tanto es posible realizar la traslación de los vectores que deseemos, hacia el origen.

A partir de este procedimiento podemos aplicar la ecuación 4.3 y podemos calcular nuestros dos primeros ángulos que determinan dos de los tres grados de libertad del robot, el algoritmo para implementar las formulas anteriores y obtener en grados el respectivo ángulo, se explica en la figura 4.19y se implementa en el anexo 4.6.

Figura 4. 18 Traslación de un vector hacia el origen.

Figura 4. 19 Cálculo de ángulo entre dos vectores.

68

Antes de poder aplicar este algoritmo es necesario trasladar los vectores que se ocupen hacia el origen, en nuestro caso los vectores a ocupar se definen en la tabla 4.4 .

Tabla 4. 4 Vectores utilizados para el cálculo de los ángulos.

Nombre Punto de origen Punto destino Vector 1 Hombro derecho Cadera derecha Vector 2 Hombro derecho Codo derecho Vector 3 Codo derecho Mano derecha Vector 4 Codo derecho Hombro derecho

A partir de esta tabla se deduce que se necesita realizar la traslación de cuatro vectores hacia el origen, entonces se aplica la formula que traslada un vector a partir de dos vectores que se proyecten del origen al destino, en nuestra aplicación no todos los vectores se trasladan de la misma manera debido a que el ángulo tomado como referencia para cada uno de ellos se toma con referencia a distinto vector, las traslaciones que se debe realizar son las siguientes:

• Vector 1: vector del origen a la cadera derecha - vector del origen al hombro derecho.

• Vector2: vector del origen al codo derecho - vector del origen al hombro derecho.

• Vector 3: vector del origen a la mano derecha - vector del origen al codo derecho.

• Vector 4: vector del origen al hombro derecho - vector del origen al codo derecho.

Como se puede observar en dos vectores se utilizaron los mismos puntos, pero la traslación se hizo de diferente forma para cada uno de ellos, esto se debe a que el ángulo que se forma para los cuatro vectores toma a un eje distinto como referencia, el primer ángulo toma como referencia al eje formado por la cadera y hombro derecho, mientras que el segundo toma el eje formado por el hombro derecho y el codo derecho, esto implica que en el primer ángulo el origen sea el hombro, mientras que el segundo tenga como origen al codo derecho, es por eso que se tienen que trasladar de diferente manera para poder utilizarlos. Con estos datos podemos implementar la función del algoritmo de la figura 4.19 y poder obtener los movimientos de dos grados de libertad de nuestro brazo.

69

Obtención del tercer grado de libertad utilizando una

matriz rotacional

El último ángulo de movimiento del brazo de usuario es definido por la rotación del hombro derecho del usuario, movimiento que se define también en grados, desafortunadamente OpenNI no entrega el resultado de esta rotación en grados, la forma en la que se estructuran estos datos es dentro de una matriz de rotación.

Los ángulos Euler representan la rotación de un cuerpo en movimiento con referencia a un sistema de coordenadas. En la figura 4.20 se muestra un ejemplo de los ángulos que forma un cuerpo en movimiento con respecto a otro sistema de referencia dentro de un plano tridimensional.

Los grados Euler pueden ser representados por una matriz de rotación 3*3 que contiene la rotación de un marco de referencia fija, con respecto a otro marco de referencia en movimiento, esto se puede explicar en la figura 4.21 ,en donde se tiene un plano fijo denotado por los ejes X1,Y1,Z1, y otro X0,Y0,Z0 que contiene un ángulo de rotación � con respecto al primero, este desplazamiento solo interviene en los ejes X y Y, es decir: si proyectamos un vector dentro del espacio X0,Y0,Z0, este vector tendrá el mismo componente tanto en Z0, como en Z1. Para poder representar un vector del plano X0,Y0.Z0 se utiliza una proyección de vectores denominada proyección ortogonal, la cual se representa con las matrices de las ecuaciones 4.4, 4.5 y 4.6 para cada eje de rotación.

Figura 4.20 Ángulos que forma la rotación de un cuerpo en un sistema de coordenadas con respecto a otro [17].

70

Rx(�)=[1 0 00 ;,/� </=>�0 /=>� ;,/� ] (Ecuación 4.4)

Ry(�)=[ ;,/� 0 /=>�0 1 0</=>� 0 ;,/�] (Ecuación 4.5)

Rz(�)=[;,/� </=>� 0/=>� ;,/� 00 0 1] (Ecuación 4.6)

Donde Rx(�), Ry(�) y Rz(�), representan la proyección de la rotación del ángulo � con respecto a cada eje, es decir en RX(�) se utiliza al eje x como pivote para la rotación de los otros planos, de igual forma se utiliza el eje y para RY(�)y el eje Z para RZ(�). Estas tres proyecciones permiten describir un cuerpo que rota en tres ángulos sobre el eje X,Y y Z respectivamente. Para obtener la rotación de los tres ángulos tenemos que multiplicarlos en determinado orden dependiendo la aplicación en la que se vayan a utilizar. Para este trabajo se necesita obtener el ángulo de rotación alrededor del eje z, del hombro derecho , utilizando como referencia el plano de la figura 4.21 ,debido a que OpenNI entrega la rotación de una articulación con respecto a la posición T del usuario la cual se define en la figura 4.22, la rotación de una articulación esta en base a esta pose, en la imagen de la figura 4.23 se muestra que al mover el brazo fuera del sistema de referencia se obtiene una rotación del punto ubicado en la articulación, el cual corresponde a la articulación del hombro derecho.

Figura 4. 21 Sistema de rotación de un cuerpo con referencia a un plano.

71

El algoritmo para calcular los tres ángulos de rotación de una articulación se define por la multiplicación de las tres matrices RX(�), RY(�) y RZ(�), en donde se obtiene una tercer matriz, que es la matriz proporcionada por las librerías de OpenNI. La siguiente matriz muestra el resultado final de multiplicar las tres matrices de rotación.

[-00 -01 -02-10 -11 -12-20 -21 -22]= [ @A@B C DEDADB @BDEDA < @ADB @EDA@EDB @E@B <DE<@BDA C @ADEDB @A@BDE C DADB @E@A](Ecuación 4.7)

En donde:

Cx=cos�x (Ecuación 4.8)

Cy=cos�y (Ecuación 4.9)

Cz=cos�z (Ecuación 4.10)

Sx=sen�x (Ecuación 4.11)

Sy=sen�y (Ecuación 4.12)

Sz=sen�z (Ecuación 4.13)

Esta matriz describe la rotación de los tres ángulos de la articulación denotados por valores flotantes, para obtener el valor en radianes de estos ángulos de rotación se toman en cuenta tres casos:

Figura 4. 22 Pose T que es el sistema de referencia para la rotación de una articulación [13].

Figura 4. 23 Sistema de referencia para la rotación del hombro derecho.

72

1. Si �y pertenece a (-I� , I�) entonces cy ≠0, cy(sx,cx)=(-r12,r22), por lo tanto

los ángulos de rotación se obtienen de la siguiente manera:

�y = asin(r02), �x = atan2(-r12, r22), �z = atan2(-r01, r00) (Ecuación 4.14)

2. Si �y= I�, entonces sy=1 y cy=0, en este caso la obtención de ángulos es:

�y = I�, �z + �x = atan2(r10, r11) (Ecuación 4.15)

3. En el caso de que �y=< I� entones sy=-1 y cy=0, para estas condiciones los

ángulos se obtienen: �y = -I� , �z -�x = atan2(r10, r11) (Ecuación 4.16)

El algoritmo de la figura 4.24 implementa las condiciones de la factorización de la matriz de rotación entregada por cada articulación del esqueleto, en donde se determina un ángulo por cada eje de rotación, tomando en cuenta el plano de la posición t del usuario, el resultado es entregado en grados, el código esta disponible en el anexo 4.7.

Figura 4. 24 Algoritmos para obtener el ángulo de rotación de una articulación.

73

4.3.7 Detección de gesto de finalización

A partir de la calibración de usuario se establece el inicio del movimiento del brazo robótico, pero el seguimiento de usuario y la obtención de los ángulos de movimientos del brazo son calculados de forma continua hasta que se le indique al sensor que deje de generar las imágenes de profundidad, es por eso que se incluye dentro de la adquisición de datos un gesto hecho por la mano izquierda del usuario para finalizar la aplicación y por lo tanto detener el movimiento del robot.

Las librerías OpenNI ofrecen la detección de gestos realizados por cualquiera de las dos manos de un usuario detectado. Estos gestos pueden ser realizados antes o después de la calibración del usuario, los gestos incluidos dentro de estas librerías para ser detectados son:

• saludo: realizar un movimiento similar al de un saludo con una de las dos manos.

• click: extender la mano del usuario con referencia al sensor Kinect y después regresarla al primer lugar donde estaba antes del movimiento.

• circulo: mover la mano en forma circular hacia cualquier lado.

De estos tres gestos proveídos por OpenNI, elegí el gesto de saludo debido a que su movimiento no requiere extender demasiado los brazos, basta con simular un saludo típico de “hola” con la mano para que el gesto sea detectado. La detección del gesto basa su funcionamiento en eventos que se generan en las librerías de OpenNI, cuyo diagrama de flujo de los procesos que lleva la detección del gesto se muestra en la figura 4.25. El inicio marca un movimiento de la mano que puede propiciar que el usuario realice el gesto indicado al sensor, después de que efectivamente el usuario lleva acabo el gesto se genera el evento, en donde se realiza un seguimiento de la mano y se puede acceder o no a las coordenadas (x,y,z) de la mano que realizó el gesto, si el seguimiento de la mano es perdido por el sensor de profundidad, se genera un nuevo evento, el cual realiza una petición para la nueva detección del gesto, a partir de entonces el usuario tendrá que realizar nuevamente el gesto.

74

Figura 4. 25 Diagrama de flujo para la detección de gestos con OpenNI.

75

4.3.8 Detección de dedos para apertura y cierre de la pinza La idea de poder controlar el brazo robótico a través del Kinect es no tener que utilizar algún tipo de interfaz de usuario como: botones, palancas, mouse, etc., es por eso que todo el control del movimiento del brazo, incluyendo el cierre y apertura de la pinza, debe ser controlado por los movimientos del brazo del usuario.

Desafortunadamente dentro de las articulaciones o puntos de los cuales el sensor Kinect realiza un seguimiento en un plano 3D, no se encuentran articulaciones de los dedos, el punto más cercano a estos es la mano, es por eso que para permitir un control de la pinza que se efectúe a través de la apertura o cierre de la mano del usuario se necesitó utilizar otra librería que no esta incluida en las librerías de OpenNI, esta librería es denominada “EmguCV”, la cual contiene herramientas que facilitan algoritmos y procesos utilizados en visión por computadora. EmguCV es un conjunto de librerías para programación en lenguaje C# que implementa todas las funciones y algoritmos utilizados en el paquete de librerías de visión por computadora denominado “OpenCV”. Estas librerías de visión por computadora son utilizadas en este proyecto debido a que facilitan la implementación de distintos algoritmos de visión por computadora, además de que aceleran el procesamiento de imágenes debido a que utilizan memoria del sistema que ayuda a procesar las imágenes de forma más rápida. EmguCV cuenta también con ejemplos que utilizan imágenes de profundidad o imágenes a color como las que entrega el Kinect, es por eso que se proyectan como la mejor opción para tratar las imágenes del sensor para esta aplicación.

Como ya se mencionó, Kinect no puede entregar de ninguna manera un seguimiento en el plano 3D de las articulaciones que forman los dedos de la mano del usuario, ahí surgió un problema para el desarrollo de este proyecto. Realizando investigación acerca del tratamiento de imágenes de profundidad y a color a través de Kinect, se encontraron dos posibles soluciones para la detección de la apertura y cierre de la mano de un usuario a partir del análisis y tratamiento de imágenes en dos dimensiones mediante el sensor Kinect. La primera fue aplicar un algoritmo de detección de piel en una imagen a color RGB y a partir de las formas detectadas aplicar otros algoritmos que identifican la forma de una mano. La segunda opción fue realizar un filtrado de los pixeles que contemplen un rango de la mano dentro de la imagen de profundidad del sensor Microsoft Kinect, y posteriormente aplicar el mismo algoritmo de detección de una mano que se aplica en imágenes a color. Para este proyecto se descartó utilizar un algoritmo

76

que segmentara una imagen a color para formar una imagen de la mano del usuario a partir de la detección del color de la piel utilizando la cámara RGB del Kinect, debido a que no todas las personas presentan el mismo tono de piel, además de que las imágenes RGB capturadas por el sensor pueden llegar a capturar otros colores de objetos que se confundan con el color de la piel del usuario. El objetivo de utilizar el sensor Kinect es aprovechar al máximo los recursos que ofrece, por lo tanto el algoritmo implementado para la detección del gesto que implica la apertura o cierre de una mano del usuario se basa en la extracción de una imagen de profundidad del recuadro que cubre únicamente la mano izquierda del usuario.

El procedimiento de detección del gesto de apertura o cierre de la pinza se describe a continuación:

• Extracción de imagen de profundidad basándose únicamente en la región de interés que corresponde a la mano izquierda del usuario

El algoritmo que implementa la detección del gesto con la mano requiere únicamente trabajar la región de la imagen de profundidad que contemple el área de la mano del usuario. Desafortunadamente ni el sensor Kinect ni las librerías de OpenNI entregan o permiten saber que pixeles corresponden a la mano del usuario, el mapa de profundidad solo contiene valores que indican la distancia del usuario u objetos y como dato extra informan si el pixel corresponde a la imagen del usuario o no, pero no especifican la correspondencia de ese pixel a una parte especifica del cuerpo del usuario como las manos. La forma propuesta en esta tesis para obtener dicha región de interés que pueda comprender el área de la mano del usuario es la siguiente: tomando como referencia que aproximadamente la distancia entre la cabeza y el cuello de un usuario puede ser la distancia del lado de un cuadrado que contemple el área de la mano del usuario, entonces se establece dicha medida como el lado del cuadrado del área de la mano. La figura 4.26 muestra las medidas que se proponen para obtener una región de interés que abarque el área de la mano izquierda del usuario.

Figura 4. 26 Distancia de la cabeza al cuello, similar a la distancia de lo largo de la mano.

77

En la figura 4.26 se muestra que aproximadamente la distancia de la cabeza al cuello del usuario (distancia de A hacia B ), es aproximadamente la distancia del largo de la mano(distancia de C hacia D ), a partir de esa medida se propone un cuadrado que tenga esas medidas en un lado para formar el área de la mano del usuario, a partir de estas medidas surge una nueva pregunta: ¿Cómo se obtiene la región de interés de la mano dentro de una imagen a partir de las medidas establecidas?, el sensor Kinect entrega las coordenadas de las articulaciones del usuario en mm, lo que implica que se puede obtener la distancia entres dos articulaciones en mm, dicha unidad de medida no serviría de mucho en imágenes que son procesadas por algoritmos de computadora, debido a que el rango de magnitud para una imagen es de 640*480 pixeles, a diferencia del rango del sensor que entrega datos de hasta 10000mm valores que pueden ser positivos y negativos, implementar un algoritmo que convierta estas coordenadas del mundo real, al mundo de los pixeles, puede llegar a ser complicado y como se mencionó anteriormente, afectaría en el tiempo de procesamiento, afortunadamente OpenNI contiene una función dentro de sus librerías que convierte las coordenadas del mundo real entregadas por el Kinect, a coordenadas proyectables en un sistema de referencia como un monitor, es decir: coordenadas de rango de 0 a 640 para el eje X, y de 0 a 480 para el eje Y. A partir de esta función se mide la distancia en pixeles entre la cabeza del usuario y su cuello. Aplicando la ecuación 4.8 se determina la distancia entre dos puntos dentro de un plano 2D que corresponde al plano de la imagen de profundidad que entrega el Kinect.

KLM = N(X2 < X1)2 C (Y2 < Y1)2 (Ecuación 4.17)

Esta distancia corresponde a la distancia entre la cabeza y el cuello del usuario, sobre coordenadas proyectables, obteniendo esta distancia podemos capturar un cuadro que corresponda a el área que abarca la mano del usuario. Para determinar el centro de ese cuadro que será nuestra región de interés, se toman las coordenadas que Kinect proporciona de la mano derecha, es decir, las coordenadas (x,y) de la mano izquierda del usuario se convierten a coordenadas proyectables para nuestra imagen y por lo tanto determinan el centro de nuestra región de interés. En la figura 4.27 se muestra la región que se obtiene en base a la medida tomada de la cabeza al cuello del usuario.

Figura 4. 27 Región de interés (amarillo) de la imagen de profundidad.

78

• Filtrado de pixeles correspondientes únicamente a la forma de la mano del usuario

Aplicar el procedimiento para obtener un área que es referente a nuestra región de interés, solo permite enfocar nuestro análisis en una cierta parte de la imagen de profundidad, pero todavía no se obtiene la imagen en 2D correspondiente a la forma de la mano. Para realizar este proceso es necesario hacer un filtrado de los pixeles correspondientes a la forma de la mano, como ya se ha dicho nuestro algoritmo se basa en la imagen de profundidad, a partir de esta imagen, se seleccionarán únicamente los pixeles que se encuentren dentro de un rango que abarquen el grosor de una mano sobre el eje z, es decir los valores de profundidad mayores a la localización de la mano izquierda sobre el eje z serán descartados, y también los que se encuentren menor a ese rango, la figura 4.28 muestra como se lleva a cabo el proceso de filtrado para descartar los pixeles y obtener únicamente los correspondientes a la mano izquierda del usuario.

Una vez completado este proceso se obtiene una figura dentro de nuestra imagen parecida a la forma de una mano, cabe destacar que esta imagen es analizada en un plano en dos dimensiones, por lo que carece de todas las ventajas que se tienen al trabajar con imágenes 3D, ventajas que tienen los datos entregados por el sensor. El algoritmo de filtrado únicamente coloca el valor de los pixeles que se encuentren dentro del rango del ancho de una mano en 255, y los pixeles que se encuentren fuera de ese rango sobre el eje z, son colocados en 0, permitiendo mantener únicamente los pixeles que dan forma a la mano del usuario. Debido a que la región de interés es calculada de forma propuesta y con un tamaño no exacto, la imagen resultante del proceso de filtración puede no corresponder a la imagen de solo la mano, y tomar también una parte del brazo dentro de esta

Figura 4. 28 Pixeles que serán tomados en cuenta para la forma de la imagen.

79

forma, hecho que afecta de forma mínima en el algoritmo de detección de apertura o cierre de la mano.

• Procedimiento para detectar formas convexas dentro de la nueva imagen, lo que es similar a la forma de los dedos

Una vez que se tiene una imagen en escala de grises, debido a que se trabaja con imágenes de profundidad, se requiere encontrar todas aquellas formas que puedan parecerse a la forma de un dedo, en ésta parte es donde se implementan las librerías de código abierto de algoritmos de visión por computadora denominado EmguCV. EmguCV contiene librerías que implementan algoritmos sobre imágenes que se encuentren en el espacio RGB ó en escala de grises, además aceleran la velocidad de procesamiento de las imágenes, factor que es vital para esta aplicación.

Una figura convexa se define de la siguiente manera:

Si para cada par de puntos de C, el segmento que los une está totalmente incluido en C, es decir, un conjunto es convexo si se puede ir de cualquier punto a cualquier otro en línea recta, sin salir del mismo.

La figura 4.29 muestra el ejemplo de una figura convexa

Como se puede observar, dentro de la figura 4.29 X, los puntos denotados desde A hasta B, se encuentran unidos por una línea recta hacia otro punto que pertenece al conjunto, por ejemplo: el punto A, al punto B, el C al D, etc, en ningún caso, la línea que los une sale del área de la figura, es por eso que se define como figura convexa, caso contrario de la figura 4.29 Y, en la cual algunas líneas trazadas dentro de sus puntos , salen del área de la figura.

Figura 4. 29 Figura 49 Forma convexa X, y forma no convexa Y

80

Establecido este concepto procedemos a aplicar una función de EmguCV que aplica un algoritmo que encuentra las formas convexas de nuestra imagen, la cual antes fue procesada en los anteriores algoritmos, esta función de la librería de EmguCV es denominada “Obtener defectos convexos”, la cual se encarga de detectar las formas convexas de una figura que se encuentre dentro de nuestra imagen, y entregar las coordenadas x,y de los siguientes puntos:

� Inicio de la figura convexa. � Profundidad de la figura convexa

Apoyándonos de este algoritmo podemos encontrar las puntas de todos los dedos de la mano, y de otras partes de la mano que el algoritmo considera convexos, aunque no se traten de formas que pertenecen a la de un dedo, estas partes serán descartadas en el proceso que se explicará mas adelante. Una vez que se encontraron todos esos puntos, se guarda la ubicación (x,y) de todas las formas convexas, para poder implementar el procedimiento final.

• Identificar cuando el usuario abre o cierra la mano

Par poder abrir o cerrar la pinza del brazo robótico, es necesario detectar cuando un usuario abre o cierra la mano. Los procesos explicados anteriormente permiten tener la ubicación de puntos que puedan pertenecer a la forma de los dedos de la mano, a partir de esos datos, se implementa un procedimiento para conocer si el usuario esta abriendo o cerrando la mano. Este procedimiento consiste en obtener mediante el método “Obtener la mínima área” de EmguCV, que cubre la figura de la imagen, en nuestro caso la forma de la mano, esta función devuelve un rectángulo que cubre al área comprendida por la figura encontrada dentro de la imagen a la que se le aplica esta función. En la figura 4.30(a) se dibuja este rectángulo que marca el área que cubre la figura encontrada. El siguiente paso es dibujar otro rectángulo que abarque la mitad del rectángulo encontrado anteriormente, con el objetivo de trazar el rectángulo a un área que aproximadamente sea el área que cubre la palma de la mano, en la figura 4.30(b) se muestra el polígono.

(a)

(b)

Figura 4. 30 (a) Rectángulo que cubre el área.

(b)Rectángulo que cubre la mitad del área de la figura.

81

Una vez que tenemos trazadas estas figuras dentro de nuestra imagen, el siguiente paso es aplicar las condiciones de nuestro algoritmo que permiten detectar el número de dedos que el usuario extiende con la mano izquierda, estas condiciones se basan también en la medición de distancia entre el centro de la palma la cual se puede obtener mediante la ubicación (x,y) del sensor, y la punta de los dedos de la mano que como ya se mencionó, se puede también obtener. La condición para realizar el conteo del número de dedos es la siguiente: si la distancia del centro de la mano a la punta de los dedos es mayor a la distancia del centro de la mano a la frontera del rectángulo que abarca la mitad del área de la figura, se considera que el usuario a extendido el dedo, en caso contrario se considera como si el dedo estuviese doblado. A partir de esta condición se hace un análisis de todas las formas convexas encontradas y se realiza un conteo de aquellas que cumplan la condición, sin embargo también se establece otra condición: las coordenadas (x,y), de las puntas de los dedos deben de ser menores que la frontera del rectángulo que cubre el área debido a que se considera que el usuario siempre mantiene la mano con los dedos en dirección hacia arriba, en el proceso de encontrar formas convexas, la forma de la imagen que es analizada puede tener formas convexas que no correspondan a los dedos, denominado también como ruido, es por eso que mediante esta condición se evitan errores de ese tipo. El procedimiento de detección de dedos no es del todo preciso porque puede detectar formas en la imagen y clasificarlas como dedos aunque no lo sean, o puede verse afectado por la distancia en la que se encuentra el usuario con respecto al sensor, lo cual causa que la región de interés sea muy pequeña dentro de la imagen de 640*480 pixeles y el algoritmo no obtenga de forma correcta las formas de las imágenes. Para determinar si el usuario cerró o abrió la mano, simplemente se hace un intervalo en el conteo de los dedos extendidos detectados, si el contador indica que se extendieron 4 o 5 dedos, se considera la mano abierta debido a que el dedo pulgar es difícil de detectar dentro de este algoritmo. Si el contador indica 1 ó 0 número de dedos, se contempla que el usuario ha cerrado la mano, de esas dos formas se detecta el movimiento realizado por el usuario que contribuye al cierre o la apertura de la pinza. El código del procedimiento para detectar la apertura o cierre de la mano se implementa en el anexo 4.8.

82

4.3.9 Interfaz gráfica de usuario

Como se mencionó anteriormente, la interfaz gráfica de usuario debe desplegar la imagen a color y la imagen de profundidad del sensor, con el objetivo de que el usuario pueda observar sus movimientos y saber que movimientos está realizando sobre el robot. Además de las imágenes que obtiene el sensor, la interfaz despliega los ángulos que se envían hacía el microcontrolador y despliega cuando un usuario es o no detectado. Debido a que el brazo robótico es iniciado, controlado y finalizado por los movimientos del usuario, el único botón de la interfaz gráfica es el botón que se encarga de inicializar (encender) el sensor Kinect , e iniciar la captura y procesamiento de los datos adquiridos por el sensor, es decir el movimiento del robot inicia hasta que el usuario realiza la pose de calibración, pero los datos del sensor se procesan desde que es oprimido el botón de iniciar. En la figura 4.31 se muestra la imagen la interfaz gráfica de usuario de la aplicación, así como los controles que se encuentran dentro de ella y apoyan al usuario en el control del robot.

Imagen de profundidad y color.

Valor de

ángulos

del robot.

Detección

de usuario.

Imagen de la mano que controla la pinza.

Figura 4. 31 Interfaz gráfica de usuario de la aplicación.

83

4.4 Programación del microcontrolador PIC18F4550 El microcontrolador PIC18F4550 es el dispositivo de procesamiento encargado de generar la señal para los servomotores que conforman el brazo robótico, el PIC18f4550 debe generar la señal de los servomotores en tiempo real, es decir que los motores se muevan al mismo tiempo, el motivo de generar la señal al mismo tiempo se debe a que cuando se genera una señal para cada motor de forma serial moviendo motor por motor, el movimiento del robot es lento en comparación de mover todos los motores en forma paralela, además de que los motores pueden perder el torque cuando se deja de generar la señal. Otro punto importante es que la velocidad de los motores forma parte del proceso que determina la velocidad de nuestro sistema y la respuesta dentro de los tiempos establecidos para considerarse como un sistema en tiempo real.

Retomando las especificaciones del microcontrolador utilizado, una de las herramientas del microcontrolador son los “Temporizadores” también conocidos como “Timers”, los cuales serán utilizados para generar la modulación por ancho de pulso (PWM), de los motores del brazo robótico.

La transmisión universal serial síncrona y asíncrona (USART), será utilizada para la recepción de datos desde la computadora a través del modulo serial bluetooth. Otras características incluidas dentro de la programación del PIC son la utilización de puertos para enviar la señal a cada servomotor.

Para poder programar las tareas dentro del PIC y poder asignar los tiempos que sean necesarios para realizarlas en tiempo simultáneo, se deben enumerar las prioridades de cada tarea, definiendo cual es más importante para nuestro sistema y cuales carecen de menor importancia. En la tabla 10 se enumeran las tablas de acuerdo a la prioridad y duración. Como se puede observar, las principales prioridades del sistema, son la generación de pulsos para los motores, el tiempo que duran estas tareas varia de acuerdo a los grados que deba moverse cada motor, es por eso que el tiempo de duración puede variar, sin embargo estas tareas son prioritarias para el sistema, debido a que si se deja de generar el pulso para cualquier motor, éste perderá el torque, ocasionando tal vez un error en el sistema, por ejemplo: supongamos que el motor que genera el segundo grado de libertad pierde el torque, entonces la fuerza de gravedad ocasiona que el eslabón que pertenece al motor que une ese eslabón, ejerza una fuerza hacia abajo provocando la inestabilidad o movimiento erróneo del brazo.

84

Tabla 4. 5 Prioridades del sistema en tiempo real.

Tarea Prioridad Duración Motor 1 ( 1 gdl) 1 Ciclo de trabajo Motor 2 (2 gdl) 1 Ciclo de trabajo Motor 3 (3 gdl) 1 Ciclo de trabajo Motor 4( pinza ) 1 Ciclo de trabajo Recepción UART 2 2.5 us

Dentro de la prioridad número 2, se encuentra la tarea que se encarga de recibir el paquete de datos a través de la comunicación serial ,el cual genera el movimiento para el brazo, a esta tarea se le asigna una segunda prioridad debido a que el sistema debe recibir los datos que contienen los ángulos que debe moverse cada motor, sin embargo aunque uno de estos paquetes que contiene cuatro valores correspondientes a los tres grados de libertad y al movimiento de la pinza, no llegase a ser leído, no afectaría de forma directa al sistema, debido a que el programa guarda los valores anteriores, los cuales son generados a través del PWM del motor correspondiente, cuyo torque debe de generarse de manera constante.

Una vez establecidas estas prioridades, se realizó la programación del microcontrolador PIC18F4550, la cual se basa en el diagrama de flujo mostrado en la figura 4.32, en este diagrama se establecen los pasos para la configuración de las funciones del PIC, el primer paso para iniciar el programa es la configuración de puertos de entrada y/o salida, en el presente proyecto se utilizan los puertos B0-B3 para la generación del PWM de los motores, por lo tanto estos bits son establecidos como salida. En el segundo proceso se establece la configuración de la transmisión serial asíncrona, en donde se configura el puerto TX como salida y RX como entrada, cabe destacar que en este proyecto, el PIC solo recibirá datos, sin embargo para la configuración de la comunicación serial del PIC deben establecerse estos dos pines con la configuración adecuada, además debe establecerse en 1, la bandera de interrupción de la recepción de datos, la cual recibe byte por byte ,el dato que sea enviado desde la computadora al PIC. El siguiente proceso consiste en la configuración del timer2, cuya interrupción genera el tiempo de 0.00001 segundos el cual corresponde al ciclo en alto de duración para que el servomotor se pueda mover un grado, a partir de ese concepto se moverán los demás motores. Después de establecer la configuración de los temporizadores y del UART(transmisión serial síncrona), el siguiente proceso es establecer un ciclo infinito dentro del programa, cuyo objetivo es permitir que las interrupciones tanto del TIMER como del UART se generen y realicen las

85

correspondientes tareas. Este ciclo llega a su fin solo si es recibido el dato proveniente de la computadora, que pertenece al gesto de finalización del brazo robótico, cuyo valor indica que el brazo debe detenerse, por lo cual se inicia un contador, el cual segura que todos los motores llegarán al estado final, es decir al movimiento de finalización, para después establecer al microcontrolador en un estado de bajo consumo conocido como “estado en reposo”. En dado caso de que no se estableciera un contador que permita a los motores llegar a su estado final y en vez de eso se mande al microcontrolador al estado en reposo después de recibir el dato de finalización, los motores perderán el torque inmediatamente, y no podrán llegar al estado final, lo que implica que el brazo pierda la fuerza en todas sus articulaciones. Cuando el contador llega al número establecido para llegar a la posición final, el microcontrolador llega al estado en reposo y por lo tanto la aplicación finaliza.

Figura 4.32 Diagrama de flujo de la programación del PIC18F4550.

86

En la figura 4.33(anexo 4.9) se muestra el diagrama de flujo establecido para la interrupción que se genera para la recepción de datos del modulo UART, la cual se genera cada que un byte es recibido dentro del modulo RX, en este diagrama de flujo se establece una variable que inicia en 0, cuando un dato es recibido, se asigna el dato que es recibido a la variable que guarda los grados que debe moverse el primer motor, que corresponde al primer grado de libertad, después de esto la variable se incrementa y se borra la bandera correspondiente a la interrupción de recepción, cuando esta se vuelve a generar, el valor del modulo de recepción se asigna a la variable que indica los grados de movimiento del segundo motor correspondiente al segundo grado de libertad y se incrementa la variable, este proceso se genera de forma sucesiva hasta llegar a la asignación de la cuarta variable, cuyo valor corresponde a la apertura o cierre de la pinza, una vez incrementada la variable contador hasta este valor ,la variable se reinicia en cero para volver a recibir los siguientes cuatro datos. La recepción de estos datos se realiza de forma muy rápida, debido a que los datos provenientes de la computadora son enviados uno tras de otro, sin espera ningún tiempo, lo que acelera la asignación de valores a las variables de movimiento de los motores.

Figura 4. 33 Diagrama de flujo de la interrupción generada por la recepción de datos a través del modulo UART.

87

Dentro de la figura 4.34 (anexo 4.10) se visualiza el diagrama de flujo correspondiente a la interrupción del TIMER2, el cual genera una interrupción cada 0.00001 segundos. Retomando la especificación de movimiento de un servomotor, este debe generar un tiempo en alto mínimo de 0.0006 segundos para un movimiento de 0 grados, y un tiempo máximo en alto de 0.0024 segundos lo que corresponde a 180 grados, generando después un tiempo de 0.018 segundos para el tiempo en bajo lo cual completa el periodo de la señal de un servomotor, sin embargo para que un servomotor pueda moverse los grados deseados, se deben enviar mínimo 30 periodos iguales correspondientes a los grados de movimiento. Retomando el diagrama de flujo, las condiciones para generar el PWM de los cuatro motores al mismo tiempo es la siguiente: se establecen todos los pines de los motores en estado alto desde la configuración de los puertos, se declara una variable contador2, la cual inicia en inicia en 0, y en cada interrupción esta variable incrementa en uno su valor y es comparada con las variables que contienen los grados que se moverá cada servomotor, cuyos valores de cada variable fueron asignados en la rutina de interrupción de recepción del UART, cuando la variable contador2 es igual al valor de uno de los valores de las variables de los motores, el pin correspondiente a esa señal se establece en cero, iniciando su ciclo en bajo. Por ejemplo: supongamos que dentro de la subrutina de recepción del UART se le asignó a la variable servo1 el valor de 90, esto implica que ese servomotor debe de moverse a la posición de 90, entonces quiere decir que la variable contador2, debe ser incrementada 90 mas 60 veces, el motivo de agregar el número 60 es porque como se había establecido dentro del marco teórico, los servomotores estándar necesitan un tiempo mínimo de 0.0006 segundos en alto, lo que corresponde a 0 grados, en nuestro ejemplo para mover el servomotor a 90 grados necesitamos generar un tiempo en alto de 0.0015 segundos , lo que corresponde a incrementar la variable contador2, 150 veces, es por eso que el tiempo de 0.0006 segundos debe ser obligatorio para todos los servos, independientemente de los grados a los que se vayan a posicionar. El proceso de preguntar si cualquiera de las cuatro variables que contienen los datos de movimiento de los servos, son iguales a la variable contador2, es el proceso de terminar el ciclo en alto de los motores, a partir de entonces se inicia el estado en bajo. Para completar el periodo de un servomotor se debe de establecer un tiempo en bajo desde los 0.015 hasta los 0.020 segundos, debido a eso, una vez que se ha comparado la variable contador2 con los valores de movimiento de los cuatro servomotores , se espera a que el valor de esa variable sea igual a 1800, lo que implica un transcurso de 0.018 segundos, que es el tiempo en el que todos los

88

pines de los motores estuvieron en estado bajo, y entonces se inicia un nuevo periodo, estableciendo de nueva cuenta los pines de los motores en estado alto, y estableciendo la variable contador2 nuevamente con un valor de 0.

Figura 4. 34 Diagrama de flujo de la rutina de interrupción del temporizador 2(Timer2).

89

En la figura 4.35 se muestra el período correspondiente a cada señal, la cual se marca de diferente color, en este ejemplo el motor 1 se mueve 0 grados, el dos 45, el tres 90, y el cuarto 180, lo que corresponde a los tiempos en alto con duración .000105s, 00150s, 0.00195s, 0.00240s respectivamente para cada motor. Como se mencionó anteriormente, el ciclo en bajo es el mismo para todos, es decir 0.018 segundos, lo cual no afecta de ninguna manera en el movimiento de cada motor.

Figura 4.35 Ciclo de trabajo para movimiento de servomotores en 0 grados (amarillo) ,45 grados (azul) ,90 grados (morado) y 180 grados(verde).

90

Capítulo 5 Pruebas y resultados

En el presente capítulo se explica el diseño mecánico y funcionamiento del brazo robótico, además se presentan las pruebas finales realizadas para explicar el funcionamiento del manipulador y obtener la eficiencia del proyecto, tomando como referencia determinados parámetros relacionados tanto al brazo robótico como a los diferentes usuarios que realizaron pruebas con el prototipo.

5.1 Estructura del brazo robótico

El principal objetivo es controlar el brazo robótico a través de los movimientos del brazo del usuario, delimitando la estructura del robot con tres grados de libertad. Debido a que no se tomó en cuenta un plano de referencia o coordenadas de espacio para el área del trabajo del robot, se propone una estructura que permite realizar los movimientos del brazo robótico, imitando a los del usuario. La estructura propuesta pertenece a la configuración angular o antropomórfica de un manipulador, la cual se visualiza en la figura 5.1, esta estructura presenta una articulación con movimiento rotacional y dos con movimiento angular.

Figura 5. 1 Configuración de un brazo robótico antropomórfico o angular.

91

Para el diseño mecánico se utilizaron tubos de aluminio y soportes para los servomotores construidos también con aluminio, los brackets o soportes para servomotores son fabricados con medidas que se ajustan al tamaño de un servomotor estándar, el cual se muestra en la figura 5.2 con sus respetivas medidas. En la figura 5.3 se observa el soporte que se adapta a un servomotor con las medidas de los servomotores utilizados.

A continuación se muestran los tubos de aluminio utilizados para construir los eslabones del brazo robótico (parte que une las articulaciones, en la figura 5.4 se muestra la longitud de cada uno de ellos.

Figura 5. 3 Servomotor utilizado. Figura 5. 2 Soporte para el servomotor utilizado.

Figura 5. 4 Medidas de los tubos de aluminio utilizados.

92

5.1.1 Cálculo del torque para los motores Una vez que se establecieron las medidas de los eslabones 1 y 2, el siguiente paso es calcular el torque o fuerza necesaria para poder mover el peso del brazo robótico tomando en cuenta también el peso de los motores y de los soportes (brackets), la formula utilizada para el cálculo es la que se muestra en la ecuación 5.1.

τ = Ϝ⦁d (Ecuación 5.1)

En donde:

τ = torque o torsión Ϝ = fuerza aplicada d = distancia

Para el cálculo del torque correspondiente de cada motor se tomó en cuenta el peso del motor, bracket y tubo de aluminio del correspondiente eslabón. Para el motor del eslabón del movimiento angular 2 se toman en cuenta las distancias que se muestran en la figura 5.5 y los pesos de la tabla 5.1.

Tabla 5. 1 Medidas y pesos del eslabón para movimiento angular número 2.

Elemento Distancia Peso Soporte para servomotor

4.5cm 20 gr

Tubo de aluminio

7.5cm 15 gr

Pinza con motor

6.5cm 74 gr

Figura 5.5 Medidas del eslabón para movimiento angular número 2.

93

Sustituyendo en la ecuación 5.1

τ = (0.020kg+ 0.015kg + 0.074kg)(9.80 m/s2)⦁(0.045m+0.075m+0.065m) (Ecuación 5.2)

τ= 0.197617 N/m (Ecuación 5.3)

Convirtiendo de N/m a Kg/cm obtenemos:

τ = 2.01513 kg/cm (Ecuación 5.4)

EL motor utilizado modelo Hitec-hs311 tiene un torque de 3.0kgm/cm (ver anexo costos del proyecto)

Para el motor del eslabón del movimiento angular número 1 que corresponden al movimiento angular 2 se toman en cuenta las distancias que se muestran en la figura 5.6 y los pesos de la tabla 5.2.

Tabla 5. 2 Medidas y pesos del eslabón para movimiento angular número 1.

Elemento Distancia Peso Tuvo de aluminio movimiento angular 1

12.5cm 30gr

Soporte con motor

4.5cm 84gr

Tubo de aluminio movimiento angular 2

7.5cm 15 gr

Pinza con motor 6.5cm 74 gr

Figura 5. 6 Medidas del eslabón para movimiento angular número 1.

94

Sustituyendo en la ecuación 5.1

τ = (0.030kg+ 0.084kg + 0.015k + 0.074kg)(9.80 m/s2)⦁(0.125m + 0.045m + 0.075m + 0.065cm) (Ecuación 5.5)

τ= 0.616714 N/m (Ecuación 5.6)


τ = 6.2887 kg/cm (Ecuación 5.7)

Para este torque se utilizó el servomotor Power HD con un torque de 17kg/cm(ver anexo análisis de costos)

Para obtener el torque del servomotor que proporciona el movimiento de rotación del robot se añadió la distancia del bracket que corresponde al motor que proporciona el movimiento angular número 1 y número 2, sustituyendo en la formula se obtiene lo siguiente:

τ = (0.030kg+ 0.084kg + 0.015k + 0.074kg + 0.084 Kg)(9.80 m/s2)⦁(0.125m + 0.045m + 0.075m + 0.065cm + 0.045m) (Ecuación 5.8)

τ= 0.998473 N/m (Ecuación 5.9)


τ = 10.1815 kg/cm (Ecuación 5.10)

Igualmente se utilizó un servomotor PowerHd que contiene un torque de 17kg que es mayor al requerido.

En la figura 5.7 se visualiza el prototipo del diseño mecánico del manipulador antropomórfico, diseño que fue tomado como referencia para construir el prototipo.

95

La figura 5.8 muestra las medidas del brazo robótico, estas medidas son tomando en cuenta el origen y destino de las articulaciones, en donde el motor gira para realizar los movimientos angulares.

Figura 5. 8 Medidas del prototipo final.

Figura 5. 7 Diseño final del prototipo del brazo robótico.

96

Apertura de la pinza La pinza de sujeción puede abrirse una distancia de 3.5 cm y cerrarse por completo, en la figura 5.9 se muestra la medida de la apertura de la pinza de sujeción. El espacio de trabajo para el prototipo del brazo robótico se basa en la figura 5.10, la cual corresponde al espacio que normalmente tiene acceso un manipulador de configuración antropomórfica, en donde la parte rayada, marca el área de movimiento que abarca el brazo robótico utilizando sus tres grados de libertad. Esta área es aproximada, debido a que como se ha venido mencionando, el movimiento del brazo robótico, será controlado por el movimiento del usuario, por lo que si la persona no puede realizar movimientos tan flexibles con su brazo, entonces el brazo robótico no podrá moverse mas de lo que permitan dichos movimientos.

Figura 5.9 Máxima apertura de la pinza.

Figura 5. 10 Área de trabajo del brazo robótico.

97

5.2 Resultados de la detección de dedos En base al procedimiento para la detección de formas convexas en una imagen de profundidad, se obtuvieron resultados como los que se muestran en la figura 5.11.

Los círculos rojos representan inicio de una forma convexa y los círculos amarillos representan la profundidad de la forma convexa. En las figuras 5.12 y 5.13 se muestran los resultados que se obtienen cuando el usuario extiende 2 y 5 dedos respectivamente utilizando la mano izquierda. Este procedimiento no es del todo preciso debido a que se analizan imágenes de profundidad y partir de ellas se detectan formas convexas que pueden ser similares a las de un dedo, esto provoca que existan algunas otras formas en la imagen y puedan ser contadas como formas similares a las de un dedo.

Figura 5.11 Formas convexas detectadas.

Figura 5. 12 Resultado de la detección de dedos. Figura 5. 13 Resultado de la detección de dedos

98

5.3 Resultados de movimiento del robot En las figuras 5.14, 5.15 y 5.16 se muestran los movimientos del brazo robótico y del usuario, demostrando los movimientos que se generan cuando el usuario dobla las articulaciones.

En la figura 5.14 se muestra como al extender el brazo, el brazo robótico repite la misma acción moviéndose casi 180 grados, ángulo formado entre los dos eslabones, en la figura 5.15 se muestra la máxima flexión que puede realizar el usuario con el ángulo formado entre el brazo y antebrazo, movimiento que ejecuta el brazo robótico de forma similar, un detalle importantes es que el movimiento que efectúa el brazo robótico en su tercer grado de libertad( segundo eslabón), es contrario al movimiento del brazo del usuario con el antebrazo, la implementación para este movimiento dentro de la mecánica del robot fue realizada intencionalmente, debido a que el antebrazo de cualquier usuario no es capaz de ser flexionado de forma negativa a como se muestra en la figura 70, por lo tanto esto limitaría el movimiento del robot y por lo tanto el alcance para tomar y dejar piezas, es por eso que el movimiento del segundo eslabón es contrario al movimiento natural del usuario. Finalmente en la figura 5.16 se muestra una flexión del brazo del usuario y del robot a una posición aproximadamente de 90 grados, permitiendo tener una posición recta para la pinza. El movimiento de rotación y del segundo grado de libertad, son efectuado de forma similar en el robot, delimitados por la flexibilidad en los brazos del usuario.

Figura 5. 14 Posición con brazo estirado. Figura 5. 15 Posición con brazo flexionado.

99

5.4 Pruebas del brazo robótico

Las pruebas realizadas para probar la eficiencia del brazo robótico en ser utilizado por cualquier usuario, se realizaron en una superficie que tuviera un fondo rígido para la proyección de la cámara infrarroja ,debido a que el sensor no funciona de forma correcta al proyectar la luz infrarroja sobre superficies reflejantes o habitaciones donde la luz solar se proyecte de forma directa, las pruebas se realizaron sobre una habitación donde no se afectara la luz solar de forma directa en la proyección del sensor, también se intento realizar pruebas bajo condiciones de luz solar y superficies reflejantes, pero en ningún caso se obtuvo un correcto funcionamiento del sistema (ver anexo 5.1).

Las pruebas consistieron en tomar 6 piezas como la mostrada en la figura 5.17 y colocarlas en un recipiente, las pruebas se realizaron con la colaboración de 4 usuarios, con el objetivo de demostrar que cualquier persona puede controlar el robot sin adentrarse en su programación o cosas similares. Cabe destacar que las personas que controlaron el brazo robótico para intentar tomar y cambiar las

Figura 5. 16 Posición con brazo semi -flexionado.

Figura 5. 17 Modelo de pieza cilíndrica para pruebas del brazo robótico.

100

piezas al recipiente, no estaban familiarizados con el control del brazo robótico, únicamente se les explico el movimiento correspondiente a cada grado de libertad

Cada usuario realizó dos pruebas para intentar tomar 6 piezas similares a las de la figura 5.18 dispersadas en diferentes lugares dentro de una mesa de 60 * 60cm, la dispersión de las piezas se muestra en la figura 5.17, a partir de esta distribución se tomó el tiempo que tardo cada usuario en colocar las piezas en el recipiente, realizando dos intentos por cada prueba.

En la tabla 5.4 se muestran los tiempos que realizó cada usuario al tratar de mover las piezas, además se indica el número de piezas que piezas que fueron soltadas, y las piezas que quedaron fuera del alcance del robot por un movimiento erróneo del robot, además se incluye como dato adicional, la estatura del usuario, para demostrar que cualquier usuario puede controlar el brazo robótico. En los anexos 5.2 se puede consultar los imágenes de los usuarios controlando el prototipo, también se incluye el tiempo que realicé en ejecutar las mismas pruebas, con el objetivo de comparar con el tiempo realizados por los usuarios que controlaron el robot sin tener un previo entrenamiento.

Figura 5.18 Distribución de las piezas sobre mesa de madera.

101

Tabla 5. 3 Resultados de las pruebas realizadas con el brazo robótico.

En la siguiente imagen se muestra una grafica con el tiempo realizado por usuarios que no conocen el prototipo y lo han utilizado para realizar la prueba de depositar las 6 piezas dentro del contenedor.

No. de Usuario Estatura No. de prueba

Piezas soltadas

Piezas fuera del alcance del robot

Número de pizas depositadas

Tiempo total (minutos)

1 (Desarrollador del prototipo)

1.69m 1 1 1 4 2.20

1 (Desarrollador del prototipo)

1.69m 2 0 1 5 3.59

2 (Ver anexo 5.2.1)

1.51m 1 1 0 5 6.37

2 (Ver anexo 5.2.1)

1.51m 2 1 0 5 5.12

3 (Ver anexo 5.2.2)

1.62m 1 0 1 5 2.47

3 (Ver anexo 5.2.2)

1.62m 2 0 1 5 6.05

4 (Ver anexo 5.2.3)

1.60m 1 2 1 4 13.06

4 (Ver anexo 5.2.3)

1.60m 2 2 1 4 12.56

5 (Ver anexo 5.2.4)

1.50m 1 0 3 3 8.33

5 (Ver anexo 5.2.4)

1.50m 2 0 2 4 10.20

0

2

4

6

8

10

12

14

2 2 3 3 4 4 5 5

Min

uto

s

Número de usuario

Figura 5. 19 Gráfica del tiempo en completar la prueba.

102

El promedio general del tiempo que se obtiene al tratar de transportar las 6 piezas al contenedor es el mostrado en la ecuación 5.11:

Q�=RS,S-,R=K�, = ∑ T�∗VTWV�∗� (Ecuación 5.11)

Donde:

i = número de usuario

n= total de usuarios

ti= tiempo del usuario en completar la prueba

Sustituyendo en la ecuación 5.2 obtenemos el siguiente promedio:

Tiempo promedio

= X.YZ[\]�.��.�Z[\]X.��Y.�X��.�X^.YY��.��^ =16.34minutos (Ecuación 5.12)

Para obtener la eficiencia del brazo robótico se realizaron la suma de las pruebas realizadas (incluyendo la realizada por el autor del presente trabajo) y se obtuvo un porcentaje de las piezas que fueron colocadas correctamente en el contenedor, tomando las piezas soltadas o que quedaron fuera del alcance del robot, como un error, el porcentaje de eficiencia se determina con la siguiente formula:

% de eficiencia = _�(�`��a$b(�`�b� $($bc� $%(�`��a$b ∗ 100 =

��

X�∗ 100= 73% (Ecuación 5.13)

% de error = 100% -73%= 27% (Ecuación 5.14)

El porcentaje de error disminuye cuando el usuario obtiene práctica en el uso del prototipo, adaptándose a los movimientos del robot para poder controlar su velocidad y precisión. Cuando el prototipo es utilizado por personas que han realizado un previo entrenamiento para controlar el robot, el porcentaje de error disminuye.

103

Conclusiones Dentro de las pruebas se observó que el movimiento del brazo robótico puede ser un poco brusco, debido a que las coordenadas entregadas por el Kinect no son del todo constantes dentro de cada imagen entregada por el sensor, aun así, se pudieron tomar algunas piezas de pequeño tamaño y peso ligero, demostrando que el brazo robótico podría llegar a transportar piezas u objetos pequeños como los utilizados en las pruebas los cuales tienen un ancho menor a la apertura total de la pinza

El tiempo promedio para que un usuario que desconoce el funcionamiento del prototipo pueda utilizar el robot, depende la habilidad de la persona para acostumbrarse al control del robot; para algunos usuarios fue difícil mantener la mano izquierda referenciada al sensor para abrir y cerrar la pinza y al mismo tiempo realizar el control con el brazo derecho.

El porcentaje de error fue considerable, debido a que no todas las piezas fueron transportadas de forma correcta durante las pruebas, debido a que ligeros movimientos del robot desplazaban las piezas dejándolas fuera su alcance. Además de que otras piezas fueron soltadas al presentarse fallas dentro de la detección de dedos para la apertura y cierre de la pinza.

En cuanto a la respuesta del sistema se obtuvieron resultados favorables, el robot se mueve a una velocidad que asimila ser paralela a la velocidad con la que el usuario mueve el brazo, permitiendo menor tiempo en el transporte de piezas u objetos. Una de las limitaciones del proyecto, como se ha mencionado anteriormente, es que ninguno de sus tres grados de libertad alcanza el máximo movimiento permitido por los servomotores (180 grados), debido a que la flexibilidad en los movimientos del brazo de la mayoría de las personas, no se ajusta a dicho movimiento, delimitando como consecuencia el movimiento del brazo robótico.

Finalmente, este trabajo de tesis produjo un brazo robótico con tres grados de libertad, que puede ser controlado de forma natural por cualquier persona que cuente con las extremidades requeridas, sin necesidad de utilizar interfaces físicas como palancas o botones.

104

Observaciones El cuarto donde se utilice el sensor es de gran importancia, se debe procurar que el sensor proyecte sobre una superficie rígida y no transparente o reflejante (vidrios, etc.), además de que la habitación debe ser un espacio en donde no afecte la luz solar de forma directa, por ejemplo colocar el sensor cerca de una ventana o puerta. La altura donde se coloque el sensor debe estar dentro de los rangos que indica el fabricante (0.60m a 1.50m), ya que al no cumplirse esta especificación, el sensor adquiere y entrega los datos de forma incorrecta debido a la mala proyección que ejecuta el sensor infrarrojo sobre la superficie cuando se coloca el sensor en una altura fuera del rango especificado.

Limitaciones Ninguno de los tres grados de libertad del brazo robótico puede desplazarse los 180 grados que limita un servomotor, los movimientos realizados por un usuario dependiendo de su capacidad para mover el brazo controlan el robot, limitan el movimiento de cada articulación. Otro aspecto que limita este proyecto, es que no puede utilizarse en ambientes donde exista luz solar, debido a que el sensor Kinect no trabaja bajo esas condiciones, de igual forma si algún objeto o persona se encuentra entre el sensor y el usuario, se obstruye la lectura de los datos del sensor, como consecuencia la aplicación tendrá un funcionamiento incorrecto, provocando fallas catastróficas en el movimiento del brazo robótico.

Mejoras del proyecto y trabajo a futuro El alcance para tomar o dejar piezas con el brazo robótico depende también de los grados de libertad del robot, una mejora que podría implementarse es agregar mas grados de libertad imitando lo más preciso el movimiento natural del brazo de una persona. En cuanto a la comunicación entre la computadora y el PIC, se puede cambiar el protocolo de comunicación utilizando alguno que mantenga el envío de los datos de manera rápida y efectiva, pensando tal vez en una comunicación basada en el protocolo Wifi.

Otra opción dentro del control del robot, es poder anular el uso de la mano izquierda para el control de la pinza, realizando este control con la misma mano que del brazo que controla el robot. Este trabajo solo será posible si en algún futuro los desarrolladores del hardware del Kinect liberan un nuevo modelo del dispositivo que permita el seguimiento de las articulaciones de los dedos dentro de un plano 3D. Otra opción para implementar la tarea mencionada, es utilizar

105

algunas librerías que permite un análisis 3D de la mano, basado en algoritmos de visión por computadora, cuyo software se encuentra en la página de las librerías de programación utilizadas en este trabajo, además de conjuntarlo con un seguimiento de usuario, como el que se implementó en el proyecto.

106

Bibliografía [1]UDC. (2012). OpenNI and software. Obtenido de http://sabia.tic.udc.es/gc/trabajos%202011-

12/Kinect/codigo.html

[2]Alejandro, I. L. (Noviembre de 2012). Sistemas en tiempo real. Apuntes del semestre.

[3] Sistemas de asquicisión de datos,H Mora Mora

[4] Atif Khan, F. M. (2011). KinDectect: Kinect Detecting Objects.

[5] http://es.scribd.com/doc/86437713/kinectdoc pagina 22

[6] SignLanguageTranslator árticulo por Daniel Martinez Capilla pagina 17.

[7] DEPT, H. E. (2012). Kinect docs. Obtenido de http://es.scribd.com/doc/86437713/kinectdoc

[8] Jaime, M. M. (Noviembre de 2012). Diapositivas de clase. Vision Stereo.

[9] http://es.scribd.com/doc/86437713/kinectdoc páginas 23 y 24.

[10] Matthias Kronlachner, I. m. (2012). THE KINECT SENSOR AS HUMAN-MACHINE-INTERFACE IN

AUDIO-VISUAL ART PROJECTS. Austria.

[11] Real-Time Human Pose Recognition in Parts from Single Depth Images, Jamie Shotton ,

Andrew Fitzgibbon, Mat Cook.

[12] “KinDectect: Kinect Detecting Objects” , Atif Khan, Febin Moideen, Juan Lopez, Wai L. Khoo

and Zhigang Zhu Department of Computer Science, City College of New York, New York.

[13] Sense, P. (2011). OpenNI User Guide.

[14] http://www.openni.org/

[15] http://articulo.mercadolibre.com.mx/MLM-419491511-bluetooth-modulo-serial-

microcontrolador-pic-arduino-atmel-_JM

[16] Publicación Interna 9 20-09-2007 Francisco A. Candelas Herías Juan A. Corrales Ramón

[17]http://es.wikipedia.org/wiki/%C3%81ngulos_de_Euler.

[18]http://es.wikipedia.org/wiki/Convexidad

[19]Arranz Aranda Francisco, L. Y. (2011 - 2012). Interacción persona-computador basada en el

reconocimiento visual de manos. UNIVERSIDAD COMPLUTENSE DE MADRID.

107

[20]Atif Khan, F. M. (2011). KinDectect: Kinect Detecting Objects.

[21]Boreisntein, G. (Febrero 2012). Making things see: 3D vision with Kinect, Processing, Arduino

and MakerBot. O´Reilly.

[22]Bruno Siciliano, L. V. (2008). Robotic, Modelling, Planning and Control. Springer.

[23]Diez, E. R. (Abril 18 2012). Arduino and Kinect Projects. Technology in action.

[24]Eberly, D. (1 de Diciembre de 1999). http://www.geometrictools.com/. Obtenido de Euler

Angle Formulas.

[25]Gary Bradsky, A. K. (2008). Learning OpenCV. O´Reilly.

[26]Jamie Shotton, A. F. (s.f.). Real-Time Human Pose Recognition in Parts from Single Depth

Images.

[27]Ladislao Mathe, D. S. (s.f.). Estudio del funcionamiento del sensor Kinect y aplicaciones para

bioingeniería. 2011.

[28]Li, Y. (2010). Thesis on HAND GESTURE RECOGNITION USING KINECT. B.S., Communication

University of China,.

[29]MacCormick, J. (2010-2011). How does the Kinect work?

[30]Prime Sense. (2011). Prime Sense 1.3 NITE Algorithms notes.

[31]Prime Sense, NITE. (2011). Prime Sensor NITE 1.3 Controls Programer´s Guide, version 1.

[32]PrimeSense. (2012). OpenNI.org. Recuperado el Junio de 2012, de http://www.openni.org/

[33]Ravì, D. (s.f.). Kinect: the next generation of motion control.

[34]Sean Kean, J. H. (Dicimebre 23 -2011). Meet the Kinect. Technology in action.

[35]Tongo, L. d. (02 de Septiembre de 2010). Emgu CV Hand Gestures Recognition Advanced

Tutorial. Obtenido de http://www.youtube.com/watch?v=Fjj9gqTCTfc

108

Anexo 1 1.1 Análisis de costos Para la construcción e implementación de este proyecto se utilizaron los siguientes materiales:

� Sensor Kinect: El sensor Kinect es el principal componente de este proyecto, debido a que todos los datos son adquiridos a través del él, este dispositivo puede comprarse en cualquier tienda donde este a la venta la consola Xbox 360, debido a que es un complemento de la consola, es recomendable comprarlo por separado para que se incluya el cable USB que se requiere para la conexión con la computadora. Precio: $1800.00

� Bracket para servomotor estándar: sirve para montar cualquier servomotor estándar y poder hacer una estructura más rígida o conectarlo con otros brackets y permitir la rotación de la articulación del brazo. Precio: $275.00 Cantidad: 3

� Modulo bluetooth para transmisión serial: funciona por medio del protocolo bluetooth, pero la transmisión y recepción es de forma serial RS232. Precio: $250.00

� Servomotor estándar HITEC HS-311: utilizado para una articulación y para la apertura y cierre de la pinza. Velocidad : (sec/60o): 0.19

Torque (Kg-cm/Oz-in): 3.7/49

109

Tamaño (mm): 40 x 20 x 37

Peso (g/oz): 43/1.51

Precio: $210.00

Cantidad: 2

� Servomotor estándar alto torque: Para el movimiento de rotación del brazo y el movimiento del primer eslabón, se utilizó un servomotor con mayor torque, funcionando con las mismas características que el HITEC HS-311.

Velocidad: (sec/60o): 0.19

Torque (Kg-cm): 17kg

Tamaño (mm): 40 x 20 x 37

Peso (g/oz): 43/1.51 Precio: $350.00

Cantidad : 2

� Gripper: pinza que abre o cierra para tomar objetos pequeños con el brazo robótico, la apertura del gripper es de 1.3 pulgadas. Precio :$ 300.00

� Tubo de aluminio ligero : utilizado para construir los eslabones del brazo robótico, debido al material con el que está fabricado, no se requiere demasiado torque para poder levantar dicho eslabón. Precio: $30.00 Cantidad: 2

� Placa fenólica doble cara 10*10cm: el diseño del circuito impreso requiere una placa de doble vista para hacer el diseño de la placa controladora del brazo. Precio: $18.00

110

� Batería de acido-plomo 6v 2 Ampers: los servomotores utilizados en el proyecto demandan mayor cantidad de corriente y voltaje a los utilizados por el PIC18F4550, es por eso que se utiliza una batería con mayor voltaje y amperaje para permitir el máximo torque de los motores. Precio: $120.00

� Base para circuito integrado de 40 pines: utilizada para el colocar el PIC ene l circuito impreso. Precio: $5.00

� Microcontrolador PIC18F4550 : las características de este PIC satisfacen las herramientas que se requieren para el proyecto. Precio: $120.00

� Cristal piezoeléctrico 20Mhz: es necesario para generar la frecuencia de trabajo del reloj del PIC18F4550. Precio: $15.00

� Conector USB tipo B para circuito impreso: este conector permite realizar la conexión con la computadora para poder programar el microcontrolador y alimentarlo. Precio: $8.00

� Capacitor 22 ρf: complementos para el correcto funcionamiento del cristal piezoeléctrico. Precio: $2.00 Cantidad: 2

111

La siguiente tabla muestra el costo total del proyecto.

Tabla anexo 1 Costo total del proyecto.

Material Cantidad Costo por pieza Costo total Kinect 1 $1800.00 $1800.00 Soporte para servomotor

3 $275.00 $825.00

Módulo bluetooth 1 $250.00 $250.00 Servomotor 3.7kg 2 $210.00 $420.00 Servomotor 17kg 2 $350.00 $700.00 Pinza 1 $300.00 $300.00 Tubo de aluminio 2 $30.00 $60.00 Tabla fenólica 1 $18.00 $18.00 Batería acido -plomo

1 $120.00 $120.00

PIC18F4550 1 $120.00 $120.00 Base 40pin 1 $5.00 $5.00 Cristal 20Mhz 1 $15.00 $15.00 Conector USB 1 $8.00 $8.00 Capacitor 22pf 2 $2.00 $4.00 Total $4645.00

De todos los materiales utilizados, el sensor Kinect es el mas costoso debido a que es un producto de última tecnología y con gran futuro dentro de las interfaces de usuario, el uso de este producto es la base en esta tesis, pero representa una gran ventaja y ahorro de trabajo al lado de otro tipo de sensores que son costosos y requieren de circuitería externa. Algunos de los servomotores utilizados tienen un costo elevado debido al torque con el que cuentan y su durabilidad, además de tener tiempos de respuesta favorables para la implementación del proyecto.

El material utilizado para la estructura del robot esta diseñado para permitir libremente la rotación de cada motor y ser ligero debido al material con el que esta construido.

El proyecto es relativamente costoso pero demasiado eficiente debido al gran futuro y desarrollo que ha vendo incrementándose en las interfaces de usuario que utilizan el sensor Kinect, además de ser un proyecto demasiado innovador.

112

Anexo 2

2.1 Características del PIC18F4550 Es un microcontrolador de la familia pic18 fabricado por Microchip, el cual cuenta con las siguientes características:

• Arquitectura RISC avanzada Harvard: 16 bits con 8 bits de datos. • 77 instrucciones • Desde 18 a 80 pines • Hasta 64K bytes de programa (hasta 2 Mbytesen ROMless) • Multiplicador Hardware 8x8 • Hasta 3968 bytes de RAM y 1KBytes de EEPROM • Frecuencia máxima de reloj 40Mhz. Hasta 10 MIPS. • Pila de 32 niveles. • Múltiples fuentes de interrupción • Periféricos de comunicación avanzados (CAN y USB)

El PIC18F4550 dispone de las siguientes memorias:

• Memoria de programa: memoria flash interna de 32.768 bytes: La cual almacena instrucciones y constantes/datos, además puede ser escrita/leída mediante un programador externo o durante la ejecución del programa mediante unos punteros.

• Memoria RAM de datos: memoria SRAM interna de 2048 bytes en la que están

incluidos los registros de función especial. Almacena datos de forma temporal durante la ejecución del programa y puede ser escrita/leída en tiempo de ejecución mediante diversas instrucciones.

• Memoria EEPROM de datos: memoria no volátil de 256 bytes: almacena datos

que se deben conservar aun en ausencia de tensión y de alimentación. Puede ser escrita/leída en tiempo de ejecución a través de registros

• Pila: bloque de 31 palabras de 21 bits que almacena la dirección de la instrucción que debe ser ejecutada después de una interrupción o subrutina

113

2.2 Terminales PIC18F4550

114

2.3 Registros transmisión UART

115

116

2.4 Registros Timer2

117

118

Anexo 3

3.1 Gráficas de descarga de la batería de ácido-plomo

3.2 Plantilla del archivo xml para OpenNI Archivo xml para el uso del Kinect en OpenNI

<OpenNI> <Licenses> <Licensevendor="PrimeSense" key="0KOIk2JeIBYClPWVnMoRKn5cdY4="/> </Licenses> <ProductionNodes> <Node type=" " name=" "> <Configuration> </Configuration> </Node> </ProductionNodes> </OpenNI>

119

Anexo 4

4.1 Plantilla del archivo xml para programación del sensor

Archivo xml utilizado para la aplicación <OpenNI> <Licenses> <License vendor="PrimeSense" key="0KOIk2JeIBYClPWVnMoRKn5cdY4="/> </Licenses> <Log writeToConsole="false" writeToFile="false">  <LogLevel value="3"/> <Masks> <Mask name="ALL" on="true"/> </Masks> <Dumps> </Dumps> </Log> <ProductionNodes> <Node type="Depth" name="Image1"> <Configuration> <MapOutputMode xRes="640" yRes="480" FPS="30"/> <Mirror on="true"/> </Configuration> </Node> <Node type="Image" name="Image2"> <Configuration> <MapOutputMode xRes="640" yRes="480" FPS="30"/> <Mirror on="true"/> </Configuration> </Node> <Node type="User"/> <Node type="Gesture"/> <Node type="Hands"/> </ProductionNodes> </OpenNI>

120

4.2 Código para obtener imagen de profundidad

public unsafe Bitmap Obtener_imagenDepth(DepthMetaData Metadata_profundidad) { lock (this) { Rectangle rectangulo = new Rectangle(0, 0, 640, 480);

BitmapData mapadatos = this.mapa_profundidad.LockBits(rectangulo, ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);

imagen_profundidad.GetMetaData(Metadata_profundidad); ushort* apuntadorprofundidad = (ushort*)imagen_profundidad.DepthMapPtr.ToPointer(); for (int a = 0; a < 480; a++) { byte* valores = (byte*)mapadatos.Scan0.ToPointer() + a * mapadatos.Stride; for (int b = 0; b < 640; b++, apuntadorprofundidad++, valores += 3) { valores[0] = (byte)*apuntadorprofundidad;//canal 1 valores[1] = (byte)*apuntadorprofundidad;//canal 2 valores[2] = (byte)*apuntadorprofundidad;//canal 3 } } this.mapa_profundidad.UnlockBits(mapadatos); } return this.mapa_profundidad; }

121

4.3 Código para obtener imagen RGB

4.4 Código para obtener imagen infrarroja

public unsafe Bitmap Obtener_imagen_RGB(ImageMetaData datos_RGB) { Rectangle rectangulo = new Rectangle(0, 0, 640, 480);

BitmapData mapadatos = mapa_RGB.LockBits(rectangulo, ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);

imagen_RGB.GetMetaData(datos_RGB); RGB24Pixel* pRGB = (RGB24Pixel*)imagen_RGB.ImageMapPtr.ToPointer();

for (int y = 0; y < 480; y++) { byte* pDest = (byte*)mapadatos.Scan0.ToPointer() + y * mapadatos.Stride;

for (int x = 0; x < 640; x++, ++pRGB, pDest += 3) { byte red = pRGB->Red; byte green = pRGB->Green; byte blue = pRGB->Blue; pDest[0] = blue; pDest[1] = green; pDest[2] = red; } } mapa_RGB.UnlockBits(mapadatos); return mapa_RGB; }

public unsafe Bitmap Obtener_imagenIR(IRMetaData Metadata_infrarojo) { Rectangle rectangulo = new Rectangle(0, 0, 640, 480); BitmapData mapadatos = mapa_IR.LockBits(rectangulo, ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb); imagen_IR.GetMetaData(Metadata_infrarojo);

ushort* apuntadorprofundidad = (ushort*)imagen_IR.IRMapPtr.ToPointer(); for (int a = 0; a < 480; a++) { byte* valores = (byte*)mapadatos.Scan0.ToPointer() + a * mapadatos.Stride; for (int b = 0; b < 640; b++, apuntadorprofundidad++, valores += 3) { valores[0] = (byte)*apuntadorprofundidad;//canal 1 valores[1] = (byte)*apuntadorprofundidad;//canal 2 valores[2] = (byte)*apuntadorprofundidad;//canal 3 } } mapa_IR.UnlockBits(mapadatos); return mapa_IR;

122

4.5 Código para calibración de usuario

private void UserGenerator_NewUser(object sender, NewUserEventArgs e) { if (e.ID == 1) {

label1.Text = "Usuario detectado con ID = " + e.ID.ToString(); this.usuario.PoseDetectionCapability.StartPoseDetection("Psi", 1); } } private void UserGenerator_LostUser(object sender, UserLostEventArgs e) { if (e.ID == 1) { label1.Text = "Usuario 1 perdido"; } } private void PoseDetectionCapability_PoseDetected(object sender, PoseDetectedEventArgs e) { if (e.ID == 1) { this.usuario.SkeletonCapability.RequestCalibration(1, true); //peticion de calibración this.usuario.PoseDetectionCapability.StopPoseDetection(1); //detener la deteccion de pose } } private void PoseDetectionCapability_OutOfPose(object sender, OutOfPoseEventArgs e) { if (e.ID == 1) { this.usuario.PoseDetectionCapability.StartPoseDetection("Psi", 1); } } private void SkeletonCapability_CalibrationComplete(object sender, CalibrationProgressEventArgs e) { if (e.ID == 1) { if (e.Status.ToString() == "OK") { bandera_actualizacion = true; bandera_comienza_seguimiento_mano = true; this.usuario.SkeletonCapability.StartTracking(1); //empezamos calibracion } else { this.usuario.PoseDetectionCapability.StartPoseDetection("Psi", 1); //peticion pra nueva detecccion de pose } } }

123

4.6 Cálculo de ángulo entre dos joints

public double obtener_angulo_entre_dos_(double v1, double v2, double v3, double w1, double w2, double w3) { double producto_punto; double magnitud_v; double magnitud_w; double angulo, angulo_real; referencia = new double[3]; articulacion = new double[3]; referencia[0] = v1; referencia[1] = v2; referencia[2] = v3; articulacion[0] = w1; articulacion[1] = w2; articulacion[2] = w3; producto_punto = (referencia[0] * articulacion[0]) + (referencia[1] * articulacion[1]) + (referencia[2] * articulacion[2]); magnitud_v = Math.Sqrt(Math.Pow(referencia[0], 2.0) + Math.Pow(referencia[1], 2.0) + Math.Pow(referencia[2], 2.0)); magnitud_w = Math.Sqrt(Math.Pow(articulacion[0], 2.0) + Math.Pow(articulacion[1], 2.0) + Math.Pow(articulacion[2], 2.0)); angulo = Math.Acos((producto_punto) / (magnitud_v * magnitud_w)); angulo_real = (angulo * 360) / (2 * Math.PI); return angulo_real; }

124

4.7 Cálculo del ángulo de rotación

public double obtener_rotacion_joint(double[,] matriz,int eje) { double thetaY, thetaX, thetaZ; if (matriz[0,2] < +1) { if (matriz[0, 2] > -1) { thetaY = Math.Asin(matriz[0, 2]); thetaX = Math.Atan2(-1 * matriz[1, 2], matriz[2,2]); thetaZ = Math.Atan2(-matriz[0, 1], matriz[0, 0]); } else { thetaY = -1 * Math.PI / 2; thetaX = -1 * Math.Atan2(matriz[1, 0], matriz[1, 1]); thetaZ = 0; } } else { thetaY = 1 * Math.PI / 2; thetaX = Math.Atan2(matriz[1, 0], matriz[1, 1]); thetaZ = 0; } switch (eje) { case 1: resultado = thetaX; break; case 2: resultado = thetaY; break; case 3: resultado = thetaZ; break; } return resultado; } }

125

4.8 Código detección de dedos

public Image<Bgr, Byte> dibujardedos(Image<Bgr, Byte> image) {

int dedos = 0; //inicia un contador para saber la cantidad de dedos if (defectos != null) { int posiblesdedos=defectos.Total; for (int i = 0; i < defectos.Total; i++) { try { PointF Puntoinicial = new PointF((float)areglodedefectos[i].StartPoint.X, (float)areglodedefectos[i].StartPoint.Y); PointF Puntoprofundidad = new PointF((float)areglodedefectos[i].DepthPoint.X, (float)areglodedefectos[i].DepthPoint.Y); PointF Puntofinal = new PointF((float)areglodedefectos[i].EndPoint.X, (float)areglodedefectos[i].EndPoint.Y); LineSegment2D Lineainicio = new LineSegment2D(areglodedefectos[i].StartPoint, areglodedefectos[i].DepthPoint); LineSegment2D Lineaprofundidad = new LineSegment2D(areglodedefectos[i].DepthPoint, areglodedefectos[i].EndPoint); CircleF Circuloinicio = new CircleF(Puntoinicial, 5f); CircleF Circuloprofundidad = new CircleF(Puntoprofundidad, 5f); CircleF Circulofinal = new CircleF(Puntofinal, 5f); if ((Circuloinicio.Center.Y < caja.center.Y || Circuloprofundidad.Center.Y < caja.center.Y) && (Circuloinicio.Center.Y < Circuloprofundidad.Center.Y) && (Math.Sqrt(Math.Pow(Circuloinicio.Center.X - Circuloprofundidad.Center.X, 2) + Math.Pow(Circuloinicio.Center.Y - Circuloprofundidad.Center.Y, 2)) > caja.size.Height / 6.5)) { dedos++; } } catch (Exception) {} } MCvFont font = new MCvFont(Emgu.CV.CvEnum.FONT.CV_FONT_HERSHEY_DUPLEX, 5d, 5d); switch (dedos) { case 0: resultado = "C"; angulo_mano_final = 110; break; case 1: resultado = "C"; angulo_mano_final = 110; break; case 2: resultado = "C "; angulo_mano_final = 110; break; case 3: resultado = "C "; angulo_mano_final = 110; break; case 4: resultado = "A"; angulo_mano_final = 5; break; case 5: resultado = "A"; angulo_mano_final = 5; break; case 6: resultado = "A"; angulo_mano_final = 5; break;

126

4.9 Código de la interrupción UART del PIC18F4550

//interrupcion RX

if(PIR1bits.RCIF==1) //bandera de interrupcion de RX se activa al recibir un dato

{

if(RCREG==181){ grados=90; gradosdos=10; gradostres=10; gradoscuatro=10; bandera_reposo=1; } else

{

variable++; //variable que asigna el dato correspondiente a cada articulación

switch(variable)

{

case 1:

grados=RCREG;

break;

case 2:

gradosdos=RCREG;

break;

case 3:

gradostres=RCREG;

break;

case 4:

gradoscuatro=RCREG;

variable=0;

break; default:

break; }

PIR1bits.RCIF=0; //limpiamos bandera de interrupción

} }

127

4.10 Código de la interrupción Timer2 del PIC18F4550

//interrupción Timer2

if(PIR1bits.TMR2IF==1) //bandera interrupcion timer2

{

PR2=120; //cargamos registro

contador++; //incrementamos contador

if(contador==60+grados) //preguntamos

por la primera variable

{

LATBbits.LATB1=0; //si el pulso

esta completo,terminamos el ciclo de trabajo

}

if(contador==60+gradosdos) //segunda variable

{

LATBbits.LATB3=0; //terminamos el

pulso de la segunda variable

}

if(contador==60+gradostres) //segunda variable

{

LATBbits.LATB6=0; //terminamos el

pulso de la segunda variable

}

if(contador==60+gradoscuatro) //segunda variable

{

LATBbits.LATB7=0; //terminamos el pulso de la segunda variable

}

// if(contador == 3800) //reiniciamos el pulso

colocando los bits en uno

if(contador==1800)

{

LATBbits.LATB1=1; //iniciamos nuevo periodo

LATBbits.LATB3=1;

LATBbits.LATB6=1;

LATBbits.LATB7=1;

contador=0;

}

128

Anexo 5 Imágenes

5.1 Imagen de habitación no apta para funcionamiento del sensor

5.2 Imágenes de los usuarios controlando el brazo robótico

5.2.1 Usuario número 2 5.2.2 Usuario número 3

5.2.3 Usuario número 4 5.2.4 Usuario número 5

Figura A. 1 Habitación con condiciones no aptas para el funcionamiento del sensor.

Figura A.3 Usuario 2 (1.51metros) Figura A. 2 Usuario 3 (1.62metros)

Figura A. 5 Usuario 4 (1.60metros) Figura A. 4 Usuario 5 (1.50metros)

129

Anexo 6 Diagrama de clases de la aplicación

Documents

4.3.5 Selección de las articulaciones a utilizar