INSTITUTO POLITCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERA

MECNICA Y ELCTRICA

BRAZO ROBTICO CONTROLADO MEDIANTE SENSOR

KINECT

TESIS
QUE PARA OBTENER EL TTULO DE
INGENIERO EN COMUNICACIONES Y ELECTRNICA

PRESENTA:
FRANCISCO JAVIER VZQUEZ VZQUEZ

ASESOR:
ING. ARMANDO MANCILLA LEN

MXICO, D.F. 2013

INSTITUTO POLITC NICO NACIONAL

ESCUELA SUPERIOR DE INGENIERA MECNICA Y ELECTRICA
UNIDA D P ROF ESIONAL "AD O LFO LPEZ MATEOS"

TEMA DE TE S I S
QUE PARA OBTENER EL TI TU LO DE

INGENIERO EN COMUNICACIONES Y ELECTRNICA

POR LA OPC I N DE TITULACIN

TESIS Y EXAMEN ORAL INDIVIDUAL

DEBERA(N) DESA RR O LLA R

C. FRANCISCO JAVIER VZQUEZ V ZQUEZ

"BRAZO ROBTICO CONTROLADO MEDIANTE SENSOR KINECT"

CONSTRUIR EL PROTOTIPO DE UN BRAZO ROBTICO INTEGRADO POR TRES GRADOS DE LIBERTAD Y UNA

PINZA DE SUJECIN, PROGRAMADO PARA MOVERSE DE ACUERDO A LOS MOVIMIENTOS HECHOS POR EL

BRAZO DEL USUARIO DE FORMA SIMULTANEA, DICHOS MOVIMIENTOS DEL USUARIO SERN ADQUIRIDOS A

TRAVS DEL SENSOR MICROSOFT KINECT.

:.
:.
.:.
:.
.:.
.:.
:.
:.
:.

INTRODUCCIN.
ESTADO DEL ARTE.
MARCO TERICO.
DESCRIPCIN DEL HARDWARE.
DISEO DEL SOFTWARE.
PRUEBAS y RESULTADOS .
CONCLUSIONES .
BIBLIOGRAFA .
ANEXOS.

MXICO D. F., A 10 DE JUNIO DE 2013.

JEFE DEL DEPA

INGENIERA EN COM

ndice general
Introduccin .......................................................................................................................... 1
Definicin del problema ............................................................................................................. 1
Justificacin ............................................................................................................................... 2
Objetivos del proyecto ............................................................................................................... 3
General .................................................................................................................................. 3
Especficos ............................................................................................................................. 3
Captulo 1 Estado del arte ......................................................................................................... 4
1.1 Control de un Robot ABB con Kinect ..................................................................................... 4
1.2 Brazo robtico controlado mediante gestos a travs de Kinect ............................................. 5
1.3 Uso mdico del Kinect .......................................................................................................... 5
1.4 Perro robot gua para ciegos................................................................................................. 6
Captulo 2 Marco terico .......................................................................................................... 7
2.1 Sistemas en tiempo real ....................................................................................................... 7
2.1.1 Sensores ........................................................................................................................ 9
2.1.2 Acondicionamiento de la seal ....................................................................................11
2.1.3 Conversin analgica a digital.......................................................................................11
2.1.4 Procesamiento digital ...................................................................................................14
2.1.5 Clasificacin de los sistemas en tiempo real ..................................................................16
Captulo 3 Descripcin del Hardware ....................................................................................... 17
3.1 Sensor de movimiento y obtencin de datos ..................................................................... 18
3.1.1 Sensor de profundidad .................................................................................................21
3.1.2 Deteccin y seguimiento de usuario .............................................................................25
3.1.3 Libreras de libre acceso para la programacin de Kinect ..............................................29
3.2 Dispositivos de procesamiento digital................................................................................. 33
3.2.1 Descripcin de los dispositivos de procesamiento.........................................................33
3.2.2 Comunicacin entre la computadora y microcontrolador PIC18F4550 ..........................35
3.3 Servomotores .................................................................................................................... 36

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 esquemtico del circuito impreso para la tarjeta de control .........................39
Captulo 4 ............................................................................................................................... 43
Diseo del software ................................................................................................................ 43
4.1 Descripcin del software .................................................................................................... 43
4.2 Inicializacin del Kinect ..................................................................................................... 46
4.3 Software para adquisicin 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 calibracin ..................................................................................................56
4.3.5 Seleccin de las articulaciones a utilizar ........................................................................60
4.3.6 Clculo de movimientos del brazo del usuario ..............................................................61
4.3.7 Deteccin de gesto de finalizacin ................................................................................73
4.3.8 Deteccin de dedos para apertura y cierre de la pinza ..................................................75
4.3.9 Interfaz grfica de usuario ............................................................................................82
4.4 Programacin del microcontrolador PIC18F4550 ................................................................ 83
Captulo 5 Pruebas y resultados .............................................................................................. 90
5.1 Estructura del brazo robtico ............................................................................................. 90
5.1.1 Clculo del torque para los motores .............................................................................92
5.2 Resultados de la deteccin de dedos .................................................................................. 97
5.3 Resultados de movimiento del robot .................................................................................. 98
5.4 Pruebas del brazo robtico................................................................................................. 99
Conclusiones ........................................................................................................................ 103
Observaciones ........................................................................................................................104
Limitaciones ............................................................................................................................104
Mejoras del proyecto y trabajo a futuro ..................................................................................104
Bibliografa ........................................................................................................................... 106
ii

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

1.1 Anlisis de costos ..............................................................................................................108
Anexo 2 ................................................................................................................................ 112
2.1 Caractersticas del PIC18F4550 ..........................................................................................112
2.2 Terminales PIC18F4550 .....................................................................................................113
2.3 Registros transmisin UART...............................................................................................114
2.4 Registros Timer2 ...............................................................................................................116
Anexo 3 ................................................................................................................................ 118
3.1 Grficas de descarga de la batera de cido-plomo ............................................................118
3.2 Plantilla del archivo xml para OpenNI ................................................................................118
Anexo 4 ................................................................................................................................ 119
4.1 Plantilla del archivo xml para programacin del sensor .....................................................119
4.2 Cdigo para obtener imagen de profundidad ....................................................................120
4.3 Cdigo para obtener imagen RGB ......................................................................................121
4.4 Cdigo para obtener imagen infrarroja ..............................................................................121
4.5 Cdigo para calibracin de usuario ....................................................................................122
4.6 Clculo de ngulo entre dos joints .....................................................................................123
4.7 Clculo del ngulo de rotacin...........................................................................................124
4.8 Cdigo deteccin de dedos................................................................................................125
4.9 Cdigo de la interrupcin UART del PIC18F4550 ................................................................126
4.10 Cdigo de la interrupcin Timer2 del PIC18F4550............................................................127
Anexo 5 Imgenes ................................................................................................................ 128
5.1 Imagen de habitacin no apta para funcionamiento del sensor .........................................128
5.2 Imgenes de los usuarios controlando el brazo robtico ...................................................128
5.2.1 Usuario nmero 2 5.2.2 Usuario nmero 3................................................................ 128
5.2.3 Usuario nmero 4 5.2.4 Usuario nmero 5 ............................................................... 128
Anexo 6 Diagrama de clases de la aplicacin ............................................................................. 2

iii

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) Seal original [3]...................................................................................................................... 12
Figura 2. 4 Multiprogramacin......................................................................................................................... 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 Lnea de vista vertical [6]. ............................................................................................................... 20
Figura 3. 5 Lnea de vista horizontal [6]........................................................................................................... 20
Figura 3.6 Triangulacin en visin estreo [8]. ................................................................................................ 21
Figura 3.7 Imagen que muestra la proyeccin de puntos sobre una superficie [9]. ........................................ 22
Figura 3.8 Cada punto es distinguible de otro dentro del patrn proyectado [9]. .......................................... 22
Figura 3.9 Imagen de profundidad capturada por la cmara [9]. ................................................................... 23
Figura 3.10 x es proporcional para el punto proyectado [9]. ....................................................................... 23
Figura 3. 11 Proceso de segmentacin y obtencin de articulaciones a partir de imgenes 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 mvil, 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 Representacin abstracta del concepto de OpenNI dividido en tres capas [14]. .......................... 31
Figura 3.18 Diagrama de comunicacin entre los dispositivos de procesamiento. .......................................... 35
Figura 3. 19 Mdulo serial bluetooth. .............................................................................................................. 35
Figura 3.20 Pines para transmisin y recepcin de datos a travs 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 estndar [16]. .................................................. 38
Figura 3.24 Diagrama de simulacin para movimiento de los servomotores. ................................................. 39
Figura 3.25 Diagrama esquemtico 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 Batera 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 diseado para la computadora. ................................................ 50
Figura 4.4 Mapa de bits a utilizar para copiar imgenes entregadas por el sensor......................................... 51
Figura 4.5 Algoritmo para obtener una imagen de profundidad. .................................................................... 52

iv

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 patrn infrarrojo emitido por el sensor de profundidad, obtenida a travs del nodo
Generador Infrarrojo. .................................................................................................................................... 56
Figura 4.11 Algoritmo para calibracin de usuario. ......................................................................................... 58
Figura 4. 12 Pose "Psi" para llevar a cabo el proceso de calibracin [14]. ....................................................... 58
Figura 4.13 Alineacin de las articulaciones adquiridas con imagen RGB. ...................................................... 60
Figura 4. 14 Representacin de un vector formado por un punto o articulacin 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 Traslacin de un vector hacia el origen. ...................................................................................... 67
Figura 4. 19 Clculo de ngulo entre dos vectores. .......................................................................................... 67
Figura 4.20 ngulos que forma la rotacin de un cuerpo en un sistema de coordenadas con respecto a otro
[17]. .................................................................................................................................................................. 69
Figura 4. 21 Sistema de rotacin de un cuerpo con referencia a un plano....................................................... 70
Figura 4. 22 Pose T que es el sistema de referencia para la rotacin de una articulacin [13]. ...................... 71
Figura 4. 23 Sistema de referencia para la rotacin del hombro derecho........................................................ 71
Figura 4. 24 Algoritmos para obtener el ngulo de rotacin de una articulacin. ........................................... 72
Figura 4. 25 Diagrama de flujo para la deteccin 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 Regin de inters(amarillo) de la imagen de profundidad. .......................................................... 77
Figura 4. 28 Pixeles que sern 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) Rectngulo que cubre el rea................................................................................................... 80
Figura 4. 31 Interfaz grfica de usuario de la aplicacin. ................................................................................. 82
Figura 4.32 Diagrama de flujo de la programacin del PIC18F4550. ............................................................... 85
Figura 4. 33 Diagrama de flujo de la interrupcin generada por la recepcin de datos a travs del modulo
UART. ................................................................................................................................................................ 86
Figura 4. 34 Diagrama de flujo de la rutina de interrupcin 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 Configuracin de un brazo robtico antropomrfico 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 eslabn para movimiento angular nmero 2.............................................................. 92
Figura 5. 6 Medidas del eslabn para movimiento angular nmero 1. ............................................................ 93
Figura 5. 7 Diseo final del prototipo del brazo robtico. ................................................................................ 95

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

Figura 5.9 Mxima apertura de la pinza. ......................................................................................................... 96
Figura 5. 10 rea de trabajo del brazo robtico. .............................................................................................. 96
Figura 5.11 Formas convexas detectadas. ....................................................................................................... 97
Figura 5. 12 Resultado de la deteccin de dedos. ............................................................................................ 97
Figura 5. 13 Resultado de la deteccin de dedos ............................................................................................. 97
Figura 5. 14 Posicin con brazo estirado. ......................................................................................................... 98
Figura 5. 15 Posicin con brazo flexionado. ..................................................................................................... 98
Figura 5. 16 Posicin con brazo semi -flexionado. ............................................................................................ 99
Figura 5. 17 Modelo de pieza cilndrica para pruebas del brazo robtico. ....................................................... 99
Figura 5.18 Distribucin de las piezas sobre mesa de madera. ...................................................................... 100
Figura 5. 19 Grfica del tiempo en completar la prueba. ............................................................................... 101
Figura A. 1 Habitacin 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
Figura A. 4 Usuario 5 (1.50metros)................................................................................................................. 128
Figura A. 5 Usuario 4 (1.60metros)................................................................................................................. 128

NDICE DE TABLAS
Tabla 3. 1 Caractersticas 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 Comparacin de libreras de libre acceso. ....................................................................................... 30
Tabla 3. 5 Caractersticas tcnicas de la batera 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 clculo de los ngulos. .......................................................................... 68
Tabla 4. 5 Prioridades del sistema en tiempo real. ........................................................................................... 84
Tabla 5. 1 Medidas y pesos del eslabn para movimiento angular nmero 2. ................................................ 92
Tabla 5. 2 Medidas y pesos del eslabn para movimiento angular nmero 1. ................................................ 93
Tabla 5. 3 Diseo final del prototipo del brazo robtico. ..................................... Error! Marcador no definido.
Tabla 5. 4 Resultados de las pruebas realizadas con el brazo robtico. ......................................................... 101
Tabla anexo 1 Costo total del proyecto. ........................................................................................................ 111

vi

Prlogo

Existen procesos industriales o laboratorios de investigacin qumica

donde al realizarse determinados trabajos, el personal o cientfico,
transporta y mueve sustancias u objetos peligrosos con las manos
exponindolo de forma peligrosa al entrar en contacto directo.
El objetivo de esta tesis consiste en construir el prototipo de un brazo
robtico 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 comnmente el
usuario pone en riesgo las manos al entrar en contacto con el objeto o
sustancia. Tambin puede contribuir en asistir operaciones quirrgicas
o procesos industriales de control. El proyecto es desarrollado usando
un dispositivo de ltima tecnologa como lo es Kinect.

vii

Introduccin
Los brazos robticos (tambin llamados brazos manipuladores) son comnmente
utilizados dentro de la industria en diferentes actividades como la transportacin
de piezas, ensamblado o diseo de componentes electrnicos. En el campo de la
medicina tambin se ha trabajado con brazos robticos, facilitando el trabajo a los
mdicos en operaciones quirrgicas. Los brazos manipuladores pueden ser
controlados mediante interfaces de usuario (palancas, botones, interfaces grficas,
etc.) o funcionar de forma autnoma. En el caso de los brazos autnomos se
requiere conocer las coordenadas dentro de un plano, del objeto que se quiera
transportar para implementar algn algoritmo que realice dicha labor. Para los
robots que se controlan mediante interfaces de usuario se requiere un tiempo de
respuesta favorable y precisin del robot para realizar una labor como la
transportacin de piezas.

Definicin del problema

Existen procesos industriales o laboratorios de investigacin 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 precisin, esto debido a
que existe la necesidad de sustituir el trabajo de transportacin de objetos que
comnmente 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 comnmente 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.

Justificacin
La presente tesis propone la construccin y programacin del prototipo de un
brazo robtico que sea controlado mediante el movimiento del brazo del usuario a
travs de una interfaz de usuario basada en el dispositivo Microsoft Kinect, el
brazo robtico debe imitar en tiempo real el movimiento del brazo del usuario,
mejorando el tiempo de respuesta, precisin y facilidad para controlar los brazos
manipuladores. El brazo robtico es construido para ayudar en tareas que
sustituyan el trabajo que comnmente 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 robtico tambin 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
robtico al punto deseado, adems se pretende innovar el control de brazos
manipuladores utilizando un dispositivo de ltima tecnologa como Kinect,
remplazando dispositivos que requieren mas recursos o son difciles de trabajar en
forma conjunta.

Objetivos del proyecto

General
Construir el prototipo de un brazo robtico integrado por tres grados de libertad y
una pinza de sujecin, programado para moverse de acuerdo a los movimientos
hechos por el brazo del usuario de forma simultanea, dichos movimientos del
usuario sern adquiridos a travs del sensor Microsoft Kinect .

Especficos
El diseo, construccin y programacin del brazo robtico 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 especficos establecidos
para realizar el trabajo se definen a continuacin:

Adquisicin 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 grfica de usuario que permita visualizar la
ejecucin del brazo del usuario, desplegando los grados desplazados por
cada articulacin.
Construccin del prototipo del brazo robtico utilizando servomotores para
el movimiento, permitiendo tres grados de libertad.
Establecimiento de comunicacin del sistema a travs del protocolo RS232
utilizado
para el envo de datos desde la computadora haca un
microcontrolador.
Programacin 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.

Captulo 1 Estado
del arte
Desde que fueron liberadas las diferentes libreras de programacin 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 ms
simples mecanismos de robtica hasta robots con mayor grado de complejidad en
cuanto a mecnica y programacin.

1.1 Control de un Robot ABB con Kinect

Estudiantes de Ingeniera Robtica que en el verano de 2011, en Suecia, usaron
el software de seguimiento de esqueleto del Kinect, para controlar un brazo
robtico 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 despus escribir
utilizando el robot.

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

1.2 Brazo robtico controlado mediante

gestos a travs de Kinect
En la Universidad Tsukuba (Ibaraki, Kanto, Japn), 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 cmaras, encargadas de transmitir en tiempo real informacin
sobre el movimiento y la forma de la mano, para despus ser duplicados en la
rplica robtica. Un detalle el cual ya parece haber sido resuelto por sus
desarrolladores es que no todas las manos humanas son iguales, por esta razn
cargaron al sistema con una gran base de datos repleta de manos, de forma que
slo es necesario encontrar una mano similar en forma y tamao para que el
brazo robot pueda operar sin inconvenientes [1].

1.3 Uso mdico del Kinect

Estudiantes de la Universidad de Washinton (EE.UU.) han querido ir ms all. Han
adaptado la tecnologa para realizar cirugas robticas asistidas en la vida real.
Este mtodo implica el uso de Kinect para ayudar a los cirujanos a utilizar las
herramientas cuando realicen una ciruga. En la actualidad, los cirujanos suelen
utilizar la robtica para intervenciones quirrgicas mnimamente invasivas. El
principal problema, con los mtodos actuales, es que los cirujanos no tienen
ninguna forma de palpar lo que estn haciendo. Si se mueve un instrumento
quirrgico en algo slido, el instrumento se detendr pero el mando de control
sigue en movimiento. El equipo de ingeniera elctrica de la universidad ha
resuelto este problema gracias al cdigo abierto de Kinect para asignar y
reaccionar a los entornos en tres dimensiones y enviar la informacin sobre el
entorno al usuario. Al usar Kinect se establecen "espacios electrnicos" que
restringen el movimiento de la herramienta quirrgica, 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 ciruga robtica sea fiable y prctica a largo plazo, permitiendo as a los
mdicos llevar a cabo fcilmente en las principales ciudades cirugas en pacientes
5

en pueblos pequeos y aislados. Chizeck asegura que esta idea se puede

extrapolar en catstrofes 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
quirfano, como puede ser la bsqueda de informacin sobre el estado de un
paciente en un ordenador. La realizacin de un escner por rayos X, ya que podra
manejar de forma remota el ordenador que controla el aparato. Adems de eso, se
evitara tener que lavarse y desinfectarse, como sucede ahora cada vez que utiliza
esa mquina [1].

1.4 Perro robot gua para ciegos

Un inteligente diseo de perro-robot le saca bastante provecho a la tecnologa del
Kinect, ya que su capacidad de reconocer el espacio y las distancias le convierte
en un preciso gua 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 dueo. Tambin
sube y baja escaleras si es necesario, por lo que es bastante verstil. 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 navegacin.

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

Captulo 2 Marco
terico
2.1 Sistemas en tiempo real
Es un sistema electrnico de procesamiento que interacta 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 simultnea, lo que se conoce como multitarea. Estos procesos
o tareas duran un tiempo determinado, dependiendo la aplicacin o la
determinacin 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 aplicacin o el
uso que tenga [2].
La figura 2.1 muestra la representacin de forma general de un sistema de
procesamiento digital, en el cual intervienen mnimo 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.

En el primer bloque se representa todas las variables que interactan con el

sistema, en el caso de un sistema electrnico, estas variables pueden ser
sensores debido a que estos interactan con la naturaleza o el medio, y adems
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 algn proceso o sea catastrfico para el
sistema.
En un sistema en tiempo real intervienen los siguientes factores para el tiempo de
respuesta:

Fsicos
-Capacitancias, inductancias, resistencias de los circuitos, etc
-Velocidad de propagacin de los medios de comunicacin digital
-Velocidad de procesamiento
-Etapas del sistema
Software
-Algoritmo
-Nivel de lenguaje(c++,asm,etc.)
-Compilador

Para los tipos de comunicacin digital en un sistema en tiempo real, los ms

comunes son los siguientes:

Serie
-USB
-RS232
-RS485
-Ethernet
Paralelo
-ICE
-PCI
-DB25
Inalmbricos
-Bluetooth
-Wifi

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 duracin 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 ecuacin 2.1.

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

tT =

(Ecuacin 2.1)

En donde:
tT = tiempo total de respuesta del sistema

= tiempo de etapa de procesamiento nmero

2.1.1 Sensores
Una parte fundamental en todo sistema de adquisicin de datos es el elemento
encargado de percibir la magnitud a medir. Los sensores son dispositivos capaces
de convertir una magnitud fsica como puede ser temperatura, presin, etc., en
una diferencia de potencial o una variacin de intensidad de corriente, es decir,
realizan una conversin de energas y suministran informacin sobre el estado y
tamao de la magnitud. Los sensores informan de su entorno y adems esa
informacin es cuantificable, es decir, medible por algn instrumento.

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

Que exista una propiedad en algn material que cambie en funcin de

esa magnitud
Preferiblemente esa funcin debe ser lineal para el rango en el que
estemos interesados, por ejemplo la relacin que se da en los conductores
entre su resistencia al paso de la corriente elctrica y la temperatura, es
decir a mayor resistencia, mayor temperatura.

En otras ocasiones existe una relacin entre una magnitud y un

fenmeno fsico
Si la relacin es predecible y estable, el fenmeno se puede usar como
base para la determinacin de la magnitud. En muchas ocasiones la
dificultad est en conseguir que la propiedad o fenmeno est en funcin
nicamente de la magnitud que queremos evaluar. Suele ocurrir que la
medida es funcin de varios factores, de tal manera que cualquier variacin
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
elctrica. De esta manera, y con el debido acondicionamiento, la seal de salida
puede ser tratada por un equipo digital de adquisicin de datos.
Las seales del mundo real son, en general, analgicas y varan 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
caractersticas propias y genera una tensin o intensidad determinada, por lo que
estas seales tienen que ser adaptadas para ser tratadas en una tarjeta de
adquisicin de datos.
En el tratamiento de imagen y sonido, los sensores ms utilizados son:

Micrfono: Capta la informacin sonora que se propaga por el aire y la

convierte a una seal elctrica.
Cmara: Capta la informacin visual y convierte la informacin en datos
digitales.

10

2.1.2 Acondicionamiento de la seal

El objetivo del acondicionador de seal es generar a partir de lo obtenido por los
sensores, una seal que sea aceptable por las tarjetas de adquisicin de datos.
Las funciones principales que va a tener que realizar el acondicionador de seal
son las siguientes:

Amplificacin: La seal proporcionada por los sensores suele ser de un

valor muy pequeo, por lo que debe ser amplificada con el fin de que pueda
ser detectada correctamente por la tarjeta de adquisicin de datos. La
amplificacin debe ser tal que las variaciones de la seal recorran todo el
margen de la tarjeta de adquisicin de datos. La amplificacin de las
seales, en su origen, reduce el ruido que les puede afectar en su
transmisin hasta la computadora.
Filtrado: Con el filtrado se pretende eliminar ruidos de frecuencia que
pueden hacer perder exactitud al sistema de adquisicin de datos. Lo ideal
es transportar la seal del sensor lo ms limpia posible a la tarjeta de
adquisicin.
Excitacin: Hay algunos sensores que necesitan de una excitacin en
corriente o voltaje, para producir la variacin proporcional a la magnitud a
medir.
Linealizacin: No todos los sensores tienen una variacin 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 Conversin analgica a digital

Un conversor analgico-digital, es un dispositivo electrnico capaz de convertir
una entrada analgica de voltaje en un valor binario, Se utiliza en equipos
electrnicos como computadoras, grabadores de sonido y de vdeo. Como
caractersticas ms relevantes de un convertidor analgico a digital estn:

Nmero de canales analgicos: Nos indica la cantidad de magnitudes

distintas que podemos adquirir con el mismo convertidor analgico-digital.
Generalmente disponen de un nico ADC y los diferentes canales se
generan por medio de un multiplexor analgico.
Velocidad de muestreo: Cuanto mayor sea la velocidad de muestreo
mejor representacin obtendremos de la seal analgica, en cualquier caso
la velocidad de muestreo debe ser siempre mayor que el doble de la
frecuencia de la seal que queremos muestrear, segn el Teorema de
Nyquist. El Teorema de Nyquist indica que la frecuencia de muestreo
mnima que tenemos que utilizar debe ser mayor que (2 fmax), siendo
11

fmax es la frecuencia mxima de la seal. Si utilizamos esa frecuencia de

muestreo, podremos reproducir posteriormente la seal a partir de las
muestras tomadas.

(a)

(b)

Figura 2. 3 (a) Seal original [3].

(b) Muestreo de seal utilizando teorema de Nyquist [3].

Consideremos una seal con una frecuencia de 100 Hz. El Teorema de

Nyquist indica que debemos utilizar una frecuencia de muestreo mayor que
200 Hz. Si utilizramos una frecuencia ms alta que la que nos dice Nyquist
obtendramos una representacin ms exacta de la seal de entrada. Sin
embargo, cuanta ms alta es la frecuencia de muestreo ms alto es el
nmero de muestras por segundo que se debern procesar, por lo que los
procesadores de seal debern ser ms potentes o realizar menos
procesamiento en cada muestra.

(Ecuacin 2.2)
Si utilizamos una frecuencia inferior aparece un fenmeno llamado
Aliasing. Esto significa que cuando intentamos reconstruir la seal aparece
una seal de frecuencia ms baja. Este fenmeno se presenta por el hecho
de que las muestras se pueden unir para crear una forma de onda de
frecuencia ms 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 analgico-digital suelen
indicar la velocidad de muestreo del ADC, a medida que aumenta el
nmero de canales que este debe atender disminuir el nmero de
muestras por segundo que podemos obtener en cada canal.

Resolucin: Viene dada por el nmero de bits del ADC que se utilizan para
representar cada muestra, a mayor nmero de bits del ADC la tarjeta ser
capaz de detectar variaciones menores en la seal. El nmero de distintos
niveles en que se divide la seal a convertir viene dada por 2n, siendo n la
12

longitud de palabra del conversor. Por ejemplo un conversor de 8 bits

tendr 256 niveles distintos, suponiendo un rango de entrada de 10V
proporcionara una resolucin de:
Resolucin

(.

(Ecuacin 2.3)

Rango de entrada: Indica los mrgenes entre los que debe estar la seal
de entrada para que pueda ser convertida. Las tarjetas de adquisicin de
datos suelen dar varias posibilidades que se pueden seleccionar por
hardware o por software.

Estas 4 caractersticas vienen a determinar la capacidad y la precisin de la tarjeta

de adquisicin:
A mayor nmero de canales mayor capacidad.
A mayor velocidad de muestreo mayor capacidad
A mayor resolucin mayor precisin
A menor rango de entrada mayor precisin, ya que se con los mismos bits
de resolucin se tendr que representar un menor rango.
El tiempo de conversin es el tiempo que tarda un ADC en muestrear,
sintetizar y entregar en el bus de datos el resultado de la conversin. El tempo
de conversin delimita la frecuencia mxima de muestreo:

Tmuestreo Tconversin

(Ecuacin 2.4)

Existen diversos tipos de ADC disponibles actualmente, la mayora de los cuales

tambin contienen el circuito para digitalizar seales analgicas. Los cuatro tipos
ms populares son:

ADC de aproximacin sucesiva: Este tipo de ADC compara la forma de

onda de la entrada de informacin 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
aproximacin sucesiva son generalmente precisos y rpidos, y
relativamente baratos de producir. Sin embargo, pueden ser lentos al
responder a cambios repentinos en la seal de entrada y son sensibles a
voltajes picos en la propia seal de entrada.
Tconversin= (n+1) (Tck)

(Ecuacin 2.5)

Tck= periodo de reloj utilizado en el ADC

13

ADC de rampa: Los ADC de rampa utilizan un capacitor conectado a un

voltaje de referencia. Este se carga durante un tiempo determinado a travs
del voltaje de entrada y despus se descarga a travs 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.
(Ecuacin 2.6)
Tconversin= (2n) (Tck)
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 rpido pero requiere 2n
resistencias exactas para un ADC de n bits. Esto hace el ADC flash caro, y
comercialmente no prctico 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 algn tipo de proceso o algoritmo computacional que
modifique la seal recibida. Una de las ventajas de utilizar sistemas
computacionales es que la mayor parte del procesamiento de la seal reside en la
programacin, permitiendo realizar modificaciones de forma ms rpida y
econmica 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 podran ser consumidos en la modificacin de
las partes tangibles del sistema.
Ventajas de utilizar sistemas de procesamiento digital:
-Fciles y confiables para el procesamiento digital
-Mayor inmunidad al ruido
-Solo se requiere modificar el software y no el hardware

14

Multiprogramacin
Es la ejecucin de dos o ms procesos de manera aparentemente simultnea
utilizando un CPU y sus perifricos. 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 simultnea utilizando un solo CPU.

Figura 2. 4 Multiprogramacin

Sistema operativo
Se encarga de administrar los recursos de cada proceso, tiempo de ejecucin de
cada proceso, espacio de memoria, etc. Tambin es la capa que permite al
usuario ejecutar aplicaciones sin necesidad de conocer y programar la capa
fsica(hardware), un sistema operativo en tiempo real es comnmente utilizado en
dispositivos de procesamiento como microcontroladores, DSP, FPGA,
normalmente se denota con las siglas RTOS(sistema operativo en tiempo real).

15

2.1.5 Clasificacin de los sistemas en tiempo real

Los sistemas en tiempo real se pueden dividir segn los errores que se puedan
presentar:
Crticos: si no se cumplen con los tiempos establecidos se destruye el
sistema y/o causa una catstrofe al medio o al usuario.
No crticos: 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 dao al
sistema, pero la aplicacin queda inservible.

El sistema desarrollado en la presente tesis es clasificado dentro de la categora

de sistemas en tiempo real no crticos, debido a que el sistema puede tolerar que
los resultados no se obtengan en los tiempos establecidos, en este caso las
imgenes 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 imgenes con un tiempo
superior a los movimientos del usuario, los cuales son capturados a travs del
Kinect.

16

Captulo 3
Descripcin del
Hardware
El proyecto tiene como base al sensor Microsof Kinect, el cual enva datos que se
actualizan constantemente, los cuales determinan los movimientos del brazo
robtico cuya estructura cuenta con tres grados de libertad. Cada grado est
limitado por el movimiento mximo 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.

17

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

Pose de calibracin: es necesaria para poder iniciar el movimiento del brazo

y poder controlarlo.
Movimiento del brazo derecho: es el control del brazo robtico, 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
robtico.
Gesto de finalizacin: gesto predeterminado para finalizar el movimiento del
brazo.

3.1 Sensor de movimiento y obtencin de

datos
Kinect es un dispositivo electrnico que se constituye de dos sensores: una
cmara infrarroja utilizada para la deteccin de profundidad, y una cmara RGB
para imgenes a color [4]. La resolucin para las cmaras es de 640*480 pixeles
con 11bits de resolucin y 640*480 pixeles con 32 bits de resolucin para la
cmara de profundidad y de color respectivamente. La velocidad de envo es de
30 tramas por segundo para ambas cmaras. La cmara de color RGB soporta
alta resolucin 1280*1024 pero la velocidad de envo disminuye a 15 tramas por
segundo. En adicin, el sensor Kinect contiene un arreglo de cuatro micrfonos,
adems de una base motorizada que puede rotar el sensor hacia arriba o haca
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.-Cmara RGB
3.-Arreglo de micrfonos
4.-Base
Figura 3.2 Principales componentes del sensor Kinect [5].

18

1. Sensor de profundidad que consiste en un proyector lser infrarrojo y un

sensor monocromtico, ambos trabajan en conjunto para obtener imgenes
de profundidad en un espacio 3D bajo condiciones donde no exista luz
ambiental.
2. Cmara RGB con 32 bits de resolucin de 640*480 pixeles a 30 tramas por
segundo. Esta cmara obtiene imgenes a color en dos dimensiones.
3. Arreglo de cuatro micrfonos localizados en la parte baja del sensor, de
forma horizontal. Estos micrfonos son utilizados para el reconocimiento de
voz, ya que cuentan con herramientas de gran ayuda para el tratamiento de
audio como lo son: localizacin de la fuente acstica, supresin de
ambiente de ruido, y cancelacin del eco. La trama de datos para audio en
los cuatro micrfonos es de 16 bits a 16khz.
4. Base motorizada que sirve para establecer la lnea 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 milmetros de objetos o personas con referencia al sensor.
Tambin permite detectar a usuarios (mximo 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.
Cmara RGB: permite capturar imgenes a color en un espacio 2D con
resolucin de 640*480 pixeles.
Arreglo de micrfonos: 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 caractersticas para el correcto funcionamiento del

sensor.
Tabla 3. 1 Caractersticas del sensor.

Lnea de vista horizontal

57
Lnea de vista vertical
43
Rango de movimiento de la base 27
motorizada
Rango del sensor de profundidad

1.2m a 3.5m

19

Las caractersticas mencionadas en la tabla 3.1 se refieren a:

Lnea de vista horizontal: ngulo mximo de proyeccin que forman los

vrtices de la superficie que abarca el sensor de forma horizontal.
Lnea de vista vertical: ngulo mximo de proyeccin que forman los
vrtices 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 lnea de vista del sensor de forma horizontal y

vertical en la figura 3.4, tambin se observa la distancia mnima y mxima que
cubre el sensor, estableciendo as el rea que deber ser ocupada por el usuario.

Figura 3. 5 Lnea de vista horizontal

[6].

Figura 3. 3 ngulo de movimiento

para la base [6].

Figura 3. 4 Lnea de vista vertical

[6].

20

3.1.1 Sensor de profundidad

Basa su funcionamiento en una tcnica llamada luz estructurada, la cual consiste
en la proyeccin de un patrn de puntos infrarrojos sobre una superficie, al hacer
corresponder la imagen captada con el patrn original, es posible triangular la
posicin de cada pxel y determinar su profundidad con respecto al plano
perpendicular a la cmara [7] .

Emisin del patrn de puntos infrarrojos

Cuando una superficie es iluminada por una onda de luz, cada punto acta como
una fuente de onda esfrica. 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 tecnologa usada por Kinect para adquirir la imagen de profundidad es llamada
LightCoding, la cual utiliza un emisor infrarrojo para la proyeccin del patrn de
puntos, los cuales son invisibles para el ojo humano. Cada punto del patrn esta
hecho para que sea diferente a los dems, de esta forma, la cmara infrarroja lee
la luz codificada y ejecuta un sofisticado algoritmo de procesamiento paralelo para
descifrar el cdigo de la luz y poder generar una imagen de profundidad. El
mtodo es sensible en luz ambiental [7].

Triangulacin
En visin por computadora, la triangulacin se refiere a el proceso para determinar
un la distancia de un punto en un espacio 3D a partir de la visin de dos o mas
imgenes. La figura 3.6 muestra la geometra epipolar de un par de cmaras de
visin estreo.

Figura 3.6 Triangulacin en visin estreo [8].

21

Un punto P es proyectado en un espacio tridimensional, que pasa por el punto

focal de cada cmara, lo que resulta en dos puntos correspondientes de imagen,
si estos puntos son conocidos y la geometra de la imagen es conocida, la
proyeccin de esas dos lneas puede ser determinada. Usando algebra lineal se
puede determinar la distancia de ese punto. Esta tcnica es empleada por el
sensor Kinect para calcular la profundidad de los objetos y obtener una
reconstruccin 3D, la triangulacin es realizada por cada punto entre una imagen
virtual y el patrn de observacin [7].
El proceso de triangulacin para obtener la profundidad de los objetos es
mostrado a continuacin:
1.- Patrones de luz son proyectados en la escena

Figura 3.7 Imagen que muestra la proyeccin de puntos sobre una superficie [9].

2.- Los patrones son distinguibles uno de otro

Figura 3.8 Cada punto es distinguible de otro dentro del patrn proyectado [9].

22

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

Figura 3.9 Imagen de profundidad capturada por la cmara [9].

4.- x es proporcional para la profundidad del objeto

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

23

Imgenes de profundidad
El sensor Kinect entrega imgenes de profundidad a una velocidad de 30 tramas
por segundo, con una resolucin de 640*480 pixeles. Los datos de profundidad
son representados en un espacio de color RGB o YUV (dependiendo la
configuracin), 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 nmero 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
3 bits de 8

G
8 bits

B
0 ID de usuario

A
255

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

YUV( 2 bytes por pixel)

11bits/16bits valores

24

3.1.2 Deteccin y seguimiento de usuario

Cuando se adquieren datos a travs de la cmara de profundidad, imagen con la
informacin de la distancia de los objetos o usuario, esta imagen es analizada
para extraer informacin que est relacionada con el usuario, su posicin y la pose
realizada. El sensor contiene dentro de su software un algoritmo de deteccin que
consiste en dividir el cuerpo del usuario en 31 partes que son reconocidas en un
plano tridimensional. Una representacin del proceso de deteccin de usuario se
muestra en la figura 3.11.

Figura 3. 11 Proceso de segmentacin y obtencin de articulaciones a partir de imgenes de profundidad [11].

El anlisis de imgenes de profundidad tiene ventajas sobre el anlisis de

imgenes a color, las imgenes 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
imgenes a travs de la cmara de profundidad y estas sean ms fciles de
analizar que las imgenes a color. Para segmentar la imagen del cuerpo del
usuario en diferentes imgenes se utiliza en clasificador de imgenes, cuyo
25

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 decisin de que imagen corresponde
a la imagen del usuario se establecen diferentes caractersticas. Una caracterstica
esta definida como una funcin f(I,x) que define una imagen I y una posicin x,
adems de un parmetro que describe las caractersticas de la imagen dentro
del espacio tridimensional, a travs de estas caractersticas, 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 especficos 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. Tcnica para encontrar eficiencia en la densidad.
3. Algoritmo que obtiene la aproximada localizacin de los puntos o
articulaciones.
La deteccin 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).

26

Limitaciones de la deteccin de usuario

La deteccin y seguimiento de usuario que proporciona Kinect es precisa y de
cierta forma confiable, aunque tambin sufre algunas limitaciones. Estas
limitaciones son insignificantes cuando la aplicacin del sensor es exclusivamente
en software, pero cuando se aplica a campos como el de la robtica, estas
limitaciones pueden ser vitales para la aplicacin. Las principales limitaciones en
cuanto a la deteccin y seguimiento de usuario son las siguientes:

No trabaja bajo la luz solar (hardware)

El sensor Kinect proyecta una luz infrarroja a travs 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 cmara que detecta la proyeccin de puntos infrarrojos es deshabilitada
para poder detectar los patrones emitidos por el emisor. Esto propicia que
exista una muy pobre deteccin de profundidad en reas que estn
expuestas a la luz solar.

No detecta usuarios dentro de superficies transparentes y reflejantes

(hardware)
La deteccin en superficies reflejantes o transparentes es tambin difcil
cuando se utilizan sensores pticos, como es el caso del sensor Kinect.
Este factor se debe a que la mayora de los sensores pticos reflejan la luz
sobre la superficie, esta reflexin puede ser alta o baja y puede afectar en
las lecturas del sensor.

La resolucin de la cmara limita el reconocimiento de gestos

demasiados precisos, como pueden ser gestos realizados con los
dedos a determinada distancia (hardware)
La resolucin de la cmara de profundidad se limita a 640*480 pixeles con
pocos centmetros de resolucin, 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 crculo con la misma. Sin embargo si una pequea
rea del cuerpo es observada, por ejemplo la mano del usuario, gestos tan
especficos como los realizados por esta , no pueden ser reconocidos

27

debido a que la regin de inters de la imagen que debe ser analizada, es

pequea en comparacin con la imagen del cuerpo.

El Kinect debe de mantenerse fijo sobre una base o superficie

(hardware)
Para simplificar la deteccin y seguimiento de usuario, el sensor debe estar
totalmente fijo, esto debido a que cuando el sensor se encuentra sobre una
superficie mvil, puede detectar determinados objetos como si estos
estuvieran en movimiento y/o confundirlos con siluetas humanas para
despus entregar resultados incorrectos. La figura 3.13 muestra los datos
errneos que entregara el sensor Kinect cuando se encuentre montado
sobre una superficie mvil, algunos objetos son detectados como usuarios
debido a que cuando el sensor se mueve, la imagen obtenida aparenta el
movimiento del objeto.

Figura 3.13 Imagen que muestra cuando el sensor se

encuentra sobre una superficie mvil, algunos objetos son
detectados como usuarios siendo marcados con determinado
color [12].

La solucin a este problema es la calibracin que lleva a cabo el usuario

para confirmar que se trata de una silueta humana.

La inicializacin para la deteccin y seguimiento de usuario toma

determinado tiempo (software)
Otro problema importante es la inconsistente deteccin 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.
28

Figura 3.14 Imagen 1

Figura 3.16 Imagen 2

Figura 3.15 Imagen 3

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 deteccin de usuario, a diferencia que se ilumina de color azul,
debido a que el sensor asume que es un nuevo usuario.

3.1.3 Libreras de libre acceso para la programacin

de Kinect
Cuando el sensor Kinect sali a la venta, no existan controladores ni libreras
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, cmara RGB y acceso al arreglo de micrfonos. Debido a que Microsoft
no fue el creador del controlador principal del sensor Kinect, se han desarrollado
diferentes libreras de programacin de libre acceso compatibles con el sensor
Kinect.
En la tabla 3.4 se muestran las diferentes libreras de libre acceso que se han
desarrollado para el sensor Microsoft Kinect, algunas son compatibles con
distintos lenguajes de programacin y plataformas de desarrollo.

29

Tabla 3. 4 Comparacin de libreras de libre acceso.

Nombre
Open Kinect/
Libfreenect

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

Plataformas
Linux, Windows,
Mac OS X

Windows

Robot Operating
System

Pyhon, C++

UNIX

OpenNI/NITE
Middle-ware

C,C++,C#, Java

Windows,
Linux,
Ubuntu, Mac OS X

CL SDK NUI and

driver

C++,C#, Visual
SDK Microsoft Kinect

Caractersticas
Imgenes de color y
profundidad, control de
la base motorizada y del
led.
Imgenes de color y
profundidad, control del
led y de la base
motorizada.
Imgenes de color y
profundidad.
Acceso a base
motorizada.
Identificacin de
usuario, deteccin de
gestos, seguimiento y
orientacin de
articulaciones de
usuario, imgenes de
color y profundidad.
Identificacin de
usuario, deteccin de
gestos, seguimiento de
articulaciones de
usuario, imgenes de
profundidad y de color.

Trabajando con ejemplos de las libreras de OpenNI y las libreras de desarrollo

de Microsoft para Kinect, se opt por elegir a OpenNI para la programacin del
sensor. Aunque la informacin para la programacin 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
rotacin de las articulaciones del usuario detectado, instalacin en plataformas
como Windows y Mac, distintos lenguajes de programacin (Java, C++, C#) y libre
uso de las libreras de programacin para cualquier implementacin comercial. La
programacin entre estas dos libreras es totalmente diferente, pero se mantienen
los mismos conceptos cuando se trabaja con Kinect como lo son: imgenes de
profundidad, imgenes a color y seguimiento de usuario.

30

Descripcin de las libreras de uso libre para programar

el sensor
OpenNI (Interfaz natural de uso libre) es un conjunto de libreras multiplataforma y
multilenguaje para desarrollar aplicaciones utilizando interfaces naturales como e
sensor Kinect. Las libreras fueron desarrolladas por una organizacin llamada
OpenNI que fue fundada por la empresa Israel PrimeSense, la compaa que
otorg la licencia a Microsoft para construir el sensor Kinect [13]. El principal
propsito de OpenNI es establecer un desarrollo de software estndar que habilite
la comunicacin con:

Sensores de audio y visin: en esta tesis de utiliza el sensor Microsoft

Kinect, pero OpenNI puede utilizarse con el sensor desarrollado por
PrimeSense llamado XAzus.
Percepcin de audio y video(los componentes del software analizan los
datos de audio y video que son capturados a travs de las imgenes), por
ejemplo software que recibe datos visuales como imgenes, regresando la
localizacin de la palma de la mano.

El estndar de OpenNI es aplicado al desarrollo de aplicaciones de interaccin

natural para realizar un seguimiento dentro de una escena tridimensional, estos
datos son capturados por medio de las imgenes de profundidad obtenidas por el
sensor. Las libreras de programacin de OpenNI se puede describir en tres
capas (vase 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 libreras que
interpretan y analizan los datos del sensor. Finalmente la capa superior contiene el
software que implementa las aplicaciones de interaccin natural.
.

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

La forma en la que trabaja OpenNI es a travs de la produccin de nodos. La

produccin de nodos es el establecimiento de componentes que forman los datos
del sensor que sern utilizados en las aplicaciones.
OpenNI clasifica la produccin de nodos en dos categoras:

Produccin de nodos relacionada con el sensor

Produccin de nodos relacionada con las libreras

Los nodos relacionados con el sensor son los siguientes:

Dispositivo: Un nodo que representa un dispositivo fsico (por ejemplo un

sensor de profundidad o una cmara 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 algn sensor que capture imgenes en tercera
dimensin y est certificado por la compaa OpenNI.
Generador de imgenes: Nodo que genera imgenes a color, debe ser
implementado en algn sensor que obtenga imgenes a color y est
certificado por la compaa OpenNI.
Generador infrarrojo: Nodo que genera imgenes infrarrojas.
Generador de audio: Genera cadenas de audio.

Los nodos relacionados con las libreras de OpenNI son los siguientes:

Generador de gestos: genera eventos en la aplicacin 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
posicin.
Generador de usuario: representacin del cuerpo(o parte del cuerpo) en
una escena tridimensional.

Calibracin
Para la produccin del nodo de generacin 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 cmara de profundidad no estn alineados con
32

respecto a los datos de la cmara de color. La calibracin se utiliza para poder

utilizar los datos de profundidad, junto con los de la imagen de color. Tambin
optimiza el seguimiento de usuario, debido a que ofrece una mayor precisin a
diferencia de no utilizar la mencionada calibracin.

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 tecnologa, adems de que la adquisicin de datos que se obtiene del
sensor es a travs del puerto USB(bus serial universal) y todas las libreras 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 robtico requiere de
un dispositivo ajeno a la computadora personal para generar el movimiento de los
servomotores (modulacin por ancho de pulso) que conforman la estructura del
robot, este dispositivo debe contar con algn protocolo de comunicacin que
facilite la recepcin 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 simultnea.

3.2.1 Descripcin de los dispositivos de

procesamiento
Computadora personal para procesamiento de datos del sensor
De acuerdo con las especificaciones de los desarrolladores de las libreras
utilizadas para la programacin del sensor Kinect [13], las caractersticas 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

33

Para el presente proyecto se utiliz una computadora personal con procesador

Intel i7 a 2.20 GHz, y sistema operativo Windows 7 edicin Ultmate, debido a que
es la computadora personal con la que se cuenta y cumple las exigencias para la
programacin del sensor.
Microcontrolador PIC18F4550
Como se mencion anteriormente el control del robot requiere un dispositivo de
procesamiento que sea capaz de establecer una comunicacin con la
computadora para la recepcin 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 caractersticas que se requieren para la
recepcin, procesamiento, y generacin de seal de movimiento de los motores,
aadiendo que se cuenta con experiencia en la programacin 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 caractersticas del PIC18F4550 y a continuacin
se describen los recursos del PIC que se utilizan en el presente trabajo:

Comunicacin serial sncrona (USART): utilizada para establecer la

recepcin de datos que provienen desde la computadora a travs 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
electrnico externo, en nuestro caso se utilizan enviar los estados de voltaje
alto y bajo para la seal 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 recepcin de datos
provenientes de la computadora, en un tiempo que sea mnimo y contribuya
a la rpida respuesta del movimiento del brazo robtico.

34

3.2.2 Comunicacin entre la computadora y

microcontrolador PIC18F4550
Un sistema en tiempo real necesita de un protocolo de comunicacin que permita
transportar los datos enviados hacia el dispositivo final (en nuestro caso micro
controlador), desde la computadora. Este protocolo debe favorecer al rpido
transporte de los datos para evitar retrasos en los tiempos de respuesta.
El protocolo que establece la comunicacin entre la computadora y el micro
controlador, el cual es el encargado de mover el brazo robtico, es el protocolo
RS232, dicho protocolo es uno de los mas usados dentro de los sistemas en
tiempo real, adems de que permite fcilmente transmitir datos como caracteres
de forma rpida, eficiente y sin fallas. La figura 3.18 muestra el diagrama que
representa la comunicacin entre los dispositivos de procesamiento.

Figura 3.18 Diagrama de comunicacin entre los dispositivos de procesamiento.

En este proyecto se utiliza comunicacin serial RS232 para enviar los datos de la
computadora al microcontrolador, pero se realiza de forma inalmbrica utilizando
el mdulo bluetooth de la computadora para el envo de datos y el modulo serial
inalmbrico que se muestra en la figura 3.19 para la recepcin por parte del PIC,
mdulo basa su funcionamiento en el protocolo bluetooth, pero entrega los datos
de forma serial a una velocidad de 9600 baudios por segundo. La comunicacin
entre los dispositivos de procesamiento es totalmente inalmbrica como se
ejemplifica en la figura 3.18, en donde se envan los datos por el mdulo bluetooth
de la computadora y ser reciben por el modulo serial que se encarga de entregar
los datos al microcontrolador.

Figura 3. 19 Mdulo serial bluetooth.

35

Este mdulo se adapta a cualquier bluetooth de computadora como si se tratara

de un dispositivo de este protocolo que se encuentra en celulares, cmaras, 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 mdulo, como si se
tratara de un puerto fsico 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 comunicacin ayuda en el proyecto para la supresin de cables en la
comunicacin entre la computadora y el PIC18F4550, adems de que contiene
todas las ventajas del protocolo bluetooth, como la distancia de alcance y la
compatibilidad con cualquier dispositivo que maneje comunicacin serial. Cabe
destacar que aunque el mdulo base su funcionamiento en el protocolo bluetooth,
no es necesario conocer propiedades demasiado adentradas acerca del protocolo
bluetooth, ni realizar ningn tipo de configuracin en la programacin interna del
mdulo.
En la figura 3.20 se muestran los pines del modulo, los cuales corresponden a la
conexin a VCC, GND y los pines de envo TX, y recepcin RX, de datos para el
dispositivo final, que en nuestro caso es el PIC18F4550.

Figura 3.20 Pines para transmisin y recepcin de

datos a travs del modulo serial bluetooth [15].

3.3 Servomotores
Es un motor de corriente continua que tiene la capacidad de ser controlado en una
determinada posicin. El motor es capaz de ubicarse en cualquier posicin dentro
de un rango de operacin (generalmente de 180) y mantenerse estable en dicha
posicin. Los servomotores se suelen utilizar en robtica, automatizacin, debido a
su gran precisin 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

36

motor gira en un sentido a su velocidad mxima. Si el voltaje aplicado sus

dos terminales es inverso, el sentido de giro tambin 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 potencimetro colocado en el
eje de salida del servomotor que se utiliza para conocer la posicin angular
del motor.
Circuito de control: Es una placa electrnica que implementa una
estrategia de control de la posicin por realimentacin. Para ello, este
circuito compara la seal de entrada de referencia (posicin deseada) con
la posicin actual medida por el potencimetro. La diferencia entre la
posicin actual y la deseada es amplificada y utilizada para mover el motor
en la direccin necesaria para reducir el error.
En la figura 3.21 se muestran los 4 elementos mencionados anteriormente,
adems se muestra la carcasa en donde vienen incluidos estos elementos y
en conjunto forman al servomotor.

Figura 3.21 Elementos que conforman un servomotor [16].

3.3.1 Principio de funcionamiento

Los servos disponen de tres cables (Figura 3.22): dos cables de alimentacin
(positivo y negativo) que suministran un voltaje 4.8-6V y un cable de control que
indica la posicin deseada al circuito de control mediante seales PWM
(Modulacin por ancho de pulsos).

Figura 3.22 Cables de un servomotor [16].

37

Las seales PWM (modulacin por acho de pulso) utilizadas para controlar los
servos estn formadas por pulsos positivos cuya duracin es proporcional a la
posicin 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,
tambin existen servos que se pueden mover en un rango extendido de 180 y sus
pulsos de control varan entre 0.5 y 2.5ms. Antes de utilizar un servo se debe
comprobar experimentalmente su rango de movimiento para no daarlo. Para
mantener fijo un servo en una posicin habr que enviar peridicamente el pulso
correspondiente; ya que si no recibe seales, el eje del servo quedar libre y se
podr mover ejerciendo una leve presin.

3.3.2 Control de un servomotor

Para controlar un servo, se le ordena un cierto ngulo, medido desde 0 grados,
envindole 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 lmites 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
ms. El factor limitante es el tope del potencimetro y los lmites mecnicos
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 tambin nombrado pulso en alto para que un
servomotor se posicione en 90 grados (posicin 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 estndar

[16].

38

3.4 Tarjeta de control para los servomotores

La figura 3.24 muestra la conexin que se realiz para la simulacin del
movimiento de los motores, dentro del esquema se encuentra la conexin del
puerto del microcontrolador del cual se utilizan los pines b0 a b3 para conectar los
motores. La conexin 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 inalmbrico bluetooth.

Figura 3.24 Diagrama de simulacin para movimiento de los servomotores.

3.4.1 Diagrama esquemtico del circuito impreso

para la tarjeta de control
Una vez realizadas las pruebas correspondientes para el movimiento de los
servomotores y recepcin de datos a travs del modulo UART, se implement el
siguiente diseo de la tarjeta controladora, la cual contiene el PIC18F4550 como
unidad central de control y el modulo serial bluetooth para la recepcin de datos.
El diseo del circuito esquemtico y PCB, fue realizado con el software ALTIUM
Designer, implementando un modelo de PCB de doble capa. La figura 3.25
muestra el diseo final de la tarjeta controladora.

39

Figura 3.25 Diagrama esquemtico de tarjeta controladora para los servomotores.

En las figuras 3.26 y 3.27 se muestran las capas que forman el diseo del circuito
impreso basado en el diagrama esquemtico que corresponde a la tarjeta
controladora de servomotores incluyendo las conexiones para los servomotores y
el mdulo de comunicacin entre la computadora y el microcontrolador.

Figura 3. 26 Capa superior del circuito impreso.

Figura 3. 27 Capa inferior del circuito impreso.

40

En la figura 3.28 se muestra el diseo fsico del circuito impreso, indicando las
medidas que corresponden a la tarjeta controladora para los servomotores del
brazo robtico e indicando los componentes ms importantes que constituyen a la
tarjeta.

Figura 3.28 Tarjeta de control para los servomotores.

Batera para los servomotores

Los servomotores utilizados en el presente proyecto requieren una fuente de
alimentacin independiente al voltaje suministrado al PIC18F4550. La fuente de
alimentacin que se utiliza para alimentar a todos los motores que componen el
brazo manipulador es una batera de acido-plomo. Las bateras de acido-plomo
son confiables, de larga duracin, adems de que no requieren algn tipo de
circuitera que represente mayores gastos o espacio dentro del circuito. La
mayora de las bateras tienen una determinada duracin, dependiendo de la
corriente y voltaje demandados por el circuito. En la figura 3.29 se muestra la
batera utilizada para los servomotores, y en la tabla 3.5 sus caractersticas.
Tabla 3. 5 Caractersticas tcnicas de la batera acido-plomo.

Sistema de proteccin para carga excesiva

Terminales de 1.06 cm
Soporta hasta 300 Centgrados
0.78 kg
6v a 4Ampers/hora

Figura 3.29 Batera de acido-plomo.

41

La duracin para la batera de forma continua es la indicada a continuacin:

Duracin =

!"

( %

#$ %$ &$
"

$)

= 3.3 ,-./ (Ecuacin 3.1)

Para la duracin de manera discontinua se tom en cuenta la grfica de descarga

de la batera (ver anexo 3.1) donde indica que para una corriente de 1200mA de
forma no constante se obtendr una duracin de 2 a 3 horas de forma no continua.

42

Captulo 4
Diseo del software
Como se mencion anteriormente, el trabajo realizado en esta tesis es un sistema
en tiempo real, el brazo robtico 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 Descripcin del software

En el diagrama mostrado en la figura 4.1 se marcan de color azul los procesos que
sern 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 ejecucin.
En nuestro primer proceso o inicio del algoritmo del sistema, se inicializa el sensor,
en el segundo proceso se adquieren los datos de profundidad, despus se entra
en el proceso calibracin de usuario, hasta que sea completado de forma correcta
se puede trabajar con los datos de usuario. El siguiente paso es el clculo del
movimiento del brazo del usuario, es aqu donde se aplica el algoritmo de
seguimiento del brazo que controla el robot. La segunda condicin que existe
dentro del sistema es la deteccin del gesto de finalizacin, dato que ordena al
microcontrolador que realice la detencin del brazo robtico, esta condicin 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 condicin de finalizacin, la diferencia entre la condicin
marcada en verde y la marcada en azul, radica en que el proceso marcado de
verde es aplicado por el microcontrolador, si sta condicin se cumple, el
microcontrolador detiene el brazo robtico dando fin a la aplicacin, en caso
43

contrario se genera el movimiento del robot, y despus regresa nuevamente al

proceso de adquisicin de imgenes, que propicia la repeticin del ciclo del
algoritmo, el cual llega a su fin cuando el gesto de finalizacin es detectado.

Figura 4.1 Diagrama de flujo del software del sistema.

44

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 travs 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 robtico 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 continuacin:

Inicializacin del Kinect: el sensor es la variable de entrada que interacta

con el ambiente y entrega datos del mismo (en nuestro caso usuario),
adems 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 adquisicin de mltiples variables,
debido a los diferentes datos que entrega el Kinect.
Adquisicin de imgenes y datos de profundidad: se capturan todos los
datos que enva el sensor hacia la computadora, permitiendo utilizarlos para
la implementacin de nuestro algoritmo de movimiento.
Proceso de calibracin: no todos los usuarios presentan el mismo tamao
de extremidades del cuerpo, motivo por el cual se realiza un proceso de
calibracin que permite la correcta lectura de los datos del usuario.
Seleccin de articulaciones a utilizar: Microsoft Kinect entrega datos
referentes a las articulaciones del cuerpo del usuario, sin embargo no todos
45

estos datos se utilizan en el proyecto, dentro de esta etapa se adquieren

nicamente las articulaciones que servirn para realizar el clculo del
movimiento del brazo derecho y mano izquierda del usuario, las dems son
descartadas.
Clculo de movimientos del brazo: se implementan los algoritmos
basados en cinemtica directa, que utilizan datos procesados por etapas
anteriores y se calculan los datos finales que sern enviados a la siguiente
etapa.
Transductor o etapa del movimiento del brazo robtico: un sistema en
tiempo real , aplica una accin en el ambiente despus de procesar las
variables de entrada, dentro de esta etapa se explica el movimiento del
brazo robtico, el cual es efectuado a travs del microcontrolador
PIC18F4550.

4.2 Inicializacin del Kinect

Realizando investigacin sobre las libreras 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 construccin del dispositivo, por lo que estas libreras 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 libreras, factor que puede contribuir en una futura
implementacin comercial.
Las principales ventajas entre OpenNI y el sotfware de Microsoft se muestran en
la tabla 4.1. En relacin al seguimiento de usuario, una de las ventajas de OpenNI
que es factor en este trabajo, es la obtencin de la rotacin 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 libreras para el seguimiento
exclusivo de las manos y reconocimiento de gestos con las mismas. Algunos otros
factores que tambin influyen en la eleccin de OpenNI son el menor consumo de
CPU, uso de mltiples lenguajes de programacin y de plataformas como Linux o
Mac. En cuanto a las desventajas que pueden presentarse dentro de OpenNI se
encuentran la pose de calibracin que se necesita para trabajar con los datos de
usuario y la confusa instalacin y falta de informacin por parte de las libreras
utilizadas. En la tabla 4.2 se enlistan las desventajas tanto del SDK de Microsoft
y de OpenNI.
46

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

Ventajas

SDK de Microsoft

OpenNI

Soporte par audio

Soporte para motor

Licencia de uso comercial

Framework para seguimiento
de manos independiente.

Seguimiento de usuario
No necesita pose de
calibracin
Mejor tratamiento de
articulaciones
ocluidas.

Seguimiento de usuario
Calcula rotacin de las
articulaciones
Soporta Windows, Linux y
Mac.

Instalacin simple

Soporte para adquirir las

imgenes infrarrojas
Sistema de reconocimiento de
gestos con las manos.
Compatible con varios
sensores.

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

Desventajas

SDK de
Microsoft

OpenNI

Licencia
nicamente para
uso no comercial.
Seguimiento de
usuario completo
(no permite seguir
nicamente las
manos)
No calcula la
rotacin de las
articulaciones.
Exclusivamente
para Windows 7
Consume mas
CPU que OpenNI

Carece de rotaciones para

manos, pies y clavcula.
Articulaciones ocluidas no
son compatibles.

Laboriosa instalacin

47

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 cmara de color
RGB, se debe utilizar el nodo denominado Generador de Imagen que permite
generar las imgenes a color por parte de la cmara del sensor y adquirir las
imgenes 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 configuracin con extensin .xml, este archivo contiene los nodos que
sern utilizados en la aplicacin.
La configuracin 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 parmetros:

<licencias> indica la licencia que se utilizada para el uso libre de OpenNI,

la cual se obtiene de forma gratuita en la pgina de OpenNI , y permite el
acceso a todos los nodos disponibles en las libreras.
<Produccin de nodos> en esta etiqueta se deben incluir todos los nodos
que se desean producir a travs del sensor, especificando las
caractersticas deseadas.
<Tipo de nodo = nombre> en esta seccin se debe indicar el tipo de nodo
que se va a utilizar (profundidad, imagen, imagen de infrarrojo, audio, etc),
adems de que se aade un nombre que identifica al nodo.
<Configuracin > la configuracin de cada nodo es establecida a travs de
esta etiqueta, donde se indican las caractersticas de cada nodo, si se
desea utilizar cualquiera de las cmaras del sensor, se debe establecer la
velocidad de envo y la resolucin.

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 ubicacin 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 travs de imgenes 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
48

(Generador de seguimiento de manos y Generador de gestos) sirven de apoyo

para utilizar las libreras que proporciona OpenNI y dedicadas exclusivamente
al seguimiento de manos y deteccin de gestos con las manos, herramienta
que se implementara para definir un gesto de finalizacin del movimiento del
brazo robtico.
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

configuracin de este archivo es el establecimiento de los nodos a utilizar y sus
propiedades, ya que de esto depender la velocidad de actualizacin de nuestra
aplicacin. La configuracin final del archivo .xml utilizado en el proyecto es la
mostrada en el anexo 4.1.
Algunos puntos importantes de observar en la configuracin de este archivo son:
el establecimiento de la resolucin y velocidad de envo para las cmaras de
profundidad y de color, los cuales son de 640*480 pixeles a un velocidad de 30 fps
(30 tramas por segundo) para ambas cmaras.
Todos estos nodos deben ser iniciados y procesados computacionalmente a
travs de un principal objeto definido en las libreras de OpenNI, denominado
contexto. Este objeto se encarga de inicializar, actualizar y detener todos los
nodos producidos por el sensor, los cuales fueron tambin establecidos en el
archivo .xml. Para poder trabajar con el objeto contexto en OpenNI, se deben
tomar en cuenta los siguientes mtodos que son la base para trabajar con los
datos del sensor: Iniciar generando todo, Esperar y actualizar, Detener todo,
mtodos que son llamados a travs del objeto contexto. El mtodo 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 mtodo 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
mtodos como Esperar por alguno y actualizar, el cual espera por un nodo en
49

especifico sin tomar en cuenta que otros nodos hayan generado o no, nuevos
datos.
El mtodo Detener todo se encarga de detener la generacin de todos los nodos
a travs del sensor, este mtodo puede utilizarse para dejar de utilizar alguna
configuracin de un archivo xml y poder utilizar otro archivo con la extensin
indicada.

4.3 Software para adquisicin de datos

Para la programacin 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 caractersticas que ofrece el sensor.

Figura 4.3 Diagrama de clases del software diseado para la computadora.

El contenido de las clases se resume a continuacin:

Seguimiento: contiene los mtodos para obtener todos los datos referentes
al seguimiento de el usuario como las coordenadas (x,y,z) de las
articulaciones y su rotacin.
Imgenes: realiza la adquisicin y procesamiento de todas las imgenes
con las que se trabajan como imagen de profundidad e imagen RGB.
Clculos: implementa todos los algoritmos matemticos utilizados en el
software.

50

Deteccin de mano: procesa dentro de sus mtodos 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 travs 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 imgenes de profundidad, estas son generadas a travs del nodo
Generador de profundidad y entregadas a una velocidad de 30 tramas por
segundo. Una desventaja de OpenNI es que no genera ningn tipo de evento
cuando una imagen ha sido producida y enviada por el sensor hacia la
computadora, simplemente los datos son entregados a travs del mtodo Obtener
Metadatos, el cual entrega los datos de profundidad, debido a esto, la velocidad
de adquisicin de la trama o imagen, depender del algoritmo implementado en la
aplicacin y el tiempo que se asigne para procesar cada imagen.
La adquisicin y procesamiento de datos del sensor Kinect son desarrollados
utilizando tecnologa .Net, y lenguaje de programacin C#, trabajando las
imgenes como mapas de bits. Estos mapas permiten crear una imagen del
tamao 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 representacin del mapa de bits que
permite almacenar la cantidad exacta de datos entregados por el nodo de
profundidad.

480 bytes

640 bytes
Figura 4.4 Mapa de bits a utilizar para
copiar imgenes entregadas por el
sensor.

51

Cada byte dentro del mapa contiene 8 bits, esto indica que solo se pueden
almacenar datos con valor mximo 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 imgenes. La representacin 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, graficndose 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 grfica 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 despus
mostrarlos de forma grfica. El algoritmo de la figura 4.5 obtiene una imagen de
profundidad y es implementado en el cdigo del anexo 4.2.

52
Figura 4.5 Algoritmo para obtener una imagen de profundidad.

El objeto de tipo Bitmap sirve para poder almacenar los datos de profundidad
obtenidos de la funcin 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 deteccin de usuario, debido a
que el contorno puede ser obtenido utilizando otros algoritmos de visin 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.

53

En la figura 4.7 se observa otro detalle importante cuando se trabaja con el sensor
de profundidad del Kinect, cuando algn 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 diseo de la cmara 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 robtico, pero en el movimiento del robot, no afecta de ninguna
manera. El nodo encargado de generar datos para adquisicin de imgenes a
color es Generador de Imagen . La composicin 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 cmara RGB, permitiendo mostrar nicamente pixeles donde se muestre el
usuario deseado.
El algoritmo para obtener imgenes a color es similar al de las imgenes 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 imgenes a color se muestra en
la figura 4.8 y es implementado en el cdigo del anexo 4.3.

54

Figura 4. 8 Algoritmo para obtener imagen a color.

En la figura 4.9 se muestra la imagen a color que se obtiene a travs del nodo
Generador de Imagen. La resolucin de la imagen es normalmente de 640*480
pixeles, pero el sensor Kinect puede generar imgenes a color con una resolucin
de 1280*1024 reduciendo la velocidad de envo a 15 tramas por segundo.

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

55

4.3.3 Imagen de puntos infrarrojos

Las imgenes de proyeccin del patrn de puntos infrarrojos que emite el sensor
de profundidad del Kinect no son utilizadas para la implementacin del proyecto,
sin embargo se muestran como referencia para entender el desarrollo de la
aplicacin 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 travs 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.

Figura 4. 10 Imagen del patrn infrarrojo emitido por el sensor de profundidad, obtenida a
travs del nodo Generador Infrarrojo.

4.3.4 Proceso de calibracin

El sensor de profundidad detecta mximo a seis usuarios dentro del rea que
cubre, sin embargo, para realizar un mejor seguimiento de usuario, es
recomendable trabajar con un mximo 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 robtico, pero tambin se consideran factores como la
intromisin 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 nmero de identificacin
(ID) al usuario detectado, por ejemplo: si la aplicacin es iniciada y entra un primer
usuario al rea que cubre el sensor, se le es asignado el nmero 1 como ID, si
posteriormente ingresa otra persona se le asigna el ID nmero 2, continuando de
esta manera sucesiva hasta llegar al mximo de usuarios que pueden ser
detectados, si llegaran a ingresar mas usuarios dentro del rea del sensor, estos
56

no serian detectados o simplemente obtendramos un error en tiempo de

ejecucin. Una pregunta comn que puede llegar a surgir dentro de la deteccin
de usuario es: Qu pasa cuando un usuario es identificado, pero despus 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 tamao, 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 identificacin, 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 difcil 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 grficas 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 cmara RGB para obtener imgenes a color del cuerpo del usuario.
La diferencia para adquirir datos de usuario entre el SDK de Microsoft y las
libreras de OpenNI para el seguimiento de usuario, radica en que OpenNI
necesita una pose de calibracin. Las libreras de Microsoft no requieren de una
pose de calibracin para acceder a las articulaciones del usuario, esto se debe a
que la calibracin 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
calibracin, la cual no impide que se puedan acceder a las articulaciones del
usuario, pero se obtiene una mejor precisin del seguimiento realizando esta pose
de calibracin. El proceso de calibracin tambin ayuda en el seguimiento de
usuarios que estn dentro del rea del sensor y tengan parecidas pero no
idnticas formas en los sus cuerpos.
OpenNI contiene eventos que se generan cuando ocurren procesos relacionados
con la deteccin y calibracin de usuario. En la figura 4.11 se muestra el diagrama
de flujo para poder realizar la correcta calibracin del usuario, estos procesos son
establecidos por OpenNI de forma general, sin poder ser modificados,
implementando la calibracin en el cdigo del anexo 4.5.
57

Figura 4.11 Algoritmo para calibracin de usuario.

Los procesos marcados de color azul dentro del algoritmo de calibracin mostrado
en la figura 4.11 representan los eventos que se generan cada que ocurre dicho
proceso, los procesos de color verde representan mtodos que deben ser
llamados para realizar la tarea especfica. El proceso de calibracin 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 calibracin 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 peticin para detectar una pose de calibracin, es decir, se asume que el
usuario detectado realizar la pose de calibracin, el mtodo que realiza esta
peticin es Iniciar pose de deteccin, este mtodo recibe dos parmetros: el
ID(nmero de usuario) del que se desea calibrar, y la pose de calibracin a
realizar, la cual esta definida de forma predeterminada en OpenNI y es la que se
muestra en la figura 4.12 .

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

La razn de la forma de la pose para calibrar al usuario se debe que a travs de

la pose se puede tomar una imagen donde se visualicen casi la mayora de las
articulaciones del usuario, o por lo menos la parte superior del cuerpo del usuario.
Una vez que se realiz la peticin de deteccin de pose de calibracin 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 mtodo que
indica el diagrama de flujo , Peticin de calibracin, el cual se encargar de
realizar la peticin para la calibracin del usuario, este mtodo recibe como
argumento el ID del usuario que se requiera calibrar, antes de llamar a este
mtodo de peticin de calibracin se debe de llamar al mtodo Detener deteccin
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 Calibracin completa, evento que se genera cuando se completa la
calibracin, en este proceso se deben tomar en cuenta algunas consideraciones,
el termino de la calibracin no significa la correcta calibracin de usuario, por ese
motivo OpenNI cuenta con una bandera dentro de este evento que indica si la
calibracin 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 calibracin del usuario. El mtodo encargado de comenzar el seguimiento
de usuario es Iniciar seguimiento, mtodo que de igual forma recibe el numero ID
de usuario a seguir, si el valor de la bandera que indica la correcta calibracin de
usuario es establecido es errneo, se debe repetir el proceso de calibracin a
partir de la peticin de la deteccin de pose de calibracin, llevndose a cabo este
proceso de forma iterativa hasta obtener una correcta calibracin del usuario. Los
factores que influyen para que la calibracin de usuario no se lleve a cabo de
forma correcta se deben a una mala imitacin de la pose de calibracin o a que el
usuario deje de realizar la pose de calibracin antes de completarse el proceso,
normalmente la calibracin de usuario es completada de forma correcta en menos
de dos segundos. La imagen 4.13 muestra la localizacin de cada uno de las
articulaciones despus del proceso de calibracin, se puede observar que las
coordenadas de localizacin 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 calibracin.

59

Figura 4.13 Alineacin de las articulaciones

adquiridas con imagen RGB.

4.3.5 Seleccin 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 rotacin 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 mayora de personas son diestras,
aunque sin ningn problema podra implementarse el control para personas
zurdas. La seleccin 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, tambin se obtiene como ventaja la disminucin de la distancia requerida
del usuario con referencia al sensor, no necesitamos abarcar la lnea 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
60

4.3.6 Clculo de movimientos del brazo del usuario

Identificar un usuario y poder realizar un seguimiento 3D de las articulaciones
mencionadas contiene grandes ventajas dependiendo la aplicacin que se est
desarrollando y dependiendo de los algoritmos que se realicen. El seguimiento de
usuario se puede utilizar tanto para la deteccin de gestos realizados por el cuerpo
o para imitar los movimientos que el usuario realiza y reproducirlos en tiempo real.
Para la implementacin de nuestro brazo robtico, necesitamos enviar desde la
computadora haca microcontrolador, los datos de actualizacin de los
movimientos de los motores por cada imagen recibida. Para obtener cada
movimiento de las articulaciones del brazo del usuario se utiliza cinemtica directa,
la cual utiliza las coordenadas otorgadas por el sensor y calcula los movimientos
del brazo.

Cinemtica Directa para clculo de dos grados de libertad

La 'cinemtica' es una rama de la fsica que estudia las leyes del movimiento
(cambios de posicin) de los cuerpos, sin tomar en cuenta las causas (fuerzas)
que lo producen, limitndose esencialmente, al estudio de la trayectoria en funcin
del tiempo. La aceleracin es el ritmo con que cambia su rapidez (mdulo de la
velocidad). La rapidez y la aceleracin son las dos principales cantidades que
describen cmo cambia su posicin en funcin del tiempo. La idea principal de
utilizar cinemtica para los clculos, 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 aceleracin de la
trayectoria del brazo dependen de la rapidez con la que el usuario efecta 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 posicin y una orientacin 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 posicin(x,y,z) de un punto dentro del plano 3D se
puede expresar mediante la ecuacin 4.1 .

= x X + y Y + z Z (Ecuacin 4.1)

61

Donde x, y y z denotan los componentes del vector dentro del plano 3D, a
travs de los ejes de referencia. La posicin de puede ser compactada y
representada como un vector 3*1, como se muestra en la ecuacin 4.2.

2
035
4

(Ecuacin 4.2)

En la figura 4.14 se representa la posicin y orientacin 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 articulacin o punto del cuerpo, se puede observar que la
orientacin 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.

Figura 4. 14 Representacin de un vector formado por un punto o articulacin del usuario dentro del
plano del sensor.

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 rgido debido a que las dems
partes de su cuerpo se pueden mantener estticas 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 conclusin de implementar cinemtica directa para la obtencin de los
ngulos, esto implica que se debe realizar el clculo de los movimientos de
62

nuestra estructura (brazo de usuario) para conocer la trayectoria y llegar a un

punto desconocido, punto que se conoce normalmente en la mayora 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 cdigo de aplicacin, el punto final a
donde debe llegar el brazo robtico es desconocido para el programa, debido a
que el movimiento que realizar el brazo robtico ser controlado por el usuario,
siendo este quien determine a travs de los movimientos, la posicin final del
brazo.
La cinemtica 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
autnomo, entonces surge aqu la pregunta Cmo se aplica la cinemtica directa
en el movimiento del brazo robtico?, para aplicar cinemtica directa se emplea
una analoga entre el brazo del usuario y el brazo robtico, una vez que el usuario
lleve a cabo la pose de calibracin el programa podr realizar los clculos del
movimiento del robot, los cuales imitarn a los del usuario, es por eso que el
usuario debe realizar el primer movimiento, que determina la posicin inicial del
robot, y a partir de ella poder conocer la posicin de cada articulacin del robot y
seguir con el movimiento. Para mover una articulacin del brazo robtico se toman
como referencia tres articulaciones del usuario por cada grado de libertad, las
cuales forman vectores, de los cuales se conoce la posicin y orientacin de cada
uno de ellos mediante las coordenadas proporcionadas por el sensor y por lo tanto
hacen posible la aplicacin de formulas de cinemtica directa.
La forma en la que se obtiene el movimiento del brazo del usuario utilizando
cinemtica 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 localizacin del hombro, la cinemtica
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, despus se debe tomar otro vector como
referencia para encontrar el ngulo, el punto que se toma para referenciar el
vector faltante es la posicin (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
63

grados, de esta misma forma si el usuario levanta la mano, el ngulo ser

afectado por dicho movimiento generando cambios en la posicin 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, posicin que puede cambiar pero no afecta el
ngulo formado por los vectores si estos no cambian de posicin, el nico valor
que puede afectar el ngulo formado por los vectores es el del codo derecho,
debido a que cambia la posicin del vector 1 y como consecuencia aumenta o
disminuye el ngulo formado con el vector 2.

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

A partir de este ejemplo, podemos definir las articulaciones que formarn los
vectores que darn movimiento al brazo robtico, el cual estar dotado de tres
grados de libertad. La imagen 4.16 muestra los vectores que forman los puntos
que sern 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 mtodo que se
explicar ms 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 posicin del vector que forma cada uno de ellos depende
de la posicin de otro, si la mano derecha del usuario es levantada,
64

automticamente la posicin tanto del codo y de la mano cambian de valor, como

consecuencia el ngulo formado por ambos vectores cambia tambin de valor.
Cabe destacar que todos los vectores formados se proyectan en un plano
tridimensional, por lo tanto los ngulos calculados siempre cambiarn de
referencia dependiendo el eje del plano al que estn orientados, debido a que la
obtencin del tercer ngulo es nicamente referenciado al eje z, esto impide la
rotacin del usuario dentro del plano 3D que proyecta el Kinect, lo que implica que
el usuario en todo momento debe tener el cuerpo en posicin de frente dirigida al
sensor, sin poder girar hacia otro eje de referencia.

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

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 posicin mientras la mano o codo derecho si pueden
hacerlo, otro punto que tampoco cambiar de posicin es la articulacin
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 varan acorde a la distancia en la que se encuentre el usuario, tanto para
el eje x, y, z, es por eso que el clculo de los ngulos del movimiento del brazo
65

debe contemplar que estas coordenadas no tendrn siempre un rango fijo de

valores y no sern positivas en todos los casos. En la figura 4.17 se muestra la
proyeccin de dos vectores dentro de un plano 3D y la formula definida dentro del
clculo vectorial para obtener el ngulo que se forma entre ambos.

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

La formula para calcular en ngulo formado por los vectores v y w se define a

continuacin:
=cos-1

(Ecuacin 4.3)

La ecuacin 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 posicin 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 traslacin de vectores al origen, la cual se puede representar en la figura
4.18.

66

Figura 4. 18 Traslacin de un vector hacia el origen.

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 aplicacin conocemos los puntos que forman cada uno de los
vectores, adems de que podemos proyectar vectores desde el origen hacia el
punto que forma nuestro vector deseado, por lo tanto es posible realizar la
traslacin de los vectores que deseemos, hacia el origen.
A partir de este procedimiento podemos aplicar la ecuacin 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. 19 Clculo de ngulo entre dos vectores.

67

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 clculo de los ngulos.

Nombre
Vector 1
Vector 2
Vector 3
Vector 4

Punto de origen
Hombro derecho
Hombro derecho
Codo derecho
Codo derecho

Punto destino
Cadera derecha
Codo derecho
Mano derecha
Hombro derecho

A partir de esta tabla se deduce que se necesita realizar la traslacin 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 aplicacin
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
traslacin 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 funcin del algoritmo de la figura 4.19 y poder
obtener los movimientos de dos grados de libertad de nuestro brazo.
68

Obtencin del tercer grado de libertad utilizando una

matriz rotacional
El ltimo ngulo de movimiento del brazo de usuario es definido por la rotacin del
hombro derecho del usuario, movimiento que se define tambin en grados,
desafortunadamente OpenNI no entrega el resultado de esta rotacin en grados,
la forma en la que se estructuran estos datos es dentro de una matriz de rotacin.
Los ngulos Euler representan la rotacin 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.

Figura 4.20 ngulos que forma la rotacin de un cuerpo en un

sistema de coordenadas con respecto a otro [17].

Los grados Euler pueden ser representados por una matriz de rotacin 3*3 que
contiene la rotacin 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 rotacin
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 proyeccin de
vectores denominada proyeccin ortogonal, la cual se representa con las matrices
de las ecuaciones 4.4, 4.5 y 4.6 para cada eje de rotacin.

69

1
0
Rx( )= 0 ;,/
0 /=>

;,/
Ry( )= 0
</=>

;,/
Rz( )= /=>
0

0
1
0

0
</=>
;,/

</=>
;,/
0

/=>
0
;,/

0
0
1

(Ecuacin 4.4)

(Ecuacin 4.5)

(Ecuacin 4.6)

Figura 4. 21 Sistema de rotacin de un cuerpo con referencia a un plano.

Donde Rx( ), Ry( ) y Rz( ), representan la proyeccin de la rotacin del ngulo

con respecto a cada eje, es decir en RX( ) se utiliza al eje x como pivote para la
rotacin 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 rotacin de los tres
ngulos tenemos que multiplicarlos en determinado orden dependiendo la
aplicacin en la que se vayan a utilizar. Para este trabajo se necesita obtener el
ngulo de rotacin alrededor del eje z, del hombro derecho , utilizando como
referencia el plano de la figura 4.21 ,debido a que OpenNI entrega la rotacin de
una articulacin con respecto a la posicin T del usuario la cual se define en la
figura 4.22, la rotacin de una articulacin 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 rotacin del punto ubicado en la articulacin, el cual corresponde a
la articulacin del hombro derecho.

70

Figura 4. 22 Pose T que es el sistema de referencia

para la rotacin de una articulacin [13].

Figura 4. 23 Sistema de referencia para la rotacin del

hombro derecho.

El algoritmo para calcular los tres ngulos de rotacin de una articulacin se define
por la multiplicacin de las tres matrices RX( ), RY( ) y RZ( ), en donde se
obtiene una tercer matriz, que es la matriz proporcionada por las libreras de
OpenNI. La siguiente matriz muestra el resultado final de multiplicar las tres
matrices de rotacin.
-00
-10
-20

-01
-11
-21

-02
-12
-22

@A@B C DEDADB
@EDB
<@BDA C @ADEDB

][
=

@BDEDA < @ADB

@E@B
@A@BDE C DADB

@EDA
<DE
@E@A

(Ecuacin 4.7)

En donde:
Cx=cos

(Ecuacin 4.8)

Cy=cos

(Ecuacin 4.9)

Cz=cos

(Ecuacin 4.10)

Sx=sen

(Ecuacin 4.11)

Sy=sen

(Ecuacin 4.12)

Sz=sen

(Ecuacin 4.13)

Esta matriz describe la rotacin de los tres ngulos de la articulacin denotados

por valores flotantes, para obtener el valor en radianes de estos ngulos de
rotacin se toman en cuenta tres casos:

71

1. Si

pertenece a (- , ) entonces cy 0, cy(sx,cx)=(-r12,r22), por lo tanto

I I

los ngulos de rotacin se obtienen de la siguiente manera:

y = asin(r02), x = atan2(-r12, r22),
I

z = atan2(-r01, r00) (Ecuacin 4.14)

2. Si y= , entonces sy=1 y cy=0, en este caso la obtencin de ngulos es:

I

y = , z + x = atan2(r10, r11) (Ecuacin 4.15)

I

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

ngulos se obtienen:
y = - , z - x = atan2(r10, r11) (Ecuacin 4.16)
El algoritmo de la figura 4.24 implementa las condiciones de la factorizacin de la
matriz de rotacin entregada por cada articulacin del esqueleto, en donde se
determina un ngulo por cada eje de rotacin, tomando en cuenta el plano de la
posicin t del usuario, el resultado es entregado en grados, el cdigo esta
disponible en el anexo 4.7.

Figura 4. 24 Algoritmos para obtener el ngulo de rotacin de una articulacin.

72

4.3.7 Deteccin de gesto de finalizacin

A partir de la calibracin de usuario se establece el inicio del movimiento del brazo
robtico, pero el seguimiento de usuario y la obtencin de los ngulos de
movimientos del brazo son calculados de forma continua hasta que se le indique al
sensor que deje de generar las imgenes de profundidad, es por eso que se
incluye dentro de la adquisicin de datos un gesto hecho por la mano izquierda del
usuario para finalizar la aplicacin y por lo tanto detener el movimiento del robot.
Las libreras OpenNI ofrecen la deteccin de gestos realizados por cualquiera de
las dos manos de un usuario detectado. Estos gestos pueden ser realizados antes
o despus de la calibracin del usuario, los gestos incluidos dentro de estas
libreras 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
despus regresarla al primer lugar donde estaba antes del movimiento.
circulo: mover la mano en forma circular hacia cualquier lado.

De estos tres gestos provedos por OpenNI, eleg el gesto de saludo debido a que
su movimiento no requiere extender demasiado los brazos, basta con simular un
saludo tpico de hola con la mano para que el gesto sea detectado. La deteccin
del gesto basa su funcionamiento en eventos que se generan en las libreras de
OpenNI, cuyo diagrama de flujo de los procesos que lleva la deteccin 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, despus 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 peticin
para la nueva deteccin del gesto, a partir de entonces el usuario tendr que
realizar nuevamente el gesto.

73

Figura 4. 25 Diagrama de flujo para la deteccin de gestos con OpenNI.

74

4.3.8 Deteccin de dedos para apertura y cierre de la

pinza
La idea de poder controlar el brazo robtico a travs del Kinect es no tener que
utilizar algn 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 ms cercano a estos es la mano, es por eso
que para permitir un control de la pinza que se efecte a travs de la apertura o
cierre de la mano del usuario se necesit utilizar otra librera que no esta incluida
en las libreras de OpenNI, esta librera es denominada EmguCV, la cual
contiene herramientas que facilitan algoritmos y procesos utilizados en visin por
computadora. EmguCV es un conjunto de libreras para programacin en lenguaje
C# que implementa todas las funciones y algoritmos utilizados en el paquete de
libreras de visin por computadora denominado OpenCV. Estas libreras de
visin por computadora son utilizadas en este proyecto debido a que facilitan la
implementacin de distintos algoritmos de visin por computadora, adems de que
aceleran el procesamiento de imgenes debido a que utilizan memoria del
sistema que ayuda a procesar las imgenes de forma ms rpida. EmguCV
cuenta tambin con ejemplos que utilizan imgenes de profundidad o imgenes a
color como las que entrega el Kinect, es por eso que se proyectan como la mejor
opcin para tratar las imgenes del sensor para esta aplicacin.
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 investigacin acerca del tratamiento de imgenes de profundidad y a
color a travs de Kinect, se encontraron dos posibles soluciones para la deteccin
de la apertura y cierre de la mano de un usuario a partir del anlisis y tratamiento
de imgenes en dos dimensiones mediante el sensor Kinect. La primera fue
aplicar un algoritmo de deteccin 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 opcin 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 deteccin de una mano que se
aplica en imgenes a color. Para este proyecto se descart utilizar un algoritmo
75

que segmentara una imagen a color para formar una imagen de la mano del
usuario a partir de la deteccin del color de la piel utilizando la cmara RGB del
Kinect, debido a que no todas las personas presentan el mismo tono de piel,
adems de que las imgenes 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 mximo los
recursos que ofrece, por lo tanto el algoritmo implementado para la deteccin del
gesto que implica la apertura o cierre de una mano del usuario se basa en la
extraccin de una imagen de profundidad del recuadro que cubre nicamente la
mano izquierda del usuario.
El procedimiento de deteccin del gesto de apertura o cierre de la pinza se
describe a continuacin:

Extraccin de imagen de profundidad basndose nicamente en la

regin de inters que corresponde a la mano izquierda del usuario

El algoritmo que implementa la deteccin del gesto con la mano requiere

nicamente trabajar la regin de la imagen de profundidad que contemple el rea
de la mano del usuario. Desafortunadamente ni el sensor Kinect ni las libreras 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 regin de inters 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 regin de inters que
abarque el rea de la mano izquierda del usuario.

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

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: Cmo se obtiene la
regin de inters 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 servira de mucho en imgenes
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, afectara en el tiempo de procesamiento, afortunadamente OpenNI
contiene una funcin dentro de sus libreras 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 funcin se mide la distancia en
pixeles entre la cabeza del usuario y su cuello. Aplicando la ecuacin 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

(Ecuacin 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 regin de inters, 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
regin de inters. En la figura 4.27 se muestra la regin que se obtiene en base a
la medida tomada de la cabeza al cuello del usuario.

Figura 4. 27 Regin de
inters (amarillo) de la
imagen de profundidad.

77

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 regin de

inters, solo permite enfocar nuestro anlisis en una cierta parte de la imagen de
profundidad, pero todava 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
seleccionarn 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 localizacin de la mano izquierda sobre el eje z sern descartados, y
tambin 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.

Figura 4. 28 Pixeles que sern tomados en cuenta para la forma de la imagen.

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 imgenes 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 regin de inters es calculada de forma propuesta y con un tamao no
exacto, la imagen resultante del proceso de filtracin puede no corresponder a la
imagen de solo la mano, y tomar tambin una parte del brazo dentro de esta
78

forma, hecho que afecta de forma mnima en el algoritmo de deteccin 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
imgenes 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 libreras de cdigo abierto de algoritmos de visin por computadora
denominado EmguCV. EmguCV contiene libreras que implementan algoritmos
sobre imgenes que se encuentren en el espacio RGB en escala de grises,
adems aceleran la velocidad de procesamiento de las imgenes, factor que es
vital para esta aplicacin.
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 lnea recta, sin salir del mismo.
La figura 4.29 muestra el ejemplo de una figura convexa

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

Como se puede observar, dentro de la figura 4.29 X, los puntos denotados desde
A hasta B, se encuentran unidos por una lnea recta hacia otro punto que
pertenece al conjunto, por ejemplo: el punto A, al punto B, el C al D, etc, en ningn
caso, la lnea 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 lneas
trazadas dentro de sus puntos , salen del rea de la figura.

79

Establecido este concepto procedemos a aplicar una funcin de EmguCV que

aplica un algoritmo que encuentra las formas convexas de nuestra imagen, la cual
antes fue procesada en los anteriores algoritmos, esta funcin de la librera 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
Apoyndonos 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 sern
descartadas en el proceso que se explicar mas adelante. Una vez que se
encontraron todos esos puntos, se guarda la ubicacin (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 robtico, es necesario detectar cuando
un usuario abre o cierra la mano. Los procesos explicados anteriormente permiten
tener la ubicacin 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 mtodo Obtener la mnima rea de EmguCV, que cubre la figura de
la imagen, en nuestro caso la forma de la mano, esta funcin devuelve un
rectngulo que cubre al rea comprendida por la figura encontrada dentro de la
imagen a la que se le aplica esta funcin. En la figura 4.30(a) se dibuja este
rectngulo que marca el rea que cubre la figura encontrada. El siguiente paso es
dibujar otro rectngulo que abarque la mitad del rectngulo encontrado
anteriormente, con el objetivo de trazar el rectngulo a un rea que
aproximadamente sea el rea que cubre la palma de la mano, en la figura 4.30(b)
se muestra el polgono.

(a)

(b)

Figura 4. 30 (a) Rectngulo que cubre el rea.

(b)Rectngulo que cubre la mitad del rea de la figura.

80

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 nmero de dedos que el usuario extiende con la mano izquierda, estas
condiciones se basan tambin en la medicin de distancia entre el centro de la
palma la cual se puede obtener mediante la ubicacin (x,y) del sensor, y la punta
de los dedos de la mano que como ya se mencion, se puede tambin obtener. La
condicin para realizar el conteo del nmero 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 rectngulo 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 condicin se hace
un anlisis de todas las formas convexas encontradas y se realiza un conteo de
aquellas que cumplan la condicin, sin embargo tambin se establece otra
condicin: las coordenadas (x,y), de las puntas de los dedos deben de ser
menores que la frontera del rectngulo que cubre el rea debido a que se
considera que el usuario siempre mantiene la mano con los dedos en direccin
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 tambin como ruido, es por eso que mediante esta condicin se
evitan errores de ese tipo.
El procedimiento de deteccin 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 regin de inters sea muy pequea dentro
de la imagen de 640*480 pixeles y el algoritmo no obtenga de forma correcta las
formas de las imgenes.
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 difcil de detectar dentro de este algoritmo. Si el contador indica 1
0 nmero 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 cdigo del procedimiento para detectar la apertura o
cierre de la mano se implementa en el anexo 4.8.

81

4.3.9 Interfaz grfica de usuario

Como se mencion anteriormente, la interfaz grfica 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. Adems de las imgenes que obtiene el sensor, la interfaz
despliega los ngulos que se envan haca el microcontrolador y despliega cuando
un usuario es o no detectado. Debido a que el brazo robtico es iniciado,
controlado y finalizado por los movimientos del usuario, el nico botn de la
interfaz grfica es el botn 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
calibracin, pero los datos del sensor se procesan desde que es oprimido el botn
de iniciar. En la figura 4.31 se muestra la imagen la interfaz grfica de usuario de
la aplicacin, as como los controles que se encuentran dentro de ella y apoyan al
usuario en el control del robot.

Imagen de profundidad y color.

Deteccin
de usuario.

Valor de
ngulos
del robot.

Imagen de la mano que controla la pinza.

Figura 4. 31 Interfaz grfica de usuario de la aplicacin.

82

4.4 Programacin del microcontrolador

PIC18F4550
El microcontrolador PIC18F4550 es el dispositivo de procesamiento encargado de
generar la seal para los servomotores que conforman el brazo robtico, el
PIC18f4550 debe generar la seal de los servomotores en tiempo real, es decir
que los motores se muevan al mismo tiempo, el motivo de generar la seal al
mismo tiempo se debe a que cuando se genera una seal para cada motor de
forma serial moviendo motor por motor, el movimiento del robot es lento en
comparacin de mover todos los motores en forma paralela, adems de que los
motores pueden perder el torque cuando se deja de generar la seal. 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 tambin conocidos
como Timers, los cuales sern utilizados para generar la modulacin por ancho
de pulso (PWM), de los motores del brazo robtico.
La transmisin universal serial sncrona y asncrona (USART), ser utilizada para
la recepcin de datos desde la computadora a travs del modulo serial bluetooth.
Otras caractersticas incluidas dentro de la programacin del PIC son la utilizacin
de puertos para enviar la seal a cada servomotor.
Para poder programar las tareas dentro del PIC y poder asignar los tiempos que
sean necesarios para realizarlas en tiempo simultneo, se deben enumerar las
prioridades de cada tarea, definiendo cual es ms importante para nuestro sistema
y cuales carecen de menor importancia. En la tabla 10 se enumeran las tablas de
acuerdo a la prioridad y duracin. Como se puede observar, las principales
prioridades del sistema, son la generacin 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 duracin 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 eslabn
que pertenece al motor que une ese eslabn, ejerza una fuerza hacia abajo
provocando la inestabilidad o movimiento errneo del brazo.
83

Tabla 4. 5 Prioridades del sistema en tiempo real.

Tarea
Motor 1( 1 gdl)
Motor 2 (2 gdl)
Motor 3 (3 gdl)
Motor 4(pinza)
Recepcin UART

Prioridad
1
1
1
1
2

Duracin
Ciclo de trabajo
Ciclo de trabajo
Ciclo de trabajo
Ciclo de trabajo
2.5 us

Dentro de la prioridad nmero 2, se encuentra la tarea que se encarga de recibir el

paquete de datos a travs de la comunicacin 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 ledo, no afectara de forma directa al sistema, debido a que el
programa guarda los valores anteriores, los cuales son generados a travs del
PWM del motor correspondiente, cuyo torque debe de generarse de manera
constante.
Una vez establecidas estas prioridades, se realiz la programacin 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 configuracin de
las funciones del PIC, el primer paso para iniciar el programa es la configuracin
de puertos de entrada y/o salida, en el presente proyecto se utilizan los puertos
B0-B3 para la generacin del PWM de los motores, por lo tanto estos bits son
establecidos como salida. En el segundo proceso se establece la configuracin de
la transmisin serial asncrona, 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 configuracin de la comunicacin serial del PIC deben
establecerse estos dos pines con la configuracin adecuada, adems debe
establecerse en 1, la bandera de interrupcin de la recepcin de datos, la cual
recibe byte por byte ,el dato que sea enviado desde la computadora al PIC. El
siguiente proceso consiste en la configuracin del timer2, cuya interrupcin genera
el tiempo de 0.00001 segundos el cual corresponde al ciclo en alto de duracin
para que el servomotor se pueda mover un grado, a partir de ese concepto se
movern los dems motores. Despus de establecer la configuracin de los
temporizadores y del UART(transmisin serial sncrona), 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
84

correspondientes tareas. Este ciclo llega a su fin solo si es recibido el dato

proveniente de la computadora, que pertenece al gesto de finalizacin del brazo
robtico, cuyo valor indica que el brazo debe detenerse, por lo cual se inicia un
contador, el cual segura que todos los motores llegarn al estado final, es decir al
movimiento de finalizacin, para despus 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 despus
de recibir el dato de finalizacin, los motores perdern el torque inmediatamente, y
no podrn llegar al estado final, lo que implica que el brazo pierda la fuerza en
todas sus articulaciones. Cuando el contador llega al nmero establecido para
llegar a la posicin final, el microcontrolador llega al estado en reposo y por lo
tanto la aplicacin finaliza.

Figura 4.32 Diagrama de flujo de la programacin del PIC18F4550.

85

En la figura 4.33(anexo 4.9) se muestra el diagrama de flujo establecido para la

interrupcin que se genera para la recepcin 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, despus de
esto la variable se incrementa y se borra la bandera correspondiente a la
interrupcin de recepcin, cuando esta se vuelve a generar, el valor del modulo de
recepcin 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 asignacin 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 recepcin de estos datos se
realiza de forma muy rpida, debido a que los datos provenientes de la
computadora son enviados uno tras de otro, sin espera ningn tiempo, lo que
acelera la asignacin de valores a las variables de movimiento de los motores.

Figura 4. 33 Diagrama de flujo de la interrupcin generada por la

recepcin de datos a travs del modulo UART.

86

Dentro de la figura 4.34 (anexo 4.10) se visualiza el diagrama de flujo

correspondiente a la interrupcin del TIMER2, el cual genera una interrupcin
cada 0.00001 segundos. Retomando la especificacin de movimiento de un
servomotor, este debe generar un tiempo en alto mnimo de 0.0006 segundos para
un movimiento de 0 grados, y un tiempo mximo en alto de 0.0024 segundos lo
que corresponde a 180 grados, generando despus un tiempo de 0.018 segundos
para el tiempo en bajo lo cual completa el periodo de la seal de un servomotor,
sin embargo para que un servomotor pueda moverse los grados deseados, se
deben enviar mnimo 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 configuracin de los puertos, se
declara una variable contador2, la cual inicia en inicia en 0, y en cada interrupcin
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 interrupcin de recepcin 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 seal se establece en cero,
iniciando su ciclo en bajo. Por ejemplo: supongamos que dentro de la subrutina de
recepcin del UART se le asign a la variable servo1 el valor de 90, esto implica
que ese servomotor debe de moverse a la posicin de 90, entonces quiere decir
que la variable contador2, debe ser incrementada 90 mas 60 veces, el motivo de
agregar el nmero 60 es porque como se haba establecido dentro del marco
terico, los servomotores estndar necesitan un tiempo mnimo 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
87

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 interrupcin del temporizador 2(Timer2).

88

En la figura 4.35 se muestra el perodo correspondiente a cada seal, 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 duracin
.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).

89

Captulo 5 Pruebas
y resultados
En el presente captulo se explica el diseo mecnico y funcionamiento del brazo
robtico, adems se presentan las pruebas finales realizadas para explicar el
funcionamiento del manipulador y obtener la eficiencia del proyecto, tomando
como referencia determinados parmetros relacionados tanto al brazo robtico
como a los diferentes usuarios que realizaron pruebas con el prototipo.

5.1 Estructura del brazo robtico

El principal objetivo es controlar el brazo robtico a travs 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 robtico, imitando a los del usuario. La
estructura propuesta pertenece a la configuracin angular o antropomrfica de un
manipulador, la cual se visualiza en la figura 5.1, esta estructura presenta una
articulacin con movimiento rotacional y dos con movimiento angular.

Figura 5. 1 Configuracin de un brazo robtico antropomrfico o angular.

90

Para el diseo mecnico se utilizaron tubos de aluminio y soportes para los

servomotores construidos tambin con aluminio, los brackets o soportes para
servomotores son fabricados con medidas que se ajustan al tamao de un
servomotor estndar, 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.

Figura 5. 2 Soporte para el servomotor utilizado.

Figura 5. 3 Servomotor utilizado.

A continuacin se muestran los tubos de aluminio utilizados para construir los

eslabones del brazo robtico (parte que une las articulaciones, en la figura 5.4 se
muestra la longitud de cada uno de ellos.

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

91

5.1.1 Clculo 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
robtico tomando en cuenta tambin el peso de los motores y de los soportes
(brackets), la formula utilizada para el clculo es la que se muestra en la ecuacin
5.1.

= d

(Ecuacin 5.1)

En donde:
= torque o torsin

= fuerza aplicada

d = distancia

Para el clculo del torque correspondiente de cada motor se tom en cuenta el

peso del motor, bracket y tubo de aluminio del correspondiente eslabn. Para el
motor del eslabn 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.

Figura 5.5 Medidas del eslabn para movimiento angular nmero 2.

Tabla 5. 1 Medidas y pesos del eslabn para movimiento angular nmero 2.

Elemento
Soporte para
servomotor
Tubo de
aluminio
Pinza con
motor

Distancia
4.5cm

Peso
20 gr

7.5cm

15 gr

6.5cm

74 gr

92

Sustituyendo en la ecuacin 5.1

= (0.020kg+ 0.015kg + 0.074kg)(9.80 m/s2)(0.045m+0.075m+0.065m) (Ecuacin 5.2)

= 0.197617 N/m (Ecuacin 5.3)

Convirtiendo de N/m a Kg/cm obtenemos:
= 2.01513 kg/cm (Ecuacin 5.4)

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

costos del proyecto)
Para el motor del eslabn del movimiento angular nmero 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.

Figura 5. 6 Medidas del eslabn para movimiento angular nmero 1.

Tabla 5. 2 Medidas y pesos del eslabn para movimiento angular nmero 1.

Elemento
Tuvo de aluminio
movimiento angular 1
Soporte
con motor
Tubo de aluminio
movimiento angular 2
Pinza con motor

Distancia
12.5cm

Peso
30gr

4.5cm

84gr

7.5cm

15 gr

6.5cm

74 gr

93

Sustituyendo en la ecuacin 5.1

= (0.030kg+ 0.084kg + 0.015k + 0.074kg)(9.80 m/s2)(0.125m + 0.045m +
0.075m + 0.065cm)
(Ecuacin 5.5)
= 0.616714 N/m (Ecuacin 5.6)
Convirtiendo de N/m a Kg/cm obtenemos:
= 6.2887 kg/cm (Ecuacin 5.7)
Para este torque se utiliz el servomotor Power HD con un torque de 17kg/cm(ver
anexo anlisis de costos)
Para obtener el torque del servomotor que proporciona el movimiento de rotacin
del robot se aadi la distancia del bracket que corresponde al motor que
proporciona el movimiento angular nmero 1 y nmero 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)
(Ecuacin 5.8)
= 0.998473 N/m (Ecuacin 5.9)
Convirtiendo de N/m a Kg/cm obtenemos:
= 10.1815 kg/cm (Ecuacin 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 diseo mecnico del manipulador
antropomrfico, diseo que fue tomado como referencia para construir el prototipo.

94

Figura 5. 7 Diseo final del prototipo del brazo robtico.

La figura 5.8 muestra las medidas del brazo robtico, 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.

95

Apertura de la pinza
La pinza de sujecin 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
sujecin.

Figura 5.9 Mxima apertura de la pinza.

El espacio de trabajo para el prototipo del brazo robtico se basa en la figura 5.10,
la cual corresponde al espacio que normalmente tiene acceso un manipulador de
configuracin antropomrfica, en donde la parte rayada, marca el rea de
movimiento que abarca el brazo robtico utilizando sus tres grados de libertad.
Esta rea es aproximada, debido a que como se ha venido mencionando, el
movimiento del brazo robtico, 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 robtico no podr moverse mas de lo que permitan dichos
movimientos.

Figura 5. 10 rea de trabajo del brazo robtico.

96

5.2 Resultados de la deteccin de dedos

En base al procedimiento para la deteccin de formas convexas en una imagen de
profundidad, se obtuvieron resultados como los que se muestran en la figura 5.11.

Figura 5.11 Formas convexas detectadas.

Los crculos rojos representan inicio de una forma convexa y los crculos 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 imgenes 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. 13 Resultado de la deteccin de dedos

Figura 5. 12 Resultado de la deteccin de dedos.

97

5.3 Resultados de movimiento del robot

En las figuras 5.14, 5.15 y 5.16 se muestran los movimientos del brazo robtico y
del usuario, demostrando los movimientos que se generan cuando el usuario
dobla las articulaciones.

Figura 5. 14 Posicin con brazo estirado.

Figura 5. 15 Posicin con brazo flexionado.

En la figura 5.14 se muestra como al extender el brazo, el brazo robtico repite la

misma accin movindose casi 180 grados, ngulo formado entre los dos
eslabones, en la figura 5.15 se muestra la mxima flexin que puede realizar el
usuario con el ngulo formado entre el brazo y antebrazo, movimiento que ejecuta
el brazo robtico de forma similar, un detalle importantes es que el movimiento
que efecta el brazo robtico en su tercer grado de libertad( segundo eslabn), es
contrario al movimiento del brazo del usuario con el antebrazo, la implementacin
para este movimiento dentro de la mecnica 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 limitara el movimiento del robot y por lo tanto el alcance para tomar y dejar
piezas, es por eso que el movimiento del segundo eslabn es contrario al
movimiento natural del usuario. Finalmente en la figura 5.16 se muestra una
flexin del brazo del usuario y del robot a una posicin aproximadamente de 90
grados, permitiendo tener una posicin recta para la pinza. El movimiento de
rotacin y del segundo grado de libertad, son efectuado de forma similar en el
robot, delimitados por la flexibilidad en los brazos del usuario.

98

Figura 5. 16 Posicin con brazo semi flexionado.

5.4 Pruebas del brazo robtico

Las pruebas realizadas para probar la eficiencia del brazo robtico en ser utilizado
por cualquier usuario, se realizaron en una superficie que tuviera un fondo rgido
para la proyeccin de la cmara 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 habitacin donde no se afectara la luz solar de forma directa
en la proyeccin del sensor, tambin se intento realizar pruebas bajo condiciones
de luz solar y superficies reflejantes, pero en ningn caso se obtuvo un correcto
funcionamiento del sistema (ver anexo 5.1).

Figura 5. 17 Modelo de pieza

cilndrica para pruebas del brazo
robtico.

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 colaboracin de 4
usuarios, con el objetivo de demostrar que cualquier persona puede controlar el
robot sin adentrarse en su programacin o cosas similares. Cabe destacar que las
personas que controlaron el brazo robtico para intentar tomar y cambiar las

99

piezas al recipiente, no estaban familiarizados con el control del brazo robtico,

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 dispersin de las piezas se muestra en la figura 5.17, a partir de esta
distribucin se tom el tiempo que tardo cada usuario en colocar las piezas en el
recipiente, realizando dos intentos por cada prueba.

Figura 5.18 Distribucin de las piezas sobre mesa de madera.

En la tabla 5.4 se muestran los tiempos que realiz cada usuario al tratar de mover
las piezas, adems se indica el nmero de piezas que piezas que fueron soltadas,
y las piezas que quedaron fuera del alcance del robot por un movimiento errneo
del robot, adems se incluye como dato adicional, la estatura del usuario, para
demostrar que cualquier usuario puede controlar el brazo robtico. En los anexos
5.2 se puede consultar los imgenes de los usuarios controlando el prototipo,
tambin 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.

100

Tabla 5. 3 Resultados de las pruebas realizadas con el brazo robtico.

No. de Usuario Estatura

1 (Desarrollador
del prototipo)
1 (Desarrollador
del prototipo)
2 (Ver anexo
5.2.1)
2 (Ver anexo
5.2.1)
3 (Ver anexo
5.2.2)
3 (Ver anexo
5.2.2)
4 (Ver anexo
5.2.3)
4 (Ver anexo
5.2.3)
5 (Ver anexo
5.2.4)
5 (Ver anexo
5.2.4)

No. de
prueba

Piezas
soltadas

Piezas
Nmero de
fuera del pizas
alcance depositadas
del
robot

Tiempo
total
(minutos)

1.69m

2.20

1.69m

3.59

1.51m

6.37

1.51m

5.12

1.62m

2.47

1.62m

6.05

1.60m

13.06

1.60m

12.56

1.50m

8.33

1.50m

10.20

Minutos

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.

14
12
10
8
6
4
2
0
2

Nmero de usuario
Figura 5. 19 Grfica del tiempo en completar la prueba.

101

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

Q =RS, S-,R=K , =
Donde:

V
TWV
T

(Ecuacin 5.11)

i = nmero de usuario
n= total de usuarios
ti= tiempo del usuario en completar la prueba
Sustituyendo en la ecuacin 5.2 obtenemos el siguiente promedio:
Tiempo promedio
=

X.YZ [\]

. Z [\] X.

Y. X

. X ^.YY

=16.34minutos (Ecuacin 5.12)

Para obtener la eficiencia del brazo robtico 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 $($b

c $% ( ` a$b

100 = X 100= 73% (Ecuacin 5.13)

% de error = 100% -73%= 27% (Ecuacin 5.14)

El porcentaje de error disminuye cuando el usuario obtiene prctica en el uso del

prototipo, adaptndose a los movimientos del robot para poder controlar su
velocidad y precisin. Cuando el prototipo es utilizado por personas que han
realizado un previo entrenamiento para controlar el robot, el porcentaje de error
disminuye.

102

Conclusiones
Dentro de las pruebas se observ que el movimiento del brazo robtico 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 pequeo tamao y peso ligero, demostrando
que el brazo robtico podra llegar a transportar piezas u objetos pequeos 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 difcil 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 dejndolas fuera su alcance.
Adems de que otras piezas fueron soltadas al presentarse fallas dentro de la
deteccin 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 mximo
movimiento permitido por los servomotores (180 grados), debido a que la
flexibilidad en los movimientos del brazo de la mayora de las personas, no se
ajusta a dicho movimiento, delimitando como consecuencia el movimiento del
brazo robtico.
Finalmente, este trabajo de tesis produjo un brazo robtico 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 fsicas
como palancas o botones.

103

Observaciones
El cuarto donde se utilice el sensor es de gran importancia, se debe procurar que
el sensor proyecte sobre una superficie rgida y no transparente o reflejante
(vidrios, etc.), adems de que la habitacin 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
especificacin, el sensor adquiere y entrega los datos de forma incorrecta debido a
la mala proyeccin 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 robtico 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 articulacin. 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 algn objeto o persona
se encuentra entre el sensor y el usuario, se obstruye la lectura de los datos del
sensor, como consecuencia la aplicacin tendr un funcionamiento incorrecto,
provocando fallas catastrficas en el movimiento del brazo robtico.

Mejoras del proyecto y trabajo a futuro

El alcance para tomar o dejar piezas con el brazo robtico depende tambin de los
grados de libertad del robot, una mejora que podra implementarse es agregar
mas grados de libertad imitando lo ms preciso el movimiento natural del brazo de
una persona. En cuanto a la comunicacin entre la computadora y el PIC, se
puede cambiar el protocolo de comunicacin utilizando alguno que mantenga el
envo de los datos de manera rpida y efectiva, pensando tal vez en una
comunicacin basada en el protocolo Wifi.
Otra opcin 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 algn
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 opcin para implementar la tarea mencionada, es utilizar
104

algunas libreras que permite un anlisis 3D de la mano, basado en algoritmos de

visin por computadora, cuyo software se encuentra en la pgina de las libreras
de programacin utilizadas en este trabajo, adems de conjuntarlo con un
seguimiento de usuario, como el que se implement en el proyecto.

105

Bibliografa
[1]UDC. (2012). OpenNI and software. Obtenido de http://sabia.tic.udc.es/gc/trabajos%20201112/Kinect/codigo.html
[2]Alejandro, I. L. (Noviembre de 2012). Sistemas en tiempo real. Apuntes del semestre.
[3] Sistemas de asquicisin 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 pginas 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-serialmicrocontrolador-pic-arduino-atmel-_JM
[16] Publicacin Interna 9 20-09-2007 Francisco A. Candelas Heras Juan A. Corrales Ramn
[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). Interaccin persona-computador basada en el
reconocimiento visual de manos. UNIVERSIDAD COMPLUTENSE DE MADRID.
106

[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. OReilly.
[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. OReilly.
[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
bioingeniera. 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 Programers 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

107

Anexo 1
1.1 Anlisis de costos
Para la construccin e implementacin 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 travs 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 conexin
con la computadora.
Precio: $1800.00

Bracket para servomotor estndar:

sirve
para
montar
cualquier
servomotor estndar y poder hacer
una estructura ms rgida o conectarlo
con otros brackets y permitir la
rotacin de la articulacin del brazo.
Precio: $275.00
Cantidad: 3
Modulo bluetooth para transmisin serial:
funciona por medio del protocolo bluetooth, pero
la transmisin y recepcin es de forma serial
RS232.
Precio: $250.00
Servomotor estndar HITEC HS-311: utilizado para una articulacin y
para la apertura y cierre de la pinza.
Velocidad : (sec/60o): 0.19
Torque (Kg-cm/Oz-in): 3.7/49
108

Tamao (mm): 40 x 20 x 37
Peso (g/oz): 43/1.51
Precio: $210.00
Cantidad: 2
Servomotor estndar alto torque: Para el
movimiento de rotacin del brazo y el movimiento
del primer eslabn, se utiliz un servomotor con
mayor torque, funcionando con las mismas
caractersticas que el HITEC HS-311.
Velocidad: (sec/60o): 0.19
Torque (Kg-cm): 17kg
Tamao (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
pequeos con el brazo robtico, la apertura del
gripper es de 1.3 pulgadas.
Precio:$ 300.00
Tubo de aluminio ligero: utilizado para construir los
eslabones del brazo robtico, debido al material con
el que est fabricado, no se requiere demasiado
torque para poder levantar dicho eslabn.
Precio: $30.00
Cantidad: 2

Placa fenlica doble cara 10*10cm: el diseo del

circuito impreso requiere una placa de doble vista
para hacer el diseo de la placa controladora del
brazo.
Precio: $18.00

109

Batera 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
batera con mayor voltaje y amperaje para permitir el
mximo 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 caractersticas de

este PIC satisfacen las herramientas que se requieren
para el proyecto.
Precio: $120.00
Cristal piezoelctrico 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 conexin con la
computadora para poder programar el microcontrolador
y alimentarlo.
Precio: $8.00

Capacitor 22f: complementos para

funcionamiento del cristal piezoelctrico.
Precio: $2.00
Cantidad: 2

el

correcto

110

La siguiente tabla muestra el costo total del proyecto.

Tabla anexo 1 Costo total del proyecto.

Material
Kinect
Soporte para
servomotor
Mdulo bluetooth
Servomotor 3.7kg
Servomotor 17kg
Pinza
Tubo de aluminio
Tabla fenlica
Batera acidoplomo
PIC18F4550
Base 40pin
Cristal 20Mhz
Conector USB
Capacitor 22pf
Total

Cantidad
1
3

Costo por pieza

$1800.00
$275.00

Costo total
$1800.00
$825.00

1
2
2
1
2
1
1

$250.00
$210.00
$350.00
$300.00
$30.00
$18.00
$120.00

$250.00
$420.00
$700.00
$300.00
$60.00
$18.00
$120.00

1
1
1
1
2

$120.00
$5.00
$15.00
$8.00
$2.00

$120.00
$5.00
$15.00
$8.00
$4.00
$4645.00

De todos los materiales utilizados, el sensor Kinect es el mas costoso debido a

que es un producto de ltima tecnologa 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 circuitera externa. Algunos de los servomotores utilizados tienen
un costo elevado debido al torque con el que cuentan y su durabilidad, adems de
tener tiempos de respuesta favorables para la implementacin del proyecto.
El material utilizado para la estructura del robot esta diseado para permitir
libremente la rotacin 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 incrementndose en las interfaces de usuario que
utilizan el sensor Kinect, adems de ser un proyecto demasiado innovador.

111

Anexo 2
2.1 Caractersticas del PIC18F4550
Es un microcontrolador de la familia pic18 fabricado por Microchip, el cual cuenta con las
siguientes caractersticas:

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 mxima de reloj 40Mhz. Hasta 10 MIPS.
Pila de 32 niveles.
Mltiples fuentes de interrupcin
Perifricos de comunicacin 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, adems puede ser escrita/leda mediante un
programador externo o durante la ejecucin del programa mediante unos punteros.

Memoria RAM de datos: memoria SRAM interna de 2048 bytes en la que estn
incluidos los registros de funcin especial. Almacena datos de forma temporal
durante la ejecucin del programa y puede ser escrita/leda en tiempo de ejecucin
mediante diversas instrucciones.

Memoria EEPROM de datos: memoria no voltil de 256 bytes: almacena datos

que se deben conservar aun en ausencia de tensin y de alimentacin.
Puede ser escrita/leda en tiempo de ejecucin a travs de registros
Pila: bloque de 31 palabras de 21 bits que almacena la direccin de la instruccin
que debe ser ejecutada despus de una interrupcin o subrutina

112

2.2 Terminales PIC18F4550

113

2.3 Registros transmisin UART

114

115

2.4 Registros Timer2

116

117

Anexo 3
3.1 Grficas de descarga de la batera 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>
118

Anexo 4
4.1 Plantilla del archivo xml para programacin del sensor
Archivo xml utilizado para la aplicacin
<OpenNI>
<Licenses>
<License vendor="PrimeSense" key="0KOIk2JeIBYClPWVnMoRKn5cdY4="/>
</Licenses>
<Log writeToConsole="false" writeToFile="false">
<!-- 0 - Verbose, 1 - Info, 2 - Warning, 3 - Error (default) -->
<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>

119

4.2 Cdigo 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;
}

120

4.3 Cdigo para obtener imagen RGB

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;
}

4.4 Cdigo para obtener imagen infrarroja

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;

121

4.5 Cdigo para calibracin 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
calibracin
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
}
}
}

122

4.6 Clculo 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;
}

123

4.7 Clculo del ngulo de rotacin

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;

}
}

124

4.8 Cdigo deteccin 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;

125

4.9 Cdigo de la interrupcin 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 articulacin

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 interrupcin

}

126

4.10 Cdigo de la interrupcin Timer2 del PIC18F4550

//interrupcin 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)

LATBbits.LATB7=0;
}

//segunda variable

{
//terminamos el pulso de la segunda variable

//
colocando los bits en uno

if(contador == 3800)

//reiniciamos el pulso

if(contador==1800)

LATBbits.LATB1=1;

{
//iniciamos nuevo periodo
LATBbits.LATB3=1;
LATBbits.LATB6=1;
LATBbits.LATB7=1;
contador=0;

127

Anexo 5 Imgenes

5.1 Imagen de habitacin no apta para funcionamiento del

sensor

Figura A. 1 Habitacin con condiciones

no aptas para el funcionamiento del
sensor.

5.2 Imgenes de los usuarios controlando el brazo robtico

5.2.1 Usuario nmero 2

5.2.2 Usuario nmero 3

Figura A.3 Usuario 2 (1.51metros)

Figura A. 2 Usuario 3 (1.62metros)

5.2.3 Usuario nmero 4

5.2.4 Usuario nmero 5

128
Figura A. 5 Usuario 4 (1.60metros)

Figura A. 4 Usuario 5 (1.50metros)

Anexo 6 Diagrama de clases de la aplicacin

129