Universidad

Tecnológica de
Puebla
Organismo Público Descentralizado del Gobierno del Estado de Puebla

QUE PARA OBTENER EL TÍTULO DE TÉCNICO SUPERIOR UNIVERSITARIO EN

MECATRONICA AREA DE AUTOMATIZACIÓN

PRESENTA:

ALAN JARED LAGUNA RAMIREZ

ASESORES DE ESTADÍA:

JORGE CEREZO SANCHEZ

1
 Desarrollo e implementación de un sistema de
detección de esqueleto para aplicaciones robóticas
Índice:

Página

Capítulo 1: Introducción. ------------------------------------------------------------------------------ 3.

Capítulo 2: Resumen de reporte de estadía (en inglés). ----------------------------------- 4.

Capítulo 3: Descripción de las actividades. ---------------------------------------------------- 5.

Capítulo 3.1: Descripción del Kinect. ------------------------------------------------------------- 5.
Capítulo 3.2: Descripción e instalación de los drivers. ------------------------------------- 7.
Capítulo 3.3: Implementación del desarrollo del proyecto. ------------------------------- 10.
Capítulo 3.4: Descripción de los softwares. ---------------------------------------------------- 14.
Capítulo 3.5: Implementación del proyecto parte 1 (Skeleton tracking). -------------- 21.
Capítulo 3.6: Implementación del proyecto parte 2 (Comunicación serial
a través de arduino y processing).------------------------------------------------------------------ 27.
Capítulo 3.7: Desarrollo del proyecto parte 1 (Creación del código).------------------- 28.
Capítulo 3.8: Desarrollo del proyecto parte 2 (Creación del robot
animatrónico).---------------------------------------------------------------------------------------------- 37.
Capítulo 3.9: Final del proyecto. --------------------------------------------------------------------- 41.

(17 DE AGOSTO
Capítulo 4: Conclusión. --------------------------------------------------------------------------------- 44. DEL 2022)

Capítulo 5: Anexos. -------------------------------------------------------------------------------------- 45.

Capítulo 6: Referencia Bibliográficas -------------------------------------------------------------- 53.

2
Capítulo 1: INTRODUCCIÓN.

En este reporte se encuentra el proyecto para la realización de un manual en cual

realice el funcionamiento y contracción de un robot imitador por medio del Kinect,
en el cual tenía como tarea investigar las formas y maneras de realizar dicho
proyecto, para eso tuve que investigar diversos temas en cual pudiera realizar el
proyecto de robot imitador.

El reporte contiene toda la información y metodología de cómo realizar y poner

practica el uso de detección de esqueleto utilizando el aparato Kinect. El programa
de skeleton que es un programa el cual se interactúa con el Kinect a través de
diversos software de programación como LabView, Open cv, developer toolkit y
processing.

También contiene la información y descripción acerca del Kinect, como fue

construido, sus funciones principales y que otros usos le puedes brindar para
realizar proyecto entorno a la detección de esqueleto.

Este reporte te servirá mucho, pues no solo emplea conocimientos previos entorno
al área de mecatrónica, sino que también aprenderás nuevas cosas relacionadas
con programación digital utilizando softwares que empleen lenguajes como java y
de ese modo poder aplicarlas a futuro cuando realices proyectos en ingeniería.

Una vez que el Kinect se tenga a la mano se comience a investigar diversos temas
acerca de cómo interactuar con el Kinect a través de un equipo de cómputo en
diversos software de programación, para que así de ese modo pueda realizar el
proyecto del robot imitador.

El objetivo del proyecto es que con la diversa información que se establece en

este reporte acerca del uso del Kinect y los diversos softwares que se
implementan aquí a través de un equipo de cómputo es que se construya un robot
animatronico el cual detecte el esqueleto humano a través del Kinect
representándolo en la computadora y de ese mismo modo que dicho robot siga el
movimiento de los brazos de arriba y abajo, es decir que siga los movimientos de
un brazo humano que se mueva asía arriba y hacia abajo..

3
Chapter: Summary of the stay report.

In summary, two activities will be reported in this report. The first activity is to write
all the research and various methods that were implemented to reach the
realization of the robot mimic project, each research, use of software, method of
solution and errors that have been presented since I received the Kinect from my
teacher will be written.

After writing all the information and research about the mimic robot project, I will
write how I arrived to find the method to make it, in this case I will write what
programming software was effective for its construction and programming, as well
as explaining the program and code of its development through the software used.

The key points and methods that were implemented at the time of its elaboration
will be established together with the information that is investigated on its
elaboration, also at the time of its programming it will be written if there was or was
presented some type of error at the time of its programming, also the investigations
that were made to be able to program and to use the software that was used to
create the robot imitator will be written.

As activity two will be attached the manual of elaboration, programming and

construction of the imitator robot, adding all the key points of how to create and
program it, starting from which software to use, the drivers that need to be installed
for its connection with the Kinect with the computer equipment, the various
methods that will be used for its programming, In addition, it will contain all the
theoretical content on its construction.

The meaning of each method that will be used in its programming and the meaning
of the software that will be used will be added as well as specify how to use it and
its advantages of using the software that will be used, the materials that will be
used in the elaboration of the robot will also be specified step by step each process
from scratch at the time of its elaboration.

The connection that will be used for the realization of the imitator robot circuit will
also be explained in detail, attaching explanatory images and methodology of the
project, as a final part images of the finished project will be added as proof that the
project was tested and worked properly.

4
Capítulo 3: DESCRIPCIÓN DE ACTIVIDADES. (Desarrollo)

Como primera actividad se tiene que hacer que el Kinect se conecte con el equipo
de cómputo para que así se pueda interactuar con él, para ello se tiene que
instalar diversos drivers para así se pueda realizar el proyecto de skeleton tracking
una vez completado el proyecto de skeleton tracking, se desarrollara un robot
imitador que copiara los movimientos de los brazos por medio del Kinect, pero
para ello se tiene que investigar todo acerca del Kinect e investigar acerca de
cómo interactuar con la computadora.

Capítulo 3.1 Descripción del Kinect:

Comencemos por explicar que es el Kinect, el Kinect para Xbox 360, o

simplemente Kinect (originalmente conocido por el nombre en clave «Project
Natal»), fue un controlador de juego libre y entretenimiento creado por Alex
Kipman, desarrollado por Microsoft para la videoconsola Xbox 360, y desde junio
de 2011 para PC a través de Windows 7 y Windows 8. Kinect permite a los
usuarios controlar e interactuar con la consola sin necesidad de tener contacto
físico con un controlador de videojuegos tradicional, mediante una interfaz natural
de usuario que reconoce gestos, comandos de voz, y objetos e imágenes. El
dispositivo tiene como objetivo primordial aumentar el uso de la Xbox 360, más
allá de la base de jugadores que posee en la actualidad. 5 En sí, Kinect compitió
con los sistemas Wiimote, Wii MotionPlus y PlayStation Move, que también
controlan el movimiento para las consolas Wii y PlayStation 3, respectivamente.
Kinect fue lanzado en Norteamérica el 4 de noviembre de 2010 y en Europa el 10
de noviembre del mismo año. Por su parte, en Australia, Nueva Zelanda y
Singapur se lanzó el 18 de noviembre y en Japón el 20 de noviembre del mismo
año. Kinect gozó de enorme popularidad y ventas durante los primeros años,
convirtiéndolo en uno de los periféricos más vendidos de todos los tiempos.
Sin embargo, para cuando la versión 2.0 del dispositivo fue lanzada junto a Xbox
One, el concepto ya mostraba síntomas de agotamiento comercial. Tras muchos
intentos de recuperación por parte de Microsoft, finalmente fue descontinuado en
abril de 2016 para Xbox 360 y en octubre de 2017 para Xbox One.

Figura 1, (presentación del Kinect)

Microsoft Research invirtió veinte años de desarrollo en la tecnología de Kinect de

acuerdo con las palabras de Robert [Link]. Kinect fue anunciado por primera vez
el 2 de junio de 2009 en la Electronic Entertainment Expo 2009 como "Project
Natal".

5
El nombre en clave Proyecto Natal responde a la tradición de Microsoft de utilizar
ciudades como nombres en clave. Alex Kipman, quien incubó el proyecto, decidió
ponerle el nombre de la ciudad brasileña Natal como un homenaje a su país de
origen y porque la palabra natal significa de o en relación al nacimiento, lo que
refleja la opinión de Microsoft en el proyecto como el nacimiento de la próxima
generación de entretenimiento en el hogar. Poco antes de la E3 2010 varios
weblogs tropezaron con un anuncio que supuestamente se filtró en el sitio italiano
de Microsoft de que sugirió el título "Kinect" que confirmó más tarde junto con los
detalles de una nueva Xbox 360 más delgada.
El sensor de Kinect es una barra horizontal de aproximadamente 23 cm (9
pulgadas) conectada a una pequeña base circular con un eje de articulación de
rótula, y está diseñado para ser colocado longitudinalmente por encima o por
debajo de la pantalla de vídeo.
El dispositivo cuenta con una cámara RGB, un sensor de profundidad,
un micrófono de múltiples matrices y un procesador personalizado que ejecuta el
software patentado, que proporciona captura de movimiento de todo el cuerpo
en 3D, reconocimiento facial y capacidades de reconocimiento de voz. El
micrófono de matrices del sensor de Kinect permite a la Xbox 360 llevar a cabo la
localización de la fuente acústica y la supresión del ruido ambiente, permitiendo
participar en el chat de Xbox Live sin utilizar auriculares.
El sensor contiene un mecanismo de inclinación motorizado y en caso de usar un
Xbox 360 del modelo original, tiene que ser conectado a una toma de corriente, ya
que la corriente que puede proveerle el cable USB es insuficiente; para el caso del
modelo de Xbox 360 S esto no es necesario ya que esta consola cuenta con una
toma especialmente diseñada para conectar el Kinect y esto permite proporcionar
la corriente necesaria que requiere el dispositivo para funcionar correctamente.
El sensor de profundidad es un proyector de infrarrojos combinado con un
sensor CMOS monocromo que permite a Kinect ver la habitación en 3D en
cualquier condición de luz ambiental. El rango de detección de la profundidad del
sensor es ajustable gracias al software de Kinect capaz de calibrar
automáticamente el sensor, basado en la jugabilidad y en el ambiente físico del
jugador, tal como la presencia de sofás.
El hardware de Kinect se ha confirmado que se basará en un diseño de referencia
y la tecnología 3D-calor fabricados por la compañía israelí de
desarrollo PrimeSense Ltd.
Kinect es una herramienta demasiado útil, ya que hoy en día no solo puede usarse
solo para videojuegos si no también gracias a la detección de esqueleto en su
sistema se le pueden dar diversos usos como usos medicinales en torno al
reconocimiento esquelético del ser humano o para usos robóticos avanzados
como imitación de máquinas a través del cuerpo humano.

6
 Capítulo 3.2: Descripción e instalación de los drivers.

Estos son los drivers que se utilizan para interactuar con el Kinect atreves de la
computadora, el Kinect for Windows Speech Recognition Language Pack, Kinect
for windows runtime, Kinect for windows Drivers y Kinect for windows Developer
Toolkit estos drivers sirven para que el lenguaje del Kinect sea compatible con el
lenguaje del equipo de cómputo y así el Kinect pueda interactuarse con la
computadora a través de diversos software de programación. También se utilizará
un adaptador para conectar el Kinect al equipo de cómputo ya que el Kinect por sí
solo no puede conectarse a la computadora.

Figura 2, (Adaptador Kinect a PC) Figura 2.1, (Driver Kinect for windows)

Se debe instalar un software que viene con todos los drivers ya mencionados, este
fue el Kinect for windows SDK, este software te permite interactuar con el Kinect y
sus diversas cámaras que posee el Kinect, como la cámara normal, la infrarroja y
la de profundidad, el software SDK te permite visualizar las diversas cámaras que
el Kinect posee, así pueden visualizar la cámara normal o la de profundidad o
incluso la infrarroja o también puede visualizarse todas al mismo tiempo, a través
del equipo de cómputo.

Figura 2.2, (presentación Kinect skeleton tracking) Figura 2.3, (Kinect for Windows cámara de profundidad)
La SDK (Software Development Kit) nos permite acceder al hardware a través del
software. Son las librerías y bibliotecas necesarias para poder acceder a todas las
funcionalidades que nos ofrece Kinect.

Hay dos versiones de la SDK de Kinect. Dependerá de la versión que tengamos

del dispositivo instalaremos una u otra. Es exactamente igual, lo único que cambia
es la versión. Si tienes la versión 1 debes instalar la SDK 1.8 y si tienes la versión
2 debes instalar la versión SDK 2.0 .

7
Todos conocemos Kinect: el sorprendente dispositivo externo para Xbox 360 que
permite jugar con la consola y tener otras experiencias sin controles. Gracias a
esto podemos interactuar de diferentes maneras, no solo para uso gaming, sino
también para proyectos robóticos y diversos métodos de detección de movimiento
y gracias a los drivers y softwares que se mencionan podemos interactuar desde
el equipo de cómputo e incluso podemos programar el Kinect de tal forma que se
pueda realizar una actividad específica en el tal además de que se pueden
programar las cámaras que usa el Kinect y visualizar lo que el Kinect está viendo.

Kinect para Windows se trata de permitir que las Windows PC aprovechen Kinect.
El SDK de Kinect para Windows 1.5 y el Toolkit se lanzaron en mayo de 2012, e
incluyen drivers de Windows para el sensor Kinect, un SDK completo (Kit de
Desarrollo de Software) un toolkit (código muestra, herramientas y documentación
de soporte.

Aquí una lista de lo que necesitas para comenzar a escribir aplicaciones

 Sensor Kinect *
 Windows PC con Windows 7 o posterior OS Windows
 Visual Studio (Express o completo)
 Descargas Kinect para Windows (SDK y Toolkit)

Existen en la actualidad dos sensores Kinect que trabajan con el SDK y el Toolkit
de Kinect para Windows:

El sensor Kinect para Xbox 360 (dice “XBOX 360” en el frente) – estos

dispositivos están autorizados para propósitos de desarrollo, y no soportan el
“Modo Cercano”.

El Sensor Kinect para Windows (dice “KINECT” en el frente) – estos dispositivos

están optimizados para experiencias en Windows, y están autorizados para uso
con Windows PC, y también soportan el “Modo Cercano”.

Los desarrolladores pueden utilizar cualquier sensor para comenzar, pero los
desarrolladores necesitan estar en un sensor Kinect para Windows que puede ser
comprado en línea aquí. Si te interesa experimentar con Kinect y windows, e
integrar experiencias Kinect en tus proyectos (y espero que así sea), te
recomiendo elegir el sensor Kinect para Windows para que tengas acceso a todas
las posibilidades de desarrollo habilitadas en este dispositivo optimizado para PC.

En mi opinión no pensé que un artefacto que se creó para jugar principalmente

pudiera usarcé para otra infinidad de cosas, es sorprendente las cosas que
puedes crear y hacer con Kinect, gracias a sus diversas cámaras que nos permite
visualizar nuestro entorno de diferentes modos.

8
 Gracias al software SDK se pude lograr interactuar con Kinect a través de la
computadora, como primer paso, se interactúa con cada una de las cámaras del
Kinect para ver si todas las cámaras funcionaban correcta mente y serán capases
de interactuar con la computadora, esto para ver si el Kinect podrá servir para el
proyecto que se realizara, para eso se hace una “prueba” de sus cámaras y a su
vez se comprueba la comunicación entre el Kinect y la computadora. Se deben
visualizar las cámaras en el equipo de cómputo tal y como se observa en las
imágenes de la figura 3 y 3.1.

Figura 3, (Representación de las cámaras del Figura 3.1, (Cámara de profundidad del Kinect)
Kinect)
Una vez probado las cámaras e interacción del Kinect a través de la computadora,
se investiga acerca del skeleton tracking y con qué software de programación se
pueda realizar, porque para poder realizar el proyecto se necesitaba del skeleton
tracking, el skeleton tracking es un método en cual tu puedes interactuar con el
Kinect a través de la computadora utilizando su cámara de profundidad esto a su
vez te lanza un esqueleto que representan las uniones de tu cuerpo, utilizando la
cámara de profundidad se puede realizar dicho proceso visualizándote a ti y al
esqueleto tal y como muestran las imágenes de la figura 3.2 y 3.3.

Figura 3.2, (Skeleton tracking) Figura 3.3, (Skeleton tracking a través de la cámara
Capítulo 3.3: Implementacióndedel proyecto.
profundidad)
9
El Skeleton Tracking o seguimiento de esqueleto es un término que puede o no
haber escuchado antes; ha existido durante algún tiempo, pero en algunos casos,
si lo ha encontrado, es posible que no se haya dado cuenta de que la tecnología
detrás de una actividad interactiva única estaba rastreando su esqueleto. Microsoft
Kinect fue uno de los primeros ejemplos de consumo de seguimiento esquelético,
utilizando los datos del movimiento humano para interactuar con los juegos,
representándose en una pantalla de pese como se observa en la figura 4,
representa las uniones que en si es de lo que trata el skeleton tracking, son las
uniones del cuerpo humano representadas digitalmente.

Figura 4, (Visualización del skeleton tracking)

En pocas palabras, el seguimiento de esqueletos utiliza sensores, con frecuencia

cámaras o cámaras de profundidad, para seguir el movimiento de un ser
humano. Similar a la captura de movimiento que puede haber visto en los efectos
especiales de Hollywood, pero sin la necesidad de un traje especial o marcadores
en la persona. Los sistemas de seguimiento de esqueletos suelen utilizar cámaras
de profundidad para obtener los resultados en tiempo real más sólidos, pero
también es posible utilizar cámaras 2D con software de código abierto para
realizar el seguimiento de esqueletos a velocidades de fotogramas más bajas, por
ejemplo, con Openpose.

Las cámaras diferencian a un ser humano de un fondo y luego identifican la

posición de una serie de características o articulaciones, como hombros, rodillas,
codos y manos. Algunos sistemas también pueden rastrear manos o gestos
específicos, aunque esto no es cierto para todos los sistemas de rastreo
esquelético. Una vez que se identifican esas articulaciones, el software las
conecta en un esqueleto humanoide y rastrea su posición en tiempo real. Luego,
estos datos se pueden usar para impulsar pantallas interactivas, juegos,
experiencias de realidad virtual o realidad aumentada o cualquier número de otras
integraciones únicas, como mostrar su ' sombra' proyectada en el costado de un
automóvil real .

10
El uso de cámaras de profundidad de cualquier tipo permite que el sistema de
seguimiento del esqueleto elimine la ambigüedad entre objetos o extremidades
superpuestos u ocluidos, además de hacer que el sistema sea más resistente a
diferentes condiciones de iluminación que un algoritmo basado únicamente en una
cámara 2D. Hay una serie de soluciones de seguimiento de esqueletos que son
compatibles con las cámaras de profundidad Intel RealSense, incluido Cubemos
Skeleton Tracking SDK , lanzado recientemente.

En muchos casos, el software de seguimiento del esqueleto se desarrolla

utilizando un enfoque de aprendizaje automático. Las imágenes o las imágenes de
profundidad se etiquetan para crear conjuntos de datos de entrenamiento en los
que la posición de las articulaciones y el esqueleto se marcó manualmente y, a
partir de ahí, esos datos se utilizan para entrenar el software para que pueda
reconocer las posiciones de las articulaciones o de varias personas en tiempo real.
.

Para obtener una visión más detallada del seguimiento del esqueleto y las
tecnologías que lo impulsan, consulte esta charla de Philip Krejov sobre el
seguimiento del cuerpo en VR/AR con cámaras de profundidad Intel RealSense tal
y como se aprecian en la imagen dela figura 5.

Figura 5, (Kinect Skeleton tracking)

Una de las características más útiles de todos los dispositivos Intel RealSense de
la generación actual es la capacidad de los desarrolladores de cambiar un
dispositivo por otro sin necesidad de realizar cambios significativos en su
aplicación. Esto le permite a un ingeniero desarrollar código una vez, pero aun así
aprovechar los nuevos dispositivos a medida que estén disponibles. Un gran
ejemplo de esto es el Skeleton Tracking SDK. Originalmente desarrollado para
admitir las cámaras de la serie D400, fue necesario cambiar solo una línea de
código para alterar la relación de aspecto del software a una compatible con la
cámara. 

11
Después de realizar este cambio, el software admitió el L515. Al cambiar al L515,
esté podría aprovechar el mayor rango y la fidelidad de borde que ofrece. Como
se puede a apreciado en algunos softwares, Si ya ha desarrollado software para
otra cámara de profundidad Intel RealSense, cambiar a la L515 debería ser igual
de sencillo para usted y, en la mayoría de los casos, todo lo que necesitará serán
cambios menores en la configuración para admitir la cámara LiDAR.

El SDK de seguimiento de esqueletos también funcionará bien con las cámaras de

profundidad de la serie D400, especialmente en aplicaciones al aire libre. Como
muestra la imagen de la figura 6, estas se pueden emplear al aire libre la
diferencia es que una es la cámara de profundidad y la otra es la cámara normal,
pero en ambas se puede usar el seguimiento de esqueleto, solo es cuestión de
que el Kinect detecte al cuerpo humano para que de ese modo lance el esqueleto
o las uniones de su cuerpo representadas en la cámara.

Figura 6, (Skeleton tracking y sus funciones)

Los datos de profundidad sin procesar producidos por Kinect tienen usos
limitados. Para crear experiencias verdaderamente interactivas, divertidas y
memorables con Kinect, necesitamos más información más allá de la profundidad
de cada píxel. Aquí es donde entra en juego el seguimiento del esqueleto. El
seguimiento del esqueleto es el procesamiento de datos de imágenes de
profundidad para establecer las posiciones de varias articulaciones del esqueleto
en una forma humana. Por ejemplo, el seguimiento del esqueleto determina dónde
están la cabeza, las manos y el centro de masa de un usuario. El seguimiento del
esqueleto proporciona valores X, Y y Z para cada uno de estos puntos del
esqueleto. En el capítulo anterior, exploramos técnicas elementales de
procesamiento de imágenes de profundidad. Los sistemas de seguimiento de
esqueletos van más allá de nuestras rutinas introductorias de procesamiento de
imágenes. Analizan imágenes de profundidad empleando algoritmos complicados
que usan transformaciones de matriz, aprendizaje automático y otros medios para
calcular puntos de esqueleto.

12
Así gracias al skeleton tracking se podrá utilizar como una representación angular
en la cual se cargue un código a un controlador y de ese modo poder representar
los movimientos en la computadora y al mismo tiempo que la misma computadora
los representara a través del robot imitador por medio de unos servomotores, en
este caso cada servomotor representaría una articulación en los brazos.

Como primer paso se trata de buscar un software de programación para poder

programar el Kinect y los servomotores para la realización del proyecto, uno de
ellos podría ser LabView, pero debido a que este tiene diversas versiones y no
todas congenian con las librerías se opta por otra opción ya que en pruebas
anteriores se trató de utilizar y debido a la diferencia de versiones las librerías para
comunicarse con el Kinect no funcionaban.

Otro error que se puede presentar es que los diversos software de programación
que utilicen no puedan ser compatibles con los drivers, ya que por cuestión de
versiones o incluso de marca estos no se pueden comunicar ni funcionar con
dichos softwares ya sea LabView, Visual Studio etc.

Entonces lo que se hace en estos casos para no estar probando de software en

software se investiga otro software de programación que nos permita realizar el
skeleton tracking, se investigaron varios softwares, de ese modo con la
investigación se logra encontrar un que funcione adecuadamente para lo que se
requiere y se adapte a los drivers que se instalaron para comunicarse con el
Kinect a través de la computadora, uno de los software que más se ajusta a lo que
necesitamos fue processing, ya que al ser un software de programación digital y
visual nos permite interactuar con el Kinect de una manera muy sencilla, ya que
este fue diseñado para proyección digital encaja bastante bien con lo que
necesitamos, ya que su comunicación es bastante sencilla entre el Kinect y
processing y se pueden visualizar la cámara de profundidad y de ese modo hacer
el skeleton tracking tal y como se muestra en las imágenes de la figura 7 y 7.1,
que representan el seguimiento de esqueleto utilizando el software processing con
el Kinect.

Figura 7, (Skeleton tracking en processing) Figura 7.1, (Programación en processing del

skeleton tracking)

13
Capítulo 3.4: Descripción del softwares.
Processing es un lenguaje de programación y entorno de desarrollo integrado de
código abierto basado en Java, de fácil utilización, y que sirve como medio para la
enseñanza y producción de proyectos multimedia e interactivos de diseño digital.
Fue iniciado por Ben Fry y Casey Reas a partir de reflexiones en el Aesthetics and
Computation Group del MIT Media Lab dirigido por John Maeda.

Figura 8, Processing

La gran ventaja que tenemos con plataformas como Arduino y Scratch es que se

trata de un aprendizaje plug and play es decir, no tenemos que andar
configurando e instalando miles de cosas para ponernos a trabajar. Processing es
un lenguaje que podemos incluir en este método.

Es una plataforma que integra entorno de desarrollo y lenguaje de

programación. Es muy fácil de aprender y solo necesitamos unos minutos para
empezar a programar. Al contrario de las alternativas que tenemos para
desarrollar para entornos gráficos como OpenGL, el cual es bastante complicado y
engorroso, Processing nos facilita esta tarea y nos evita la frustración cuando
queremos aprender un lenguaje de estas características .

Pero su facilidad no quiere decir que no sea un lenguaje potente, al

contrario, podemos hacer proyectos espectaculares y muy complicados.

Una de sus grandes ventajas es que aparte de que no se requiere de licencia para
poder adquirirlo pues puedes descargarlo desde su página oficial el cual está en
constante actualización del software como tal es que no requiere de un
conocimiento avanzado, pues processing incluye las librerías para poder utilizarlo,
y en este reporte se explica de manera detallada el uso y programación de
processing, al ser un lenguaje de código abierto puedes crear tu propio código sin
problema.

14
 Otra característica muy importante es la escalabilidad. Podemos combinar
Processing  con aplicaciones Java, en los dos sentidos, e incluso tenemos la
posibilidad de portar nuestros proyectos a la web gracias a “[Link]”. Solo
necesitamos descargar el JS y a través de la etiqueta canvas de HTML5, hacer
referencia a nuestros archivos creados con Processing, muy sencillo.

Figura 9, (Programación en processing)

Existen 3 maneras de programar en esta plataforma:

 De forma básica, tipo Basic o Ensamblador. Sentencia a sentencia, con

variables globales y sin nada de complejidad.
 Podemos utilizar la programación procedural o estructurada como en C. Algo
más compleja pero mucho más limpia donde crearemos nuestras propias
funciones a las que llamaremos.
 También podemos utilizar la manera más compleja, utilizando toda la
potencia de la programación orientada a objetos.

Figura 9.1, (Visualización de cámara en processing)

15
Cuando estamos programando una aplicación de este estilo, sea cual sea el
objetivo, lo que buscamos es poder ejecutar nuestro proyecto en cualquier
ordenador. Processing nos da la posibilidad de generar un ejecutable para las
diferentes plaformas Mac OS, Windows o Linux e incluso podemos
desarrollar aplicaciones móviles gracias a la SDK que nos ofrecen para Android.
No hay que olvidar que este sistema operativo móvil está basado en Java.

Figura 10, (Programación visual con processing)

Lo bueno de este software de programación es que puede interactuar con Kinect
de una manera muy eficiente y completa, gracias a este software se puede realizar
el skeleton tracking con processing a través del Kinect.

Un pequeño ejemplo de su función de processing es lo que se observa en la

imagen de la figura 10.1, el Kinect se conecta a la computadora y processing
detecta al Kinect y una vez enlazado se prueban sus cámaras una de ellas es la
cámara de profundidad que es lo que se observa, y como pueden ver también se
puede visualizar el seguimiento de esqueleto que el Kinect nos brindada.

Figura 10.1, (Kinect y processing)

16
Pero para poder llegar a ese punto se necesita primero programar en el mismo
processing de tal modo que pueda visualizarnos a nosotros.

Como lo que a nosotros nos interesa es la cámara de profundidad, conectamos el

Kinect ya enlazado al equipo de cómputo, y simplemente se especifica que solo se
quiere visualizar la cámara de profundidad, de ese modo se inicia el programa y
nos lanza la cámara de profundidad en este caso a nosotros capturando nuestros
movimientos, como se muestra en la imagen, lo que esté más cerca del Kinect lo
representara de color blanco y lo que esté lejos de color negro.

Figura 11, (Cámara de profundidad)

En este caso solo se declara en el código de processing que el Kinect solo lanzara
los resultados de la cámara de profundidad, representándolos a través de la
computadora, representando lo que tenga más cerca de color blanco grisáceo y lo
que tenga lejos lo represente de color negro.

Se carga el código para que leyera la cámara de profundidad y la representara en

la computadora, el programa de processing debe lanzarte los resultados de la
cámara de profundidad en tiempo real.

Gracias a la cámara de profundidad se puede representar diversos factoras como

el skeleton tracking que se representa como uniones en nuestro cuerpo formando
un endoesqueleto, que captura los movimientos de nuestro cuerpo, gracias a esos
factores se pueden agregar más elementos para que nos lo represente en la
cámara de profundidad como los ángulos de nuestras articulaciones en todo
nuestro cuerpo, como se observa en la imagen.

Figura 11.1, (Skeleton tracking con processing)

17
Todo esto es posible gracias al software de programación de processing y 2
drivers que nos permiten interactuar de forma directa con la cámara de
profundidad, ya que unos drivers que fueron creados para este tipo de proyectos
quedaron obsoletos con el tiempo y ya no funcionaban adecuadamente, pero
gracias a los drivers de Open NI y Nite nos permite interactuar de forma más
precisa con Kinect y processing utilizando la cámara de profundidad y utilizando
skeleton tracking, pero para poder interactuar más con processing y realizar el
proyecto de detección de esqueleto a través de un robot animatrónico, se necesita
del conocimiento y el origen de estos drivers, que nos permiten realizar la
programación necesaria para poder interactuar con el Kinect a través de un equipo
de cómputo.

Open NI y Nite es una organización que fue creada en noviembre de 2010 y el

sitio web se publicó el 8 de diciembre. Uno de los miembros principales
era PrimeSense, la empresa que creó la tecnología utilizada en la Kinect,
un periférico de entrada que actúa como sensor de movimiento para
la videoconsola Xbox 360 de Microsoft.

En diciembre de 2010, PrimeSense liberó sus propios drivers de código abierto

junto con un middleware de detección de movimiento denominado NITE.
PrimeSense anunció posteriormente que había formado equipo con Asus para
desarrollar un dispositivo compatible para PC similar a la Kinect, que se
llamó Wavi Xtion y está programado para el lanzamiento en el segundo trimestre
de 2012.

Su software está siendo usado actualmente en una variedad de proyectos de

código abierto dentro del mundo académico y la comunidad de aficionados.
Recientemente, las empresas de software han intentado expandir la influencia de
OpenNI simplificando el funcionamiento e integración con la tecnología.

Figura 12, (Logo de Open NI)

18
Prime Sense la empresa detrás de la tecnología de Kinect, junto con Willow
Garage y Side Kick, han lanzado los drivers oficiales de Kinect, se trata en
realidad de un Framework de código abierto llamado OpenNI, que permitirá
manejar en un ordenador y en múltiples plataformas el periférico de
Microsoft, quien dicho sea de paso, al parecer aprueba la idea de esta liberación.

Figura 13, (Características y función de Open NI)

OpenNI permite, por un lado, comunicarse con los sensores de audio, video y
sensor de profundidad de Kinect, mientras que proporciona una API que sirve de
puente entre el hardware del equipo, NITE Middleware y las aplicaciones e
interfaces del S.O. La idea es facilitar el desarrollo de aplicaciones que funcionen
con interacción natural, llámese gestos y movimientos corporales.

Actualmente OpenNI permite la captura de movimiento en tiempo real, el

reconocimiento de gestos con las manos, el uso de comandos de voz y utiliza
un analizador de escena que detecta y distingue las figuras en primer plano del
fondo.

Los Controladores están disponibles, de momento, para Windows 7 y Ubuntu

10.10, y puedes descargarlos desde aquí, también puedes ver información más
detallada en este documento. Mientras tanto, dejo un vídeo que demuestra parte
del funcionamiento de este nuevo controlador.

Ésta liberación representa, en cierto sentido, el punto culmine de un gran trabajo

desarrollado por distintos hackers y entusiastas desde que Adafruit
Industries ofreciera una recompensa por conseguir controladores libres para
Kinect, ahora todo este trabajo desarrollado de forma particular se ve plasmado en
un proyecto oficial impulsado por los mismos creadores del dispositivo.

19
Sin duda se trata de un gran paso que abre muchas posibilidades con este nuevo
controlador bautizado como OpenNI, nombre que también recibe su organización
sin fines de lucro que será responsable de este desarrollo, esperamos
seguir sorprendiéndonos con este interesante «juguetito» que ha recibido alas
gracias al código abierto.
Además OpneNI es una organización sin ánimo de lucro, creada en Noviembre de
2010, para la certificación y mejora de la interoperatibilidad de la interfaz natural
de usuario y la interfaz orgánica de usuario para dispositivos de interacción
natural, las aplicaciones que requieren del uso de estos dispositivos y el
middleware que interactúa con ellos. Uno de sus miembros principales era
PrimeSense, empresa creadora de la tecnología utilizada en la Kinect de
Microsoft, por lo que, tras su adquisición en Abril de 2014 por Apple, el sitio web
oficial de OpenNI,[Link], fue cerrado. Tras el cierre, las organizaciones que
utilizaban esta tecnología conservaron la documentación y los binarios en la
página [Link].
OpenNI proporciona una API que permite la interacción de los dispositivos
hardware compatibles, ya sean de audio, video o profundidad, con las
aplicaciones, permitiéndoles a estas últimas acceder a los datos adquiridos por
estos dispositivos. Al mismo tiempo, OpenNI proporciona una interfaz sobre la que
otros middlewares se pueden apoyar para interactuar con los dispositivos
hardware, simplificando de esta forma su acceso a ellos y amplificando su
funcionalidad mediante la integración de procesos como la detección de gestos,
gracias estas funciones se puede interactuar con klinect desde la computadora y
de ese modo usarcé para distintas aplicaciones, ya que gracias a su detección de
movimiento y la cámara de profundidad, las diversas aplicaciones que se le
pueden dar son demasiadas, como por ejemplo el skeleton tracking, que se
utilizara para la construcción del robot animatrónico o incluso para usos
medicinales, de modo que se pueda detectar si alguna lesión o partidura de hueso
con la detección de esqueleto del Kinect se podría realizar dicho diagnóstico.

Figura 14, (Comunicación con Kinect y Windows)

OpenNi tiene una gran utilidad con processing y Kinect ya que se puede
interactuar con los drivers de Kinect for Windows, lo cual es muy útil ya que
algunos drivers que eran específicamente para el software SDK habían quedado
obsoletos y ya no funcionaban correctamente.

20
Capítulo 3.5: Implementación del proyecto parte 1 (Skeleton
tracking).

Para la realización del skeleton tracking se agrega el código establecido,

declarando las variables específicas.

Figura 15, (Código para el sekeleton tracking)

Como primer paso se indica la librería de SimpleOpenNI, esta para que processing
pueda leer las variables que se declaren, gracias a esta librería se puede utilizar
las diversas variables en el código de processing para que así pueda
representarse en el skeleton trinkhing, también se declara que la librería
SimpleOpenNI estará enlazada con el Kinect de ese modo representara los
resultados a través de cualquiera de sus cámaras del Kinect.

Luego se agregan los valores del Kinect junto con la librería del SimpleOpenNI de
modo que cada variable que se declare la reciba el Kinect y a su vez este mande
los resultados representados en la computadora representándolos en la cámara
de profundidad.

21
 Después se declaran las siguientes variables como aparecen el imagen de la
figura 16 que se quiere mostrar a través del Kinect, en este caso la cámara de
profundidad, que deberá mostrarte la imagen del entorno que capte el Kinect con
la cámara, de ese modo solo utilizo la cámara de profundidad del Kinect, y en cual
se puede programar de modo que declare las variables que quiero que nos
muestre la cámara.

Figura 16, (Declaración de las variables de las extremidades del cuerpo para el seguimiento de esqueleto)
Luego una vez establecida las variables para la comunicación entre processing y
el Kinect, se declaran las variables para que este pueda leer y captar los
movimientos de cada extremidad de nuestro cuerpo, para ello se debe declarar
cada extremidad de nuestro cuerpo para que este la represente a través de la
cámara de profundidad lanzando una línea que represente cada extremidad en
nuestro cuerpo a través de la cámara.

Se declaran las variables para que cuando la cámara detecte nuestro cuerpo este
lance un tipo de esqueleto que representarán las uniones de nuestras
extremidades, todas estas representadas en la cámara de profundidad que capte
el Kinect, mandándolas a processing, para ello se declara cada articulación y
extremidad en nuestro cuerpo para que este lance el esqueleto y siga los
movimientos de nuestras extremidades.

Con la librería de SimpleOpenNI se declaran las variables que esta librería nos
ofrece en este caso las extremidades de nuestro cuerpo para que las pueda leer el
Kinect y las represente por medio de la cámara de profundidad, se deben colocar
todas las variables en torno a cada articulación y extremidad en nuestro cuerpo,
todo como se aprecia en la imagen.

22
Se inicia colocando las variables para que detecte la cabeza y torso
representándolos solamente con líneas rectas, en el caso del torso, se hace que
representen dos triángulos inversos conectados desde el vértice unidos a la línea
que representa la cabeza, en el caso de los brazos y las piernas del lado derecho,
se declaran las variables de las articulaciones en este caso el codo y el brazo
representado de igual campo dos líneas unidas entre sí, todo unido al torso que
vendrían siendo los triángulos inversos.

En el caso de la pierna derecha se aplica el mismo método solo que declarando

que fuera esta vez la pierna derecha que estuviese unida debajo del torso
representado igual como una línea hasía abajo, declarando las articulaciones en
este caso solo vendría siendo mi rodilla.

Una vez se allá declarado las extremidades del lado derecho se deben declarar
las variables para las extremidades del lado izquierdo, en este caso se aplican las
mismas variables declarando cada extremidad de mi lado izquierdo, se debe
aplicar lo mismo que con el lado derecho solo que debe declararse que las dos
extremidades es decir el brazo y pierna izquierda, se ubicaran asía e ese mismo
lado, tal y como se muestra el código de la imagen de la figura 17.

Figura 17, (Declaración de las variables de las

extremidades de los brazos)

23
Una vez se allá declarado las variables de mis extremidades, se deben colocar las
variables para que todas las variables que declararon sobre las extremidades de
nuestro cuerpo la representaran a través de la cámara de profundidad del Kinect
declarando la distancia y ángulo necesario para detectar nuestro cuerpo y a su vez
representar el esqueleto de movimiento de nuestro cuerpo, es decir la cámara de
profundidad nos debe detectar a nosotros siempre y cuando estemos en la
distancia específica y una vez nos detecte aparecerá el esqueleto de movimiento
de nuestro cuerpo quien seguirá los movimientos de nuestras extremidades, como
lo muestra el código de la imagen de la figura 18.

Figura 18, (Declaración para los ángulos y el

seguimiento de extremidades)
Kinect se desarrolló con una finalidad de adentrar al usuario dentro de ambientes
virtuales, gracias a sus cámaras que posee el Kinect nos permite visualizar lo que
ven las cámaras como la infrarroja, la de movimiento y su cámara normal, gracias
estas diversas cámaras que posee, podemos visualizarnos de diferentes entornos
y gracias processing nos per mite programar los ángulos y el movimiento de
nuestras articulaciones, gracias a esto podemos realizar el programa de skeleton
tracking.

El algoritmo tiene como objetivo el reconocimiento esquelético de un individuo en

tiempo real. Sus fundamentos básicos consisten en la captura de imágenes de
profundidad con las cámaras y sensores con los que cuenta, se hace un
procesamiento y una estimación de la distancia entre el sensor y los diversos
objetos que se encuentran en su campo de visión, en este caso sería el cuerpo
humano, clasifica cada parte extremidad por secciones y en base a esto identifica
una de las 20 articulaciones que es capaz de detectar, gracias a eso el Kinect nos
visualiza a nosotros utilizando la cámara de profundidad arrojando los datos que le
insertamos en el código del programa.

24
Ya teniendo todo el programa del Skeleton Tracking en processing se copila el
programa para detectar algún error en el código o error de sintaxis, pero si todo
sale bien y no te arroja ningún error puedes correr el programa, pero antes
asegúrate de que el Kinect esté conectado a la computadora, ya conectado el
Kinect al equipo de cómputo utilizando el adaptador de Kinect a pc está preparado
para correr el programa.

Una vez que todo esté bien y conectado se inicia el programa en processing, el
cual una vez sea iniciado deberá lanzarte la cámara de profundidad visualizada en
la computadora, una vez ya está cargada la cámara y puedas visualizarla te
colocas en el Angulo de visión del Kinect, una vez el Kinect ya te allá detectado,
deberá insertarte el esqueleto que declaraste en el programa, el cual se
representa en la cámara como un endoesqueleto en tu cuerpo tal y como se
aprecia en la imagen de la figura 19.

Figura 19, (Visualización de la cámara de profundidad junto al skeleton tracking)

Si todo resulta bien y no se tuvo ningún error, la cámara de profundidad debe
detectar nuestro cuerpo y arrojar el esqueleto de movimiento el cual debe seguír
cualquier movimiento de nuestro cuerpo en tiempo real, gracias a esta primera
parte se pode realizar la siguiente fase con el proyecto del robot imitador ya que
para poder hacer el robot imitador se necesita del seguimiento de esqueleto de
ese modo poder programar ambos brazos en nuestro cuerpo y representarlo con
el robot imitador ya que también se pueden colocar los ángulos de cada
extremidad en nuestro cuerpo y que cambien constantemente siempre que mueva
los brazos o los pies.

De ese modo se puede declarar que en base a los ángulos un servomotor que
representaría una articulación nuestra siga los patrones del ángulo, en cuanto
valla cambiando su posición del ángulo este siga esos patrones y mueva al
servomotor dando como resultado la imitación del movimiento de nuestros brazos
a través del servomotor.

25
Para retroalimentación refuerzo explicamos a detalle qué es y de qué se trata el
Skeleton tracking o seguimiento de esqueleto. Skeleton tracking es un método del
Kinect en cual se puede aprender e interactuar mucho con el Kinect ya que con el
se pueden hacer diversos proyectos e experimentos ya que gracias a sus diversas
cámaras que el Kinect posee esté se le puede interactuar de diversas formas
diferentes.

La parte fundamental de MuscleKIN es la detección y seguimiento del esqueleto

humano (también conocido como Skeleton Tracking) para comparar las posturas
que presentan los usuarios con las posturas correctas preestablecidas y
verificadas. Por ello se hizo uso de las instrucciones integradas en la suite de
desarrollo de Kinect bajo la programación un nuevo algoritmo que fuera capaz de
detectar la posición en 3 dimensiones de las 20 articulaciones que son posibles
detectar con el dispositivo Kinect, mismas que se identifican en la cabeza, hombro
central, hombro derecho, hombro izquierdo, codo derecho, codo izquierdo,
muñeca derecha, muñeca izquierda, mano derecha, mano izquierda, columna,
cadera central, cadera derecha, cadera izquierda, rodilla derecha, rodilla Izquierda,
tobillo derecho, tobillo izquierdo, pie derecho y pie Izquierdo.

Al igual que con la cámara RGB y la cámara de profundidad, se habilita e inicializa

el Stream respectivo y se crea el controlador de eventos, dentro de ésta asigna
una variable de tipo Skeleton que recibirá información constantemente por ello se
debe asignar un valor de tipo Array, así mismo utilizando la sintaxis using se hace
un escaneo de la detección del esqueleto y envía esa información de las
articulaciones a una variable que posteriormente serán usadas para el algoritmo
de comparación y para el dibujado del esqueleto del usuario dentro de la interfaz.
Tiene una resolución de 640x480 pixeles y a una velocidad de 30 fps tal y como se
muestra en la imagen de la figura 20.

.
Figura 20, (Representación visual del skeleton tracking)

26
Capítulo 3.6: Implementación del proyecto parte 2 (Comunicación
serial a través de arduino y processing)

Una vez probado el skeleton tracking, se comienza con la programación para del
diseño del robot imitador, para ello necesitamos declarar los ángulos que
queremos representar en los servomotores, para ello declaramos que solo nos
muestro las uniones de nuestros brazos izquierdo y derecho, una vez echo eso
agregamos los ángulos de ambos brazos esto para los valores que vayan
cambiando se manden al servomotor y esto teóricamente debe seguir nuestros
movimientos de nuestros brazos a través de los servomotores..

Processing tiene algo que lo hace demasiado útil para proyectos similares a este y
es que processing puede interactuar con otros software de programación uno de
ellos es Arduino, ya que processing puede utilizar el código que se crea desde
arduino y al mismo tiempo asignar el código que se le declare en el mismo
processing, esto se utilizará para poder mandar las señales al servomotor,
utilizando una tarjeta arduino y el software de programación de arduino, en
resumen se utilizarán ambos softwares para realizar el animatrónico.

Figura 21, (Comunicación entre arduino y processing)

Arduino es una de las placas más populares del mundo. Su versatilidad y la

infinidad de posibilidades que ofrece la convierten en una de las
herramientas de programación más completas del mercado. Si no sabes
qué es un arduino, estás en el lugar indicado: a continuación te
explicaremos qué es y para qué sirve un arduino.

Entonces, ¿te imaginas ya para qué sirve un Arduino? Por darte una idea, con un
Arduino puedes crear básicamente lo que quieras, desde una báscula, un reloj,
hasta unas puertas controladas por voz, etc. Para que puedas entender cómo
podemos pasar de un microordenador a un sistema complejo como el que
acabamos de mencionar se implementara el código de los servomotores en lazado
a processing que esto al mismo tiempo estará conectado al Kinect.

27
Capítulo 3.7: Desarrollo del proyecto parte 1 (Creación del código)

Lo que se tiene que hacer es computar los ángulos de mis brazos y a su vez que
este los replique atreves de cuatro servomotores que representaran las
articulaciones del robot imitador, lo que significa que cada movimiento que se
haga con los brazos el robot lo replicara en tiempo real, ósea que si se muevo un
brazo asía abajo el robot ara lo mismo al mismo tiempo.

Gracias a que processing puede comunicarse con arduino sin ningún problema
simplemente se crea el código para le programación del robot, empleando el
skeleton tracking como apoyo para la creación del robot, se comienza diseñando
el código base para el robot imitador, para ello se inicia creando las variables ya
conocidas, declarando la librería de SimpleOpenNI.

I
Figura 22, (Desarrollo del código para la creación del robot
animatronico)

Se Inicia agrando la librería de SimpleOpenNI, esto para poder declarar las

variables que me permite interactuar con el Kinect, además se agrega otra librería
exclusiva de processign, este es [Link], está nos permitirá
comunicarnos de forma serial con arduino, de ese modo se puede interactuar con
la tarjeta de arduino y declarar las variables para que el arduino las pueda leer
atreves de processing .

28
Después se declaran los valores para comunicarme con el Kinect a través de las
variables que se declaran en el programa y los valores de la comunicación serial
a través del arduino, esto será para que usando el skeleton tracking agregaré los
ángulos a nuestros brazos insertando las variables en el código de processing
para que me arrojen los resultados en la cámara de profundidad y de ese modo
mandarlos al arduinio para que este agá actuar los servomotores.

Lo que se hace a continuación es computar los ángulos del brazo derecho a través
de processing, para entenderlo de una manera más concreta se obtienen estos
ángulos y simplemente obteniendo estos ángulos pasárselos al robot de ese modo
se podrá mandar esos resultados al arduino para que los servomotores repliquen
los movimientos de los brazos tal y como se muestra en la parte “float” del código
de la figura 23

Figura 23, (Declaración para los ángulos de las extremidades de los brazos)

Este proceso será bastante sencillo, usando él método de skeleton tracking que es
el uso de imágenes de profundidad , en este caso dadas por el Kinect para
determinar las uniones de un ser humano por ejemplo podemos determinar la
cabeza las manos los hombros los codos rodillas o muchas otras uniones dentro
de un ser humano, que es lo que aplique antes, esto fue como primera parte para
la realización del robot imitador, utilizando el skeleton tracking como primera parte
del código, una vez obteniendo el seguimiento de esqueleto como lo muestra la
imagen de la figura 24, se inicia con la captura de ángulos de los brazos.

29
 Figura 24, (Uso del skeleton tracking)
Ahora voy a explicar un poco aquí con el código como obtengo los ángulos de mis
uniones que es lo más importante para este formar “quinimarí” que como tal es
obtener los datos que le vas a mandar al controlador que en este caso vendría
siendo mi arduino que van a hacer mover los motores esa cantidad exacta es decir
si no quedó claro en forma cinematics lo que haces es tú le dices a partir de un
“feedback” que en este caso es mi cámara cuánto se va a mover cada motor por
cada actuador o cada cosa que estés manejando qué cantidad exacto se va a
mover a partir de lo que tu cámara obtuvo sensor o cualquier cosa que
generalmente después en visión de computadora se está viendo, comenzaremos
creando un brazo en el robot imitador una vez se cree y pruebe el brazo del robot
imitador se creara el otro brazo, como la muestra el “void draw()” del código en la
imagen de la figura 24.1.

Figura 24.1, (Declarando las variables para el brazo

izquierdo)

30
bueno para comenzar con el código se crea la imagen de profundidad luego se
crean las variables para obtengo los ángulos, bueno para obtener los ángulos lo
que se hace es simplemente es visualizarlo en un dibujo la imagen del Kinect
además de hacer uso del skeleton tracking proporcionado por openNI, aplicando el
skeleton ranking y una vez que éste ha detectado un esqueleto una persona
mandó a llamar a mi función “jaws Clayton” y “aarón sun gold” que como su
nombre lo dice una dime dibuja el esqueleto y otra mesa que la el ángulo de mis
brazos para dibujar el esqueleto lo único que se hace es mandar a llamar a la
función holding donde simplemente dibujo dos extremidades la que hay entre el
codo y la mano y la que entre ellos se manda a llamar a la función “draw join”
que es una función que define más abajo en la cual simplemente dibujo tres
puntos del codo, hombro y mano y como tal eso es lo que hace la función “dry
jon” dibujarme esas uniones.

Después tenemos las funciones, las cuales son parte del skeleton tracking, pero
como solo necesitamos las de los brazos, se reducen las demás extremidades
eliminando los demás partes, de modo que solo marque el brazo derecho, tal y
como muestra el código en la imagen utilizando la función “drawLimb” se
insertan las uniones del brazo derecho que en este caso son el codo y el hombro.

Figura 25, (Declarando las uniones del brazo )

31
Después tenemos una función llamada ángulo la cual nos define el ángulo entre
dos extremidades y un eje de referencia y tengo mi función “arms and gold farms
ángulo” lo que hace es crear un director para la mano derecha el codo derecho el
hombro derecho y la cadera derecha y en estos vectores guarda la referencia de
la posición de la unión pues para cada una es diferente en el caso del “right
hand” que lo que hace es guardar lo de la mano derecha en el caso del codo
bueno guarda lo del codo y así ustedes saben que necesita saber el ángulo entre
mi mano derecha codo y el hombro.

Entonces lo de la cadera para que es bueno esta cadera nos sirve como eje de
referencia, lo vamos a ver aquí más abajo el kinect que me va a devolver estos
vectores que definía aquí arriba como posiciones en un espacio tridimensional me
da el eje x-y-z como tal yo no quiero el eje z, porque si me alejo de la pantalla lo
que va a hacer, va a hacer que mis extremidades se muevan menos que cuando
estoy más cerca, es como si tú estás viendo en una ventana y ves un perro
corriendo, él puede correr mucho a lo lejos y tú ves que se movió un poquito en tu
vista y si pones un dedo enfrente de ti y lo mueves un milímetro este se abra
movido lo mismo que el perro, entonces quiero evitar que varíe las distancias y
todo lo que estoy midiendo dependa de la profundidad.

Entonces creo vectores en dos dimensiones tal cual, los mismos que saque en
ambos los ago bidimensionales en su mismo nombre 2d y sólo guardando el
componente en “x” y el componente en “y” de cada vector tal y como se observa
en la imagen.

32
 Figura 26, (Declaración de los ángulos)

Finalmente también se crean dos vectores nuevos agregando las variables

“orientation” y “operarme orientation” estos vectores son mis ejes, es decir el
“torso orientation” crea un vector entre el hombro derecho y la cadera derecha,
significa que como están viendo en la pantalla crea un vector vertical al cuál va a
ser mi referencia a la hora de calcular el ángulo del hombro y el “operar
morientes jon”, lo que hace es crear un vector entre codo derecho y el hombro
derecho.

Entonces se crea un vector como la hacia donde apunta a mí con mi parte baja del
brazo y es un eje de referencia que va a ser usado para calcular el ángulo.
Entonces ahora lo guardo como ángulo del hombro derecho mandando a llamar a
la función ángulo y le mandó tres parámetros de mi codo derecho 2d, mi hombro
derecho 2d y el eje de referencia, mi torso “orientation” que llevamos aquí a la
función angulados me pide esos tres parámetros, lo que hace es crear la
extremidad entre los dos vectores que le di en este caso mi codo y mi hombro me
crea esa línea y agarra el eje de referencia.

Entonces ahora lo que se hace es que nos regrese en grados el ángulo entre mi
extremidad que cree justo arriba y la niegue, entonces me regresa ese ángulo que
quiero y lo transforman a grados ya que todo esto se hace con radiales y
aplicando la misma función en el otro ángulo, aplicándolo al ángulo entre mi mano
y mi codo como se muestra en el código de la imagen.

Figura 27, (Configuración para que los ángulos nos muestre

el resultado en grados) 33
Finalmente con estas líneas se despliegan en pantalla esos ángulos en un texto
rojo para visualizarlo en la cámara de profundidad, este quiere decir que una vez
que la cámara me detecte este lanzara los ángulos de nuestro brazo derecho.

Ahora como tal sólo se debe mandar el código que se estableció en processing a
nuestro arduino, para ello usando la librería que cree al principio
“[Link]” para mandar los datos del arduino al processing y viceversa,
creo mi objeto arduino y creó el objeto declarando el puerto serial al que estará
conectado ni arduino que en este caso es el “COM3” y diciéndole los baudios que
voy a trabajar que son “9.600” baudios como lo muestra la imagen del código.

Figura 28, (Declaración para la comunicación serial entre arduino y processing)

Ahora solo hay que dirigirse a la parte del código donde está en la función “arms
and gold” y justo cuando sacan los ángulos se lo voy a mandar al arduino esto
para que de ese modo puede hacer a actuar a los servos mediante los valores del
ángulo, se tiene que enviar primero un texto el cuál va a decir “southern” con
esto el específico que quiero que lo mande al hombro derecho y le voy a poner
una diagonal y lo voy a concatenar esto para que me mandé el ángulo del
hombro derecho y finalmente le voy a mandar un salto de línea y voy a mandar el
mismo comando diciéndole ahora que en el texto sea para el codo y le mando el
ángulo del codo y finalmente un salto de línea.

34
Con esto cada vez que saque un ángulo se lo va a mandar a mi arduino de esta
manera cada vez que el ángulo registre un nuevo valor conforme al movimiento de
mi brazo éste se lo mandará al arduino para saber qué ángulo pasarle a cada
servo, así cada ángulo representa una articulación de este modo los ángulos se
representarán con los servos siguiendo mis movimientos y estos actuarán al
mismo tiempo como se observa en el código de la imagen.

Figura 29, (Declaración de las variables entre arduino y processing)

Con esto el programa de processing se comunicará por medio del arduino, el

arduino recibirá las ordenes que se establecen en el código y este las recibirá, a
su vez se cargar un código base al arduino este para pueda mandar esas señales
que reciba del processing a otro medio, este medio serán los servomotores, que
por medio del código de processing estos representaran los ángulos que la
cámara del Kinect capte, es decir cuando allá captado la profundidad y detecte la
extremidad en mi brazo este representará los ángulos y cada vez que mueva mi
brazo dichos ángulos cambiaran sus valores y estos mismos valores serán los que
el arduino recibirá, que una vez que el arduino los reciba este los anduviera a los
servomotores y de ese modo el servomotor se moverá en dirección al ángulo que
este marcando en la cámara del Kinect captada a través de processing
representada con la cámara de profundidad lanzara los movimientos de mi brazo
por medio de los ángulos y estos harán que el servomotor se muevo lo que
significará que los servomotores seguirán el movimiento de mis brazos
moviéndose con ellos en tiempo real.

35
Una vez teniendo el programa ya completado en processing, se comienza a
realizar el código en arduino para los servomotores y para pueda recibir la señal el
arduino a través de processing, en mi caso utilice un “arduino uno r3”, inicie
declarando la librería para manipular y controlar los servomotores que utilice luego
creo los objetos del servo que representarán mi codo y mi hombro derecho,
después colocó la comunicación serial a 9600 baudios, que especifique en
processing tal como lo muestra el código de arduino de la imagen.

Figura 30, (Código del arduino)

Luego se declaran los pines a los cuales se enlazaran los servomotores que en
éste caso fueron el pin “8” y el pin “7” y les di una poscicion inicial que fueron de
90° y 0° esto para que no hubiera fallos a la hora de iniciar el programa.

Como parte final se agregan las variables para la comunicación serial a través de
processing los cuales captará los datos que la cámara lanze y los mandará al
arduiono para que aga actuar los servomotores, es decir aquí en processing le
mando el identificador que dice que éste es para el hombro y el ángulo que esté
en ese hombro y el salto de línea, entonces mi código en arduino lo que va a
hacer es leer cada salto de línea entonces va a leer todo esto que venga de aquí
como un “string” y después todo el que venga para el codo como otro “String” y
así indefinidamente como línea y línea, una para el codo y una para el hombro,
así después declaró una variable de tipo entero que se llama “data = seperator”
esto es para obtener el índice de la barra que es dónde nosotros separamos
nuestro

36
identificador es decir el tipo de servo al cual va a ir con el ángulo que después
declaró con otra variable llamada “lente” en la cual voy a guardar el largo de “dell
streak” una variable de tipo “string” llamada “aid” y el identificador en el cual
voy a guardar desde el índice cero hasta el separador de mi palabra es decir como
un separador hasta donde se encuentra la barra me va a sacar la primera mitad
como el “string” es decir para saber si es el “shoulder” o para saber si es el
“bold” después crea una variable llamada “value” de tipo entero donde hago lo
mismo, separó la elección que viene y lo voy a separar después de que termine la
barra hasta el largo de la palabra entonces obtengo todo lo que el resto de la
palabra que en este caso sería el ángulo del servomotor y después convierto esto
en entero para poder utilizarlo como un valor que se le pasa al servomotor.

Capítulo 3.8: Desarrollo del proyecto parte 2 (Creación del robot

animatronico)

Una vez listo el programa se carga al la tarjeta arduino en este caso sería un
“Arduino uno R3” y se comienza a cargar el programa en processing, antes de
eso se deben colocar los servos conectándolos al arduino utilizando una
protoboard conectándolos de la manera como nos indica el diagrama de la imagen
de conexión, conectamos ambos servos iniciando como primera parte, en este
caso se prueba primero el brazo derecho, que se representa con los 2
servomotores, en el cual uno representa el codo y el otro representa el brazo,
haciendo la conexión conectado la señal al pin del arduino y la corriente a positivo
donde se conecta las energía que proporciona el arduino el cual son 5V y la señal
negativa a tierra que ya están enlazado con el arduino a través de la protoboard
una vez conectado los servos, conecto el Kinect a la computadora he inicio el
programa.

Figura 31, (Diagrama del circuito para el brazo izquierdo)

37
Una vez cargado el programa se coloca en una posición en la cual el Kinect
pudiera detectarnos en la cámara de profundidad y una vez que lo hace se ajusta
la posición para que detecte el brazo, la cámara debe mostrarte los ángulos del
brazo derecho y debe dar seguimiento con el brazo, es decir los ángulos
cambiaban sus valores en cuando se mueva el brazo derecho tal y como lo
muestra el ejemplo de la imagen.

Figura 32, (Visualización de la cámara de profundidad siguiendo los ángulos del brazo derecho)

Y tal y como se declaró en el código los servomotores deben actuar conforme se

mueva el brazo, pues estos deben seguir el movimiento del brazo al mismo
tiempo, para probar esto conecte el circuito con el arduino a la computadora y
debe subirse el código de arduino a la tarjeta y como tal debe funcionar. El Kinect
que ya está encendido como lo muestra el ejemplo de la imagen de la figura 32.2
capta el movimiento de mi brazo representándolo en la computadora tal como se
muestra en la imagen de la figura 32.1 enviando esos datos a processing y a su
vez manda esos datos al arduino quien hace actuar los servomotores.

38
Figura 32.1, (Ejemplo de la visualización en la Figura 32.2, (Visualización del Kinect captando el moviente
Una vez comprobada toda la interfaz
computadora del seguimiento del movimiento y comunicación entre processing y arduino,
del brazo derecho)
se modifican
del brazo derecho) ambos códigos para agregar la mano izquierda y de ese modo
completar el robot imitador.

Para esto solo se duplican las variables y se agregaron las variables para la mano
izquierda representándo el codo y hombro izquierdo, este para que se visualizaran
los ángulos de la mano izquierda y de ese modo mandar esos valores a los
nuevos servomotores que representaran la mano izquierda, al igual se modifica el
código del arduino para que detecte los otros 2 servomotores.

En total son 4 servomotores los que se conecten directamente al arduino, en este

caso el diagrama del circuito solo se le agregan otros dos servomotores estos
conectados a los pies 6 y 5 del arduino tal y como muestra el diagrama de la figura
33.

39
 Figura 33, (Diagrama del circuito de ambos brazos)

Teniendo ya el diagrama del circuito éste se empieza a armar en físico, utilizando

como guía el diagrama, se hacen las conexiones predeterminadas en el diagrama
conectando los cuatro servomotores a los pines determinadas del arduino.

Por último se carga el código de arduino a la tarjeta para qué éste se pruebe ya en
conexión con processing y el Kinect, de ese modo se recibe las nuevas variables
agregadas para la mano izquierda.

Se arma el circuito, realizando las conexiones adecuadas de los servomotores al

arduino, una vez ya armado el circuito y cargado el código de la mano izquierda a
la tarjeta arduino tal y como lo muestra la imagen.

40
 Figura 34, (Imagen del circuito ya armado)

Se inicia el programa con el Kinect ya conectado y enlazado a processing como lo

muestra el ejemplo de la imagen, también ya con el código modificado para la
mano izquierda esto para comprobar si hubo alguna falla en los códigos, en si
deben moverse los 4 servomotores conforme al ángulo que se posiciones ambos
brazos.

Figura 34, (Visualización del programa en processing ya corrido

en la computadora)

Capítulo 3.9: Final del proyecto

Una vez probado los 4 servomotores se construyeron ambos brazos utilizando los
servomotores, para iniciar el proyecto de detección e implementación de un

41
sistema de detección de esqueleto para aplicaciones robóticas, creando el
robot animatrónico como se observa en la imagen.

Figura 35, (Visualización del robot animatronico)

Una vez armado ambos brazos, se conectan a la tarjeta arduino, para la conexión
del mismo circuito y enlazado a la computadora para comunicarse con el
programa de processing.

Estos como se mencionó antes simularan los movimientos de mis brazos, es decir
que los brazos de los servomotores seguirán el mismo patrón de movimiento de
los brazos humanos gracias a los ángulos que marcas en la programación de
processing como lo muestra la imagen, gracias al Kinect y al código que se realizó
en processing y arduino.

Como última Figura

parte 35.1,
se tomó evidenciavisual
(Representación del funcionamiento
del programa) del proyecto que es la
imagen y al probarse este no presentó ninguna falla, la comunicación entre los
servos y el programa de processing salió bastante bien sin error alguno al igual
que la comunicación atraviesa del Kinect, todo salió perfectamente, gracias a las

42
investigaciones y diversas pruebas que se hicieron junto con el skeleton tracking
fue posible realizar este proyecto.

Figura 36, (Evidencia del proyecto)

Capítulo 4: Conclusión.

43
Este proyecto fue bastante interesante y muy educativo, en mi opinión personal
jamás avía realizado un proyecto similar, incluso no creía que pudiera realizar algo
así, no fue un proyecto sencillo pero tampoco fue una tarea casi imposible, a pesar
de tuve percances y dificultades pude resolverlo por mí mismo cada problema que
se me presentó al realizar este proyecto, estoy bastante satisfecho con todo lo que
aprendí en este proyecto, aprendí mucho acerca del Kinect, la verdad no pensé
que tuviera tantas funciones aparte del uso cotidiano que le dan en los
videojuegos, la verdad fue muy educativo durante toda la realización del proyecto,
pues no sólo apliqué conocimientos que adquirí el resto de mi carrera técnica sino
que también aprendí cosas nuevas entre ellas fue el uso del software de
processing ya que en todo mi carrera no lo vimos ni lo utilizamos, y debido a que
este software es un software de programación basado en lenguaje java, tuve que
aprender sus funciones y características por mí mismo y la verdad me dio mucho
gusto aprender sobre ello y espero todo ese conocimiento nuevo que adquirí
pueda servirme a futuro.

Quiero agradecer al profesor Jorge Cerezo Sánchez quien fue el que me propuso
este proyecto para que yo lo realizará, gracias a este proyecto pude aprender
bastante, en mi opinión no creía capaz de hacerlo porque intente con diversos
softwares y diferentes videos tutoriales para poder realizarlo pero la mayoría no
fueron de ayuda y aunque si avía videos donde mostraban el robot animatrónico
utilizando el Kinect y el skeleton tracking no encontré ninguno donde lo explicaran
su desarrollo o una manera de cómo realizarlo, así que tuve que realizar este
proyecto por mi propia cuanta sin necesitar de ningún video tutorial de cómo
hacerlo o como realizarlo, me siento orgulloso de poder haberlo logrado y que
resultará tal y como esperaba, espero volver a realizar un proyecto similar, ya que
pude aprender demasiado de él. También espero y este reporte le sea de ayuda
para aquellos que buscan realizar este proyecto de la detección de esqueleto para
aplicaciones robóticas, ya que viene todo lo que se necesitan y que a diferencia
mía que no pude encontrar ningún video o libro que me explicará a detalle el
desarrollo de dicho proyecto, espero y este reporte les brinde la ayuda que
buscan.

Capítulo 5: Anexos.

44
Código fuente del software de processing más las capturas del código:
import SimpleOpenNI.*;
import [Link].*;

SimpleOpenNI kinect;
Serial Arduino;

float RightshoulderAngle = 0;
float RightelbowAngle = 0;
float LeftshoulderAngle = 0;
float LeftelbowAngle = 0;

void setup() {
size(640, 480);
kinect = new SimpleOpenNI(this);
Arduino = new Serial(this, "COM3", 9600);
[Link]();
[Link]();
fill(255, 0, 0);
[Link](false);
}

void draw() {
[Link]();
image([Link](), 0, 0);
IntVector userList = new IntVector();
[Link](userList);
if ([Link]() > 0) {
int userId = [Link](0);
if ([Link](userId)) {
drawSkeleton(userId);
ArmsAngle(userId);
}
}
}

void drawSkeleton(int userId) {

stroke(0);
strokeWeight(5);
[Link](userId,SimpleOpenNI.SKEL_RIGHT_SHOULDER,SimpleOpenNI.SKEL_RIGH
T_ELBOW);
[Link](userId,SimpleOpenNI.SKEL_RIGHT_ELBOW,impleOpenNI.SKEL_RIGHT_H
AND);

45
[Link](userId,SimpleOpenNI.SKEL_LEFT_SHOULDER,SimpleOpenNI.SKEL_LEFT_E
LBOW);
[Link](userId,SimpleOpenNI.SKEL_LEFT_ELBOW,
SimpleOpenNI.SKEL_LEFT_HAND);
noStroke();
fill(255, 0, 0);
drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_SHOULDER);
rawJoint(userId, SimpleOpenNI.SKEL_RIGHT_ELBOW);
drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_HAND);
drawJoint(userId, SimpleOpenNI.SKEL_LEFT_SHOULDER);
drawJoint(userId, SimpleOpenNI.SKEL_LEFT_ELBOW);
drawJoint(userId, SimpleOpenNI.SKEL_LEFT_HAND);
}

void drawJoint(int userId, int jointID) {

PVector joint = new PVector();
float confidence = [Link](userId, jointID,
joint);
if (confidence < 0.5) {
return;
}
PVector convertedJoint = new PVector();
[Link](joint, convertedJoint);
ellipse(convertedJoint.x, convertedJoint.y, 5, 5);
}
float angleOf(PVector one, PVector two, PVector axis) {
PVector limb = [Link](two, one);
return degrees([Link](limb, axis));
}

void onNewUser(SimpleOpenNI kinect, int userID) {

println("Start skeleton tracking");
[Link](userID);
}

void onLostUser(SimpleOpenNI curContext, int userId) {

println("on LostUser = userId: " + userId);
}

public void ArmsAngle(int userId) {

PVector rightHand = new PVector();
[Link](userId,SimpleOpenNI.SKEL_RIGHT_HAND,rightHand);
PVector rightElbow = new PVector();
[Link](userId,SimpleOpenNI.SKEL_RIGHT_ELBOW, rightElbow);

46
PVector rightShoulder = new PVector();
[Link](userId,SimpleOpenNI.SKEL_RIGHT_SHOULDER,rightShould
er);
PVector rightHip = new PVector();
[Link](userId, SimpleOpenNI.SKEL_RIGHT_HIP, rightHip);
PVector rightHand2D = new PVector(rightHand.x, rightHand.y);
PVector rightElbow2D = new PVector(rightElbow.x, rightElbow.y);
PVector rightShoulder2D = new PVector(rightShoulder.x, rightShoulder.y);
PVector rightHip2D = new PVector(rightHip.x, rightHip.y);
PVector torsoOrientation = [Link](rightShoulder2D, rightHip2D);
PVector upperArmOrientation = [Link](rightElbow2D, rightShoulder2D);
RightshoulderAngle = angleOf(rightElbow2D, rightShoulder2D, torsoOrientation);
RightelbowAngle = angleOf(rightHand2D, rightElbow2D, upperArmOrientation);
PVector leftHand = new PVector();
[Link](userId, SimpleOpenNI.SKEL_LEFT_HAND, leftHand);
PVector leftElbow = new PVector();
[Link](userId, SimpleOpenNI.SKEL_LEFT_ELBOW, leftElbow);
PVector leftShoulder = new PVector();
[Link](userId, SimpleOpenNI.SKEL_LEFT_SHOULDER,
leftShoulder);
PVector leftHip = new PVector();
[Link](userId, SimpleOpenNI.SKEL_LEFT_HIP, leftHip);
PVector leftHand2D = new PVector(leftHand.x, leftHand.y);
PVector lefttElbow2D = new PVector(leftElbow.x, leftElbow.y);
PVector leftShoulder2D = new PVector(leftShoulder.x, leftShoulder.y);
LeftshoulderAngle = angleOf(lefttElbow2D, leftShoulder2D, torsoOrientation);
LeftelbowAngle = angleOf(leftHand2D, lefttElbow2D, upperArmOrientation);
fill(255, 0, 0);
scale(1);

textSize(40);
text("Right shoulder: " + int(RightshoulderAngle) + "\n" + " Right elbow: " +
int(RightelbowAngle), 10, 30);
[Link]("RightShoulder/" + RightshoulderAngle + "\n");
[Link]("RightElbow/" + RightelbowAngle + "\n");
text("Left shoulder: " + int(LeftshoulderAngle) + "\n" + " Left elbow: " +
int(LeftelbowAngle), 40, 60);
[Link]("LeftShoulder/" + LeftshoulderAngle + "\n");
[Link]("LeftElbow/" + LeftelbowAngle + "\n");
}

47
48
49
Código fuente del software de Arduino más las capturas del código:

#include <Servo.h>

Servo RightShoulder;
Servo RightElbow;
Servo LeftShoulder;
Servo LeftElbow;

void setup() {
[Link](9600);
[Link](8);
[Link](7);
[Link](9);

50
 [Link](10);
[Link](90);
[Link](0);
[Link](90);
[Link](0);
}

void loop() {
if ([Link]()){
String Data = [Link]('\n');
int Separator = [Link]('/');
int Length = [Link]();
String Id = [Link](0, Separator);
int Value = [Link](Separator + 1, Length).toInt();
Value = map(Value, 0, 180, 180, 0);
if ([Link]("RightShoulder")) {
[Link](Value);
} else if ([Link]("RightElbow")) {
[Link](Value);
}
if ([Link]("LeftShoulder")) {
[Link](Value);
} else if ([Link]("LeftElbow")) {
[Link](Value);
}
}
}

51
52
Capítulo 6: Referencias Bilibliograficas.

- Universidad Carlos III de Madrid. (2012). Control de Software Educativo Mediante

Kinect de Microsoft. En E. Fernández Sánchez (Ed.), Control de Software

Educativo Mediante Kinect de Microsoft (2.a ed., Vol. 1, pp. 1–115).

[Link]

- Processing, un lenguaje al alcance de todos. (2013). En A programming Handbook

for Visual Designers and Artist (2.a ed., Vol. 1, pp. 1–231). Ignacio Buioli Jaime

Pérez Marín. [Link]

%20alcance_de_todos.pdf

- Bauer, H. (2012). Making Things See (1.a ed., Vol. 1). Andrew Odewahn, Brian

Jepson. [Link]

- El poder de Kinect para Windows. (2012, 20 julio). Windows Blogs. Recuperado 16

de agosto de 2022, de [Link]

id=40278

- WordPress, W. P. V. (s. f.). Programación visual con Processing. Medialab Mx.

Recuperado 16 de agosto de 2022, de [Link]

%E2%80%9CProcessing%20es%20un%20lenguaje%20de,e%20interactivos%20de

%20dise%C3%B1o%20digital.

53