Documento de Requisitos

Documento de Requisitos
de
Fightnect
Fecha
Versión
17 de octubre del 2012
1.0
Integrantes
Christian López.
del grupo
Diego González.
Diego Riquelme.
Felipe Vera.
Documento de Requisitos de Fightnect Página i
Prefacio
El sistema Fightnect consiste en poder conectar la Kinect con un emulador de Super
Nintendo Entertainment System y poder jugar, algún juego de pelea. El objetivo
consiste en que el jugador, al hacer algún golpe, su personaje del juego haga el mismo.
Alcance del El Documento de Requisitos es la
documento Describe los siguientes aspectos
funcionales, requisitos de pruebas,
arquitectura del sistema, requisitos
riesgos del proyecto.
base de todo el desarrollo futuro de Fightnect.
del sistema: propósito, contexto, requisitos
requisitos de calidad, requisitos de ambiente,
del desarrollo, requisitos de post-desarrollo, y
Documentos Documento de Inicio de Proyecto, proyecto Fightnect, versión 0.1, 14 de septiembre
relacionados del 2012.
Autor Christian López, Diego González, Diego Riquelme, Felipe Vera.
Lectores Este documento está dirigido principalmente a los desarrolladores del proyecto, pero es
de interés de todos los interesados en el mismo.
Historia del Documento
Versión
Fecha
Explicación del cambio
0.1
14/09/2012
Documento de inicio
Grupo Fightnect
0.1
17/10/2012
Documento de requisitos
Grupo Fightnect
Documento de Requisitos de Fightnect Página ii
Autor
Índice de Materias
Prefacio ....................................................................................................................................................... ii
Historia del Documento ............................................................................................................................. ii
Lista de Figuras ......................................................................................................................................... iii
Lista de Tablas .......................................................................................................................................... iv
1 Introducción ............................................................................................................................................. 1
1.1 Propósito ................................................................................................................................................. 1
1.2 Alcance ................................................................................................................................................... 1
1.3 Contexto .................................................................................................................................................. 1
1.4 Referencias.............................................................................................................................................. 1
2 Requisitos del Sistema ............................................................................................................................. 2
2.1 Requisitos Funcionales ........................................................................................................................... 2
2.2 Requisitos de Interfaces .......................................................................................................................... 2
3 Requisitos de Ambiente ........................................................................................................................... 4
3.1 Requisitos del Ambiente de Desarrollo .................................................................................................. 4
3.1.1 Hardware de Desarrollo ....................................................................................................................... 4
3.1.2 Software de Desarrollo ........................................................................................................................ 4
4 Arquitectura del Sistema ......................................................................................................................... 5
4.1 Diagrama de Flujo de Datos.................................................................................................................... 5
4.2 Descripción de Módulos ......................................................................................................................... 5
4.2.1 Módulo 1: Kinect ................................................................................................................................. 5
4.2.2 Módulo 2: Programa intérprete ............................................................................................................ 5
4.2.3 Módulo 3: Generación de macros ........................................................................................................ 6
4.2.4 Módulo 4: Simulador de controlador SNES ........................................................................................ 6
4.3 Componentes.......................................................................................................................................... 6
5 Gestión de Riesgos.................................................................................................................................... 7
5.1 Supuestos ................................................................................................................................................ 7
5.2 Dependencias .......................................................................................................................................... 7
5.3 Restricciones ........................................................................................................................................... 7
5.4 Riesgos .................................................................................................................................................... 7
5.4.1 Utilización librerías OpenCV y OpenNI .............................................................................................. 8
5.4.2 Implementación de microcontrolador MSP430 .................................................................................. 8
5.4.3 Factor tiempo ....................................................................................................................................... 8
Lista de Figuras
Documento de Requisitos de Fightnect Página iii
Figura 1: Diagrama de flujo de datos del sistema .................................................................................... 5
Lista de Tablas
Tabla 1: Eventos externos .......................................................................................................................... 2
Tabla 2: Respuestas del sistema................................................................................................................. 3
Tabla 3: Matriz de requisitos funcionales y componentes ..................................................................... 6
Documento de Requisitos de Fightnect Página 4
1 Introducción
El proyecto consiste en crear un programa que sea capaz de comunicar un dispositivo Kinect
con un juego de pelea de Super Nintendro, a través de un simulador. En base a ciertos
códigos ya existentes de detección, tales como de cuerpo (skeleton) o de mano, se buscará
controlar al personaje del juego a través de ciertos movimientos, los cuales representarán
golpes, patadas, poderes, etc.
1.1 Propósito
El programa es un detector de cuerpo a través de un dispositivo Kinect. Al ser detecteado el
usuario, éste podrá realizar movimientos ya establecidos para jugar un juego de pelea de
Super Nintendo, tales como golpes, patadas, saltos, combinaciones especiales y poderes.
1.2 Alcance
El proyecto en sí es un detector de cuerpo, el cuál permitirá al usuario jugar (a través de un
simulador de Super Nintendo) algún juego de pelea. De esta forma, se innova en jugabilidad
y se trae un sentimiento de nostalgia por los juegos retro o antiguos.
Sin embargo, el proyecto no es en sí un simulador de Super Nintendo ni tampoco un juego de
pelea.
1.3 Contexto
El programa será desarrollado en C++ y OpenCV. Si bien existen ya varios códigos de
detección de cuerpo, mano u otras extremidades, no están implementadas para un uso de
juego de pelea.
1.4 Referencias
Libros y Manuales:

Learning OpenCV: Computer Vision with the OpenCV Library (Gary Bradski, Adrian
Kaehler).

Digital Image Processing, 3rd edition, 2007Rafael C. Gonz_alez, Richard E. Woods.
Páginas web:
 http://graphics.stanford.edu/~mdfisher/index.html
 http://100xna.wordpress.com/2011/01/12/avanzado-programar-aplicaciones-con-kinect/
 http://www.switchonthecode.com/tutorials/kinect-tutorial-hacking-101
 http://www.morethantechnical.com/2010/11/22/kinect-and-opencv-2-1/
Documento de Requisitos de Fightnect Página 1
2 Requisitos del Sistema
Esta sección describe los requisitos funcionales del sistema, sus interfaces externas, las
condiciones de excepción y las clases de pruebas que se harán para verificar que los
requisitos se cumplen.
2.1 Requisitos Funcionales
Los requisitos funcionales definen el comportamiento del sistema. Es decir, describen lo que
debe hacer el sistema.
RF1
El sistema ha de funcionar cada vez que se desée interactuar con un juego de pelea a
través del simulador.
RF2
Al detectar la Kinect el cuerpo, el sistema ha de ser capaz de recordarlo y poder
ejecutar las funciones definidas para ciertos movimientos.
RF3
Los retardos entre algún movimiento del jugador y el procesamiento de éste para que
sea realizado en el simulador, ha de ser mínimo, por lo tanto hay que priorizar
velocidad de procesamiento al momento de codificar los algoritmos necesarios.
2.2 Requisitos de Interfaces
Evento externo 1: el usuario al posicionarse frente a la Kinect, ésta ha de poder calibrarse
según los requerimientos que el usuario necesite.
Evento externo 2: al estar calibrada la Kinect, el sistema ha de detectar los movimientos del
usuario y realizar las acciones deseadas. Por ejemplo, mover el personaje, golpear, patear,
saltar, saltar y golpear/patear al mismo tiempo, realizar técnicas especiales y poderes.
La Tabla 1 muestra la lista de eventos externos a los que el sistema responde. La primera
columna es el nombre del evento; la segunda es la descripción del mismo. El “iniciador” es la
componente externa al sistema que inicia el evento. Los parámetros son los datos asociados al
evento. La respuesta es el nombre de una respuesta, cuya descripción está en la Tabla 2.
Tabla 1: Eventos externos
Evento
Descripción
Iniciador
Parámetros
Respuesta
Evento
externo 1.
Sistema capaz de detectar
cuerpo.
Posicionar
cuerpo
frente a
Kinect.
Encendido del
programa.
Comienza
calibració
n.
Evento
externo 2.
Diversos movimientos
del usuario.
Mover
cuerpo y
extremidad
es
El parámetro
dependerá del tipo de
movimiento, ya que
habrán varios con
distintos significados.
Dependien
do del
parámetro,
el
personaje
realizará
alguna
Documento de Requisitos de Fightnect Página 2
Evento
Descripción
Iniciador
Parámetros
La Tabla 2 muestra las respuestas del sistema frente a eventos externos.
Tabla 2: Respuestas del sistema
Respuesta
Descripción
Parámetros
Evento 1
Comienza calibración del
cuerpo para realizar
acciones.
Cuerpo frente a cámara
de Kinect.
Evento 2
Simulador realizará
alguna acción (mover
personaje, golpear,
patear, etc.)
Documento de Requisitos de Fightnect Página 3
Según el movimiento
del cuerpo y de
extremidades, habrá
una instrucción
diferente.
Respuesta
acción.
3 Requisitos de Ambiente
Esta sección describe el hardware y software relevante para el sistema Fightnect.
3.1 Requisitos del Ambiente de Desarrollo
3.1.1 Hardware de Desarrollo
Para la codificación de este sistema se procederá a programar en un PC. También se
programará una plataforma de desarrollo “Launchpad” para MSP430 (chip modelo
M430G2553) y simular un controlador de SNES.
3.1.2 Software de Desarrollo
Se priorizará el desarrollo para el sistema operativo Linux, puesto que la documentación es
mejor y posee un sinnúmero de ventajas a la hora de codificar programas.
Se empleará también el entorno de desarrollo QTCreator con lenguaje C++ para crear las
interfaces gráficas que Fightnect necesite junto con la librería OpenCV y OpenNI para poder
implementar los algoritmos de detección de movimiento y ejecución de acciones.
También se debe implementar un sistema de macros de teclado/gamepad, y comunicación
serial entre el PC y la MSP430, lo que hace que el código sea menos portable entre sistemas
operativos.
Para programar la MSP430 se empleará el entorno de desarrollo IAR Embedded Workbench
con un lenguaje C modificado.
Documento de Requisitos de Fightnect Página 4
4 Arquitectura del Sistema
4.1 Diagrama de Flujo de Datos
La siguiente figura muestra los módulos del sistema y los principales flujos de información.
Muestra el flujo de información y los módulos físicos y software asociado que permite dicho
flujo.
Figura 1:
Diagrama de
flujo de datos
del sistema
4.2 Descri
pc
ió
n de Módulos
Las siguientes son las componentes descritas en la Figura 1. Por cada componente se entrega
un breve párrafo descriptivo de su función y sus interacciones con otras componentes y con el
medio.
4.2.1 Módulo 1: Kinect
Este módulo se encargará de generar un mapa tetra-dimensional: tres canales de colores y un
canal de distancia, que deberá ser procesado por el siguiente módulo.
4.2.2 Módulo 2: Programa intérprete
Este módulo es el corazón del sistema. Será un programa creado para Linux en una
arquitectura x86/x64. Este a su vez poseerá distintas rutinas.
 Captar imágenes del módulo Kinect y cargarlos en la memoria. Si es necesario, guardar
varias de éstas en la RAM para detectar diferencias en ellas, y de ese modo, detectar
movimiento.
 Una base de datos que contenga patrones de movimiento para comparar con las
imágenes tomadas por Kinect.
Documento de Requisitos de Fightnect Página 5
 Rutinas para generar macros de teclado o gamepad, para controlar un emulador de
SNES.
 Envío de datos seriales a través de USB a la MSP430 mediante el cargador Launchpad
de Texas Instruments.
4.2.3 Módulo 3: Generación de macros
Este módulo corresponde a la salida del programa hacia un emulador de SNES.
4.2.4 Módulo 4: Simulador de controlador SNES
Mediante comunicación serial con USB, mediante la placa de desarrollo Launchpad y un
microcontrolador MSP430, simular el comportamiento de un controlador de SNES.
4.3 Componentes
La siguiente matriz muestra qué módulos implementan qué requisitos funcionales. Una línea
vacía en la matriz indica un requisito funcional no implementado. En ese caso es probable
que falte un módulo. Una columna vacía indica un módulo no es útil para estos requisitos
funcionales. En ese caso es posible que falte un requisito funcional.
Tabla 3: Matriz de requisitos funcionales y componentes
C1 C2 C3 C4
RF1
X
X
RF2
X
X
X
RF3
X
X
X
Documento de Requisitos de Fightnect Página 6
5 Gestión de Riesgos
5.1 Supuestos
1- Las librerías que se utilizarán como OpenCV y OpenNI (para kinect) poseen algoritmos
implementados que podremos utilizar y modificar sin mayores inconvenientes.
2- Dentro de estos algoritmos, se encuentran para la detección de una mano, para la detección
de un esqueleto, entre otros.
3- La implementación de un microcontrolador MSP430 sólo se verá realizada cuando la parte
emulada sea concretada, por lo tanto, se considerará un bonus dentro del proyecto
.
5.2 Dependencias
La principal dependencia en este caso, es que no se produzca un imprevisto de tiempo como
por ejemplo, que se disminuya el tiempo de duración del proyecto ( adelante la entrega), con
consecuencias negativas para el correcto termino de este.
5.3 Restricciones
El proyecto está restringido básicamente en términos de software a QT y librerías de
desarrollo libres como OpenCV y OpenNI. En cuanto a hardware, la utilización y
disponibilidad de un dispositivo Kinect se hace imprescindible. A su vez, si se consigue
implementar correctamente el emulador Snes, tambíen sería necesario el microcontrolador
MSP430.
Por último, los cables de conexión entre dispositivos son necesarios. Kinect-PC, Cables de
poder entre otros.
5.4 Riesgos
Existen riesgos en cuanto al uso de software, ya sea OpenCv u OpenNI y en cuanto a
hardware como es implementar el microcontrolador. Los principales riesgos son de
implementación y correcto uso de las librerías antes mencionadas. Es necesario mencionar
que la implementación del microcontrolador no es un riesgo crítico, ya que será parte
opcional en el desarrollo del proyecto, siendo críticos los factores de programación utilizando
OpenCV y OpenNI.
A continuación se detallan algunos riesgos críticos para el desarrollo correcto del proyecto:
Documento de Requisitos de Fightnect Página 7
5.4.1 Utilización librerías OpenCV y OpenNI
Este riesgo es un riesgo crítico, dado que se necesita lograr captar movimientos con el
dispositivo Kinect. La forma de hacerlo es utilizar y modificar de acuerdo a lo que
necesitemos el código ya creado y que se encuentra a disposición de forma libre. La forma de
evitar es interiorizase oportunamente de las funciones y entender el funcionamiento de estas
junto con el dispositivo Kinect.
Si se presenta este problema, aún habiendo estudiando oporotunamente, se necesitarán otras
funciones para captar movimientos, portando otra librería o simplificando aspectos del
proyecto como en vez de captar un brazo, captar una mano. Es necesario decir, que esto se
puede evitar estudiando y analizando oportunamente el código a disposición y modificarlo
para lo que se necesita.
5.4.2 Implementación de microcontrolador MSP430
Este es un riesgo no crítico, dado que es opcional, pero de poder implementarse, es necseario
codificar en lenguaje C para lograr la conexión con la consola de Super Nintendo. Para evitar
que se transforme en un problema, el equipo cuenta con un experto en el área de estructura de
computadores que podrá implementar sin mayores problemas lo necesario.
Si no se contase con esta persona con conocimientos avanzados, este punto del proyecto se
puede obviar, dado que es opcional.
5.4.3 Factor tiempo
El factor tiempo es un riesgo inherente a cualquier proyecto. En este caso, se cuenta con un
período de tiempo acotado para el desarrollo y si este tiempo se viera reducido drásticamente,
generaría muchos problemas. La forma de evitar aquello es agendar hitos y metas semanales
de acuerdo al tiempo general para así avanzar gradualmente en el problema.
Si se diera el caso de reducción considerable de tiempo para el desarrollo, se buscará
generalizar los módulos y lograr los hitos con menos detalles; en su defecto quitar
características.
Documento de Requisitos de Fightnect Página 8