Universidad Cooperativa de Colombia Facultad Ingeniería ...
186
1 Universidad Cooperativa de Colombia Facultad Ingeniería Ingeniería de sistemas Aplicación Android para silla de ruedas, que permita controlarla por comandos de voz, pantalla táctil y programación de ruta. Omar De Jesús Carreño Aguirre Luis Edgardo Arias Mercado Sergio Andrés Guerrero Palencia Departamento de Sistemas Santa Marta Colombia 2016
Transcript of Universidad Cooperativa de Colombia Facultad Ingeniería ...
1
Universidad Cooperativa de Colombia
Facultad Ingeniería
Ingeniería de sistemas
Aplicación Android para silla de ruedas, que permita controlarla por comandos de voz,
pantalla táctil y programación de ruta.
Omar De Jesús Carreño Aguirre
Luis Edgardo Arias Mercado
Sergio Andrés Guerrero Palencia
Departamento de Sistemas
Santa Marta Colombia
2016
2
Dedicatoria
Al creador de todas las cosas, el que me ha brindado la fortaleza para continuar en cada una de
las etapas de mi vida; por ello, con toda la humildad que puede emanar mi corazón, dedico
primeramente este logro a él.
A mi madre que ha dado todo de sí para formarme con buenos hábitos, valores y sentimientos,
brindándome con un abnegado esfuerzo continuo lo necesario para hoy estar en este punto de mi
vida.
A mi hermana que es mi modelo a seguir, quien ha estado junto a mí en todo momento,
brindándome su apoyo, corrigiéndome cuando estuve errado y siempre impulsándome a ser mejor
que ella en el campo profesional, muchas veces tomando el papel de padre.
A mi Padre quien a pesar de no estar en todo momento junto a mí, siempre supo cómo
reconfortarme en los malos momentos y ser un guía en este camino hacia el éxito.
A mi familia en general por siempre creer en mí y apoyarme de forma moral, espiritual y
Económicamente en el desarrollo de mi carrera.
Omar de Jesús Carreño Aguirre
3
Dedicatoria
Agradezco primeramente a Dios por permitir llegar hasta este punto, haberme dado salud y lo
necesario para salir adelante día a día para lograr mis objetivos.
A mis padres por haberme apoyado en todo momento, por sus consejos, sus valores, por la
motivación constante que me ha permitido ser una persona de bien, pero más que nada por su
amor.
Luis Arias Mercado
4
Dedicatoria
A Dios por haberme amparado en todo momento.
A mi padre, que esperaba con ganas este triunfo.
A mi madre, que multiplico sus esfuerzos y me dio fuerzas para terminar mi grado.
A mi hermano, que vea con base mi esfuerzo, para que cumpla sus objetivos.
Sergio Andrés Guerrero Palencia
5
Agradecimientos
A lo largo del desarrollo de este proyecto tuvimos muchos tropiezos que de una forma u otra
retrasaron el proceso del mismo, agradecemos enormemente el apoyo de muchas personas
quienes nos impulsaron a seguir adelante y a no desfallecer en el camino a convertirnos en
ingenieros, y también dar gracias a todas esas personas que de una forma u otra hicieron parte de
este proyecto, en especial al ingeniero José Noguera quien nos asesoró resolviendo muchas
dudas, agradecemos al nuestros profesores Leonardo Arias Alemán quien nos guio en el proceso
de aprendizaje en el diseño y desarrollo de software, gracias a ello pudimos llevar a cabo una
gran parte de este proyecto, con cada una de las materias que nos impartió nos enamoró de la
carrera con su amplio conocimiento, gracias al ingeniero José Egurrola que siempre nos infundo
un pensamiento más objetivo para abordar los problemas desde diferentes puntos de vista,
especial agradecimiento al ingeniero Danilo Juvinao por ser un gran tutor al enseñar con
constancia y puntualidad su materia, gracias al docente Luis Carlos Hernández por el apoyo
incondicional y por siempre creer que nosotros podemos lograr grandes cosas. Gracias a la
Universidad Cooperativa de Colombia por el apoyo y financiamiento del proyecto.
6
Contenido
Dedicatoria ....................................................................................................................................... 2
Dedicatoria ....................................................................................................................................... 3
Dedicatoria ....................................................................................................................................... 4
Agradecimientos ............................................................................................................................... 5
Lista de ilustraciones ...................................................................................................................... 13
Lista de Tablas ............................................................................................................................... 15
1 Resumen ...................................................................................................................................... 16
2 Abstract ....................................................................................................................................... 17
3 Introducción ................................................................................................................................ 18
4 Planteamiento del problema ........................................................................................................ 19
Descripción del problema ................................................................................................ 19 4.1
Formulación del problema ............................................................................................... 19 4.2
5 Objetivos ..................................................................................................................................... 20
Objetivo General .............................................................................................................. 20 5.1
Objetivos Específicos ...................................................................................................... 20 5.2
6 Justificación ................................................................................................................................. 21
7
Justificación Teórica ........................................................................................................ 21 6.1
Justificación metodológica .............................................................................................. 21 6.2
Justificación practica ....................................................................................................... 22 6.3
7 Alcance y Limitaciones ............................................................................................................... 23
Alcance ............................................................................................................................ 23 7.1
Limitaciones .................................................................................................................... 23 7.2
8 Marco de referencias ................................................................................................................... 24
Antecedentes .................................................................................................................... 24 8.1
Diseño de una silla de ruedas automático encontrando la trayectoria con el Sistema 8.1.1
de Orientación Inteligente. ...................................................................................................... 24
Evaluando la usabilidad de un teléfono para monitorear silla de ruedas ................. 24 8.1.2
Control de una Silla de Ruedas por Medio de un Dispositivo Móvil con Sistema 8.1.3
Operativo Android. ................................................................................................................. 25
Automatización de una silla de ruedas controlada por comandos de voz. ............... 25 8.1.4
Red neuronal basada en el control del desacoplamiento diagonal de los sistemas de 8.1.5
silla de ruedas eléctricas. ......................................................................................................... 26
Un enfoque de control visual autónomo para el paso de una silla de ruedas a través 8.1.6
de una puerta en un corredor. .................................................................................................. 26
Optimización para evadir obstáculos por generación de una trayectoria 8.1.7
reconfigurable de una silla de ruedas que sube escaleras. ...................................................... 27
8
Uso de una red inalámbrica de sensores visuales para navegar armónicamente 8.1.8
varias sillas de ruedas de bajo costo en un ambiente interior. ................................................ 27
Una Ondícula y sistema de voz basado en red neuronal para el control de una silla 8.1.9
de ruedas inteligente................................................................................................................ 28
Control neural de los movimientos de una silla de ruedas ....................................... 28 8.1.10
Desarrollo de un sistema inteligente para una silla de ruedas para un usuario con 8.1.11
discapacidad motriz severa. .................................................................................................... 29
La silla Robótica SENA. Un Enfoque Basado en la Interacción Hombre-Máquina 29 8.1.12
9 Marco Teórico ............................................................................................................................. 30
Inteligencia artificial ........................................................................................................ 30 9.1
Características de la Inteligencia Artificial...................................................................... 31 9.2
Automatización ................................................................................................................ 32 9.3
10 Marco Conceptual ..................................................................................................................... 34
Pwm ................................................................................................................................. 34 10.1
Módulo Arduino .............................................................................................................. 34 10.2
Android ............................................................................................................................ 35 10.3
Android Studio ................................................................................................................ 36 10.4
Componentes de Android Studio ............................................................................. 37 10.4.1
Puente H .......................................................................................................................... 41 10.5
Estructura de un Puente H ........................................................................................ 42 10.5.1
9
WIFI ................................................................................................................................. 43 10.6
Módulo CC3000 .............................................................................................................. 43 10.7
Odometría ........................................................................................................................ 44 10.8
11 Marco contextual ....................................................................................................................... 45
12 Metodología .............................................................................................................................. 46
Área del conocimiento, área temática y tema .................................................................. 46 12.1
Título y área de investigación .......................................................................................... 46 12.2
Tipo de investigación. ...................................................................................................... 46 12.3
Método de investigación .................................................................................................. 48 12.4
Fases de la investigación. ................................................................................................ 49 12.5
Fase 1: Desarrollo del estado del arte ....................................................................... 49 12.5.1
Fase 2: Construcción e implementación de código .................................................. 49 12.5.2
Fase 3: Generación documento y manual................................................................. 49 12.5.3
Técnicas e instrumentos metodológicos .......................................................................... 50 12.6
Técnicas .................................................................................................................... 50 12.6.1
12.6.1.1 Fuente primaria ..................................................................................................... 50
Planificación .................................................................................................................... 51 12.7
Recursos Humanos .......................................................................................................... 51 12.8
Cronograma de actividades.............................................................................................. 52 12.9
13 Delimitaciones del proyecto ...................................................................................................... 56
10
Delimitación del problema .............................................................................................. 56 13.1
Delimitaciones del espacio .............................................................................................. 56 13.2
Delimitaciones del tiempo. .............................................................................................. 57 13.3
14 Descripción del sistema ............................................................................................................. 58
Diagramas del sistema ..................................................................................................... 58 14.1
Diagrama de envío de datos ..................................................................................... 58 14.1.1
Diagrama de recepción de datos ............................................................................... 63 14.1.2
Esquema representativo del sistema de conexión .................................................... 64 14.1.3
Protocolo de conexión con módulo cc3000 ............................................................. 65 14.1.4
Protocolo conexión con silla de ruedas .................................................................... 66 14.1.5
Explicación de pines de las tablas 1 y 2 ................................................................... 66 14.1.6
Diagrama de clases del aplicativo Android .............................................................. 68 14.1.7
Explicación de variables ........................................................................................... 69 14.1.8
Diseño de aplicativo ........................................................................................................ 73 14.2
Etapa de procesamiento ................................................................................................... 80 14.3
15 Pruebas ...................................................................................................................................... 82
16 Nuevos aportes y controversias conceptuales ........................................................................... 99
17 Descripción de las dificultades y las estrategias para confrontarlas creativamente ................ 100
Dificultades .................................................................................................................... 100 17.1
Soluciones ...................................................................................................................... 100 17.2
11
18 Conclusiones y recomendaciones ............................................................................................ 102
Conclusiones .................................................................................................................. 102 18.1
Recomendaciones .......................................................................................................... 103 18.2
19 Anexos ..................................................................................................................................... 104
Código Arduino para el control de la silla de ruedas..................................................... 104 19.1
Código Arduino neurona ............................................................................................... 113 19.2
Código Android ............................................................................................................. 121 19.3
MainActivity.java (ENVIO POR PANTALLA TACTIL) .................................... 121 19.3.1
Main2Activity.java (ENVIO DE RUTA) .............................................................. 125 19.3.2
Voz.java (ENVIO POR VOZ) ............................................................................... 130 19.3.3
Diagrama de flujo Código Arduino ............................................................................... 135 19.4
Proyecto App Silla de Ruedas ....................................................................................... 138 19.5
Organización .......................................................................................................... 138 19.5.1
Participantes ................................................................................................................... 139 19.6
Reuniones ...................................................................................................................... 141 19.7
Objetivos ........................................................................................................................ 145 19.8
Requisitos ...................................................................................................................... 147 19.9
Funcionales ............................................................................................................. 147 19.9.1
No funcionales ........................................................................................................ 149 19.9.2
20 Actores .................................................................................................................................... 150
12
21 Casos de uso ............................................................................................................................ 151
Envío por voz ................................................................................................................. 153 21.1
Pantalla Táctil ................................................................................................................ 155 21.2
Ruta Definida ................................................................................................................. 158 21.3
22 Pruebas .............................................................................................................................. 168
Módulo de voz ............................................................................................................... 168 22.1
Pantalla Táctil ................................................................................................................ 173 22.2
Ruta Definida ................................................................................................................. 178 22.3
23 Diagrama de secuencia ............................................................................................................ 181
Pantalla táctil ................................................................................................................. 181 23.1
Modulo de voz ............................................................................................................... 182 23.2
Ruta Definida ................................................................................................................. 183 23.3
24 Bibliografía .............................................................................................................................. 184
13
Lista de ilustraciones
Figura 1: Logo oficial de Android. Fuente: https://es.wikipedia.org/wiki/android........................ 36
Figura 2: Mesa de trabajo Android Studio. Fuente: Propia ............................................................ 37
Figura 3: Ejemplo de una activity. Fuente: http://www.itcsolutions.eu/2011/08/31/android-tutorial
how-to-create-and-display-a-new-form-window-or-activity/ ........................................................ 38
Figura 4: Widgets en pantalla Android. Fuente:
http://www.pcworld.com.mx/Articulos/24531.htm ....................................................................... 39
Figura 5: Ejemplo de código java que invoca un servicio. Fuente:
https://developer.android.com/guide/components/services.html ................................................... 40
Figura 6: Estructura de un puente H, fuente :(Mancilla, Crespo, & Navarro, 2012, pág. 7) ......... 41
Figura 7: Estados básicos del puente h, fuente: (Mancilla, Crespo, & Navarro, 2012) ................. 42
Figura 8: Método de investigación Fuente: Propia ........................................................................ 48
Figura 9: Diagrama de envió de datos desde el aplicativo Android. Fuente: Propia ..................... 58
Figura 10: Envío de datos por ruta definida. Fuente: propia .......................................................... 60
Figura 11: Envío de datos por pantalla táctil. Fuente: Propia ........................................................ 61
Figura 12: Envío de datos por comando de voz. Fuente: Propia .................................................... 62
Figura 13: Diagrama de recepción de datos en el módulo Arduino en la silla de ruedas. Fuente:
Propia ............................................................................................................................................. 63
Figura 14: Esquema de conexión Fuente: Propia, Utilizando fritzing ........................................... 64
Figura 15: Diagrama de clases. Fuente: propia, Paint Con el estilo Enterprise Architect ............. 68
Figura 16: Pantalla de inicio de aplicación Android. Fuente: propia. ............................................ 73
Figura 17: Pantalla de Ruta de la aplicación Android. Fuente: propia........................................... 74
14
Figura 18: Pantalla de voz de la aplicación Android. Fuente: propia. ........................................... 75
Figura 19: Panel de captura de voz dela aplicación Android. Fuente: propia ................................ 76
Figura 20: Pantalla de panel táctil de la aplicación Android. Fuente: propia. ............................... 77
Figura 21: Foto silla de ruedas. Fuente: propia. ............................................................................. 79
Figura 22: Panel de control Silla de Ruedas. Fuente: propia. ........................................................ 80
Figura 23: Verificación de la conexión del módulo wifi en la interface de Arduino. Fuente: Propia
........................................................................................................................................................ 84
Figura 24: Envío de comando adelante por parte del aplicativo. Fuente: Propia ........................... 85
Figura 25: Envío de comando izquierda por parte del aplicativo. Fuente: Propia ......................... 86
Figura 26: Envío de comando derecha por parte del aplicativo. Fuente: Propia............................ 87
Figura 27: Envío de comando detener por parte del aplicativo. Fuente: Propia ............................ 88
Figura 28: Envío de comando atrás por parte del aplicativo. Fuente: Propia ................................ 89
Figura 29: Recepción de los comandos. Fuente: Propia ................................................................ 90
Figura 30: Mapas de pruebas. Fuente: Propia ................................................................................ 90
Figura 31: Ruta definida en el aplicativo desde el dispositivo móvil. Fuente: Propia ................... 93
Figura 32: Ruta definida por comando en el aplicativo desde el dispositivo móvil. Fuente: Propia
........................................................................................................................................................ 95
Figura 33: Ruta definida por pantalla táctil en el aplicativo desde el dispositivo móvil. Fuente:
Propia ............................................................................................................................................. 97
15
Lista de Tablas
Tabla 1 protocolo de conexión con modulo. Fuente: propia .......................................................... 65
Tabla 2 protocolo de conexión con silla de ruedas. Fuente: propia ............................................... 66
Tabla 3 explicación de las variables utilizadas. Fuente propia ...................................................... 72
Tabla 4 tabla de pruebas. Fuente propia ......................................................................................... 84
Tabla 5 detalles del mapa n1, por pantalla táctil. Fuente: propia ................................................... 92
Tabla 6 detalles del mapa n2, por comando de voz. Fuente: propia .............................................. 94
Tabla 7 detalles del mapa n3, por ruta definida. Fuente: propia .................................................... 96
16
1 Resumen
En el presente trabajo se realizó el diseño y la implementación de un aplicativo en el sistema
operativo Android para dispositivos móviles para el manejo de usa silla de ruedas eléctrica, tal
proceso implico la implementación de módulos Arduino que permiten a todo el sistema estar
conectado a wifi. El aplicativo cuenta con tres tipos diferentes de control, como lo son el control
por pantalla táctil, el control por voz y el control por trazado de ruta, a partir de las pruebas
realizadas se determinó que, al momento de utilizar la aplicación móvil, tanto esta como la silla
deben estar ubicados en la misma red wifi, estar dentro el rango de los mismos y no tener
implementado alguna configuración que pueda bloquear la comunicación dispositivo-silla tales
como proxys. El correcto funcionamiento de la silla de ruedas está demostrado para superficies
planas y usuarios que no superen un peso de 100kg.
17
2 Abstract
In this paper the design and implementation of an application on the Android operating system
for mobile devices for handling chair uses electric wheelchair was made, such process involved
implementing Arduino modules that allow the entire system to be connected to wifi. The
application has three different types of control, such as the touch screen control, voice control and
the control trace route, from tests it was determined that, when using the mobile application, both
this as the chair must be located in the same wifi network, be within the range of them and not
having implemented some settings that can block the device-chair communication such as
proxies. The proper functioning of the wheelchair is shown for flat surfaces and users that do not
exceed a weight of 100kg.
18
3 Introducción
El proyecto “Aplicación Android para silla de ruedas, que permita controlarla por comandos de
voz, pantalla táctil y programación de ruta.” fue realizado para optar al título de Ingeniero de
sistemas de la Universidad Cooperativa de Colombia y comprobar la viabilidad del mismo en
beneficio de la sociedad aplicando innovación por medio de las nuevas tecnologías.
En este documento se pretende demostrar el potencial que ofrecen este tipo de aplicaciones para
mejorar la calidad de vida de las personas en estado de movilidad reducida, con impedimentos
físicos, sensoriales o cognitivos, por lo que este proyecto se concibe con la intensión de
desarrollar un sistema de control modular y de bajo costo que permita el movimiento de una silla
de ruedas en diferentes entornos.
19
4 Planteamiento del problema
Descripción del problema 4.1
Desde el año 1869, la silla de rueda ha sido una importante herramienta para todas aquellas
personas que sufren de algún problema de locomoción o movilidad reducida, esta pieza ha sido
ampliamente estudiada y rediseñada para adaptarse a las necesidades de las personas, la silla de
ruedas eléctrica nos provee de un uso tecnológico avanzado con muchos componentes que
facilitan la vida diaria. (Michael Boninger, 2011)
Con el fin de reducir la necesidad de uso manual, El presente trabajo pretende desarrollar una
aplicación para dispositivos móviles que permita el control de la silla de ruedas.
Formulación del problema 4.2
El problema de la movilidad de las personas discapacitadas es un problema de una población que
ha sido aislada de alguna manera por la sociedad.
¿Cómo implementar un sistema de control por aplicaciones celulares para facilitar la movilidad,
reducir el esfuerzo de las personas, y mejorar su calidad de vida?
20
5 Objetivos
Objetivo General 5.1
Desarrollar una aplicación móvil para silla de ruedas, que contenta un manejo por Pantalla táctil,
comandos de voz y permita la programación de una ruta.
Objetivos Específicos 5.2
1. Desarrollar una aplicación celular para maniobrar la silla de ruedas por medio del panel táctil
del celular.
2. Incorporar un sistema de manejo de la silla por comandos de voz.
3. Programar un sistema de manejo por ruta en entorno definido para la silla.
4. Acoplar un sistema de control con redes neuronales.
21
6 Justificación
Justificación Teórica 6.1
La Universidad Cooperativa de Colombia, sede Santa Marta, posee un excelente cuerpo de
docente en el área de la ingeniería, también posee una base de datos e implementos de
laboratorio, este proyecto es una actualización del proyecto presentado anteriormente, la silla de
ruedas controlada por el movimiento de los ojos, este proyecto se busca motivar a los estudiantes
para continúen implementando nuevas mejoras tecnológicas dejando como base este proyecto
para así poder crear redes con los que los estudiantes y los docentes se motiven al desarrollo e
investigación, los programas utilizados fueron creados en el sistema operativo de celulares
Android, y el control de la silla de ruedas fue realizado a través de Arduino.
Justificación metodológica 6.2
Los modelos presentados en el proyecto pueden ser modificados por cualquier estudiante
interesado en el tema, con conocimientos básicos, para futuras investigaciones.
La investigación realizada arrojo como resultado la utilización del sistema Android para los
dispositivos móviles, para él envió de datos se utiliza clases conocidas de java, la recepción de
datos se realiza a través de un módulo de Arduino. La presentación de una silla de ruedas asistida
22
por un celular es una buena elección que permitirá mejor la calidad de vida a la población con
movimiento reducido.
Justificación practica 6.3
La necesidad de un sistema de control el cual transmitir los datos de la aplicación Android a la
silla de ruedas dirigido por la universidad cooperativa de Colombia, fue el principal motivo por el
cual se desarrolló este sistema; la finalidad del sistema es garantizar el movimiento de la silla de
ruedas controlado por la aplicación móvil.
23
7 Alcance y Limitaciones
Alcance 7.1
El proyecto se desarrolló en la Universidad Cooperativa de Colombia, sede Santa Marta. Tras
probar los diferentes módulos para la conectividad, se escogió el módulo wifi, se tomó la
decisión de trabajar con el dispositivo WIFI CC300, el cual ofrece un alcance y velocidad
pertinentes, en base a esto se llevaron a cabo pruebas para probar la eficiencia del dispositivo, En
definitiva, se optó por este para cumplir con el objetivo principal del proyecto, desarrollar el
Sistema de Control por Aplicación Celular, el prototipo se probará en un recinto cerrado y con
ambiente controlado.
Limitaciones 7.2
La principal limitación en este proyecto es el alcance de los dispositivos, el módulo de wifi
necesita un punto de conexión con un modem de internet, y se ve limitado a las interferencias
características del protocolo wifi.
24
8 Marco de referencias
Antecedentes 8.1
Durante la investigación encontramos distintas implementaciones de sillas de ruedas autónomas,
Dentro de estas destacamos:
Diseño de una silla de ruedas automático encontrando la 8.1.1
trayectoria con el Sistema de Orientación Inteligente.
En España (Mjumder, Banerjee, & cresta, 2011) presentaron un proyecto de silla de ruedas, el
cual consiste en: Una silla de ruedas motorizada convencional que ha sido equipada con sensores
y programada con un sistema de guía inteligente para maniobrar de manera eficiente a sí misma
automáticamente, a partir de un punto a otro en una instalación equipada con una red de sensores
que proporcionan a la silla de ruedas un mapa básico de su curso.
Evaluando la usabilidad de un teléfono para monitorear silla de 8.1.2
ruedas
De acuerdo con (Yu-Kuang, Hsin-Yi, Annmarie, Jonathan, & Rory, 6 march 2015) , se realizó un
estudio para verificar la usabilidad de las aplicaciones de monitoreo de sillas de ruedas, donde el
objetivo de estas aplicaciones era brindar un sistema de aviso previo que alertara al usuario
cuando está haciendo uso indebido de una silla de ruedas, para generar las alertas se hizo uso de
unas recomendaciones clínicas. Este estudio evaluó la facilidad con la que se manejan estas
25
aplicaciones mediante la recopilación de información a partir de cinco usuarios que utilizaban
sillas de ruedas y cinco profesionales en el campo de la rehabilitación mediante cuestionarios y
entrevistas, el cual presento como conclusión que esas Apps son de ayuda útil en usuarios y
rehabilitadores profesionales.
Control de una Silla de Ruedas por Medio de un Dispositivo Móvil 8.1.3
con Sistema Operativo Android.
De acuerdo con (Mancilla, Crespo, & Navarro, 2012) se presentó una propuesta de un prototipo
de una silla de ruedas para motorizarla y controlarla por medio de un dispositivo móvil con
Sistema Operativo Android, que surgió como respuesta a la necesidad de desplazamiento que
enfrentan niños y niñas con discapacidad motriz. La utilización de una silla de ruedas motorizada
de bajo costo y manipulada por el propio usuario a través de un sistema móvil resulta una valiosa
alternativa. El prototipo obtenido se diseñó de acuerdo a las especificaciones de los terapeutas y
asesores de la UOP (Unidad de Orientación al Público, en Tuxtla) y fue evaluado
satisfactoriamente con niños y niñas de esta institución.
Automatización de una silla de ruedas controlada por comandos 8.1.4
de voz.
Según (Garcia Pardo, feizzola, & calderon, 2003) se diseñó un Sistema que incluye diversos
campos de la electrónica como lo son: el tratamiento de señales, la electrónica de potencia, la
inteligencia artificial y el campo de control y la automatización. Todo esto concentrado en una
silla de ruedas automatizada la cual posee un sistema automático de movimiento y un módulo
reconocimiento de voz, donde su control se realiza a través de sencillos comandos como:
26
Adelante, atrás, derecha, izquierda y pare. El modulo que realiza el procesamiento de la voz en el
sistema, es el sistema de desarrollo “Voice Direct 364”, el cual en un circuito integrado incluye
un DSP (Dispositivo de Protección contra Sobretensiones) y una red neuronal, el DSP realiza el
procesamiento de la señal y la red neuronal realiza la identificación de la palabra.
Red neuronal basada en el control del desacoplamiento diagonal 8.1.5
de los sistemas de silla de ruedas eléctricas.
En este trabajo (Nguyen, Su, & Nguyen, 2013) proponen un método de control de
desacoplamiento diagonal avanzado para sistemas de silla de ruedas eléctrica. Este método de
control se basa en una combinación de la técnica de diagonalización sistemática y el diseño de
control de red neural. Como tal, este método de control reduce los efectos de acoplamiento en un
sistema multivariable, dando lugar a procedimientos de diseño de control independientes. El uso
de un modelo dinámico obtenido, el problema del cálculo Jacobiano de la planta se elimina en un
diseño de control de la red neural. La eficacia del método de control propuesto se verifica en una
aplicación en tiempo real en un sistema de silla de ruedas eléctrica.
Un enfoque de control visual autónomo para el paso de una silla de 8.1.6
ruedas a través de una puerta en un corredor.
La motivación del trabajo realizado por (Pasteau, Narayanan, Babe, & Chaumette, 2016)
proviene en parte del hecho de que los sensores de bajo costo como sensores de visión podrían
ser empleados en el diseño de sistemas autónomos. El objetivo es desarrollar una solución para la
navegación autónoma en silla de ruedas en un ambiente interior mediante un conjunto de cámaras
monoculares con cada uno de ellos está dedicado a una tarea en particular. Tales sistemas de
sillas de ruedas semi-autónomas serían útiles en condiciones en que las deficiencias motoras
27
puedan obstaculizar la navegación segura y eficaz, proporcionando asistencia segura en la
realización de las tareas fundamentales que proporciona un control de alto nivel para el usuario.
Los resultados de experimentos en una silla de ruedas robótica muestran que el sistema es capaz
de ejecutarse con firmeza en diferentes pasillos con una variedad de representaciones de puertas.
Optimización para evadir obstáculos por generación de una 8.1.7
trayectoria reconfigurable de una silla de ruedas que sube
escaleras.
Se desarrolló un prototipo de una silla de ruedas capaz de subir escaleras, siguiendo una
característica clave en el diseño mecánico, el cual es la implementación de dos mecanismos
desconectados en cada eje, uno para distribuir medidas, y el otro para posicionar el eje con
respecto a la silla con el fin de adaptarse a la pendiente general.
Este diseño simplifica considerablemente la tarea de control. Los Modelos cinemáticos son
necesarios para describir el comportamiento del sistema y para controlar los grados de libertad
accionados de la silla de ruedas con el fin de garantizar la comodidad del pasajero. (González,
Morales, & Feliu , 2010).
Uso de una red inalámbrica de sensores visuales para navegar 8.1.8
armónicamente varias sillas de ruedas de bajo costo en un
ambiente interior.
Según (Tian, Chao , Feng, Xing , & Shah , 2016) “la navegación de sillas de ruedas robóticas de
bajo costo en una topología de nodos de sensores inalámbricos que se implementan en un entorno
dinámico y lleno de gente en interiores es un problema difícil de tiempo polinómico no
determinista (NP-duro)”. Para la solución de dicho problema se propone un algoritmo de
28
navegación distribuida multi-logica de ruedas global. El algoritmo posee distintivas
características como son la navegación de búsqueda global y las capacidades locales de
resolución de conflictos. En el algoritmo propuesto, un método de predicción de tiempo de viaje
adopta una penalización por posibles conflictos sobre la base de las sillas de ruedas 'prioridad, la
velocidad y la distancia entre los nodos.
Una Ondícula y sistema de voz basado en red neuronal para el 8.1.9
control de una silla de ruedas inteligente.
(AL-Rousan & Assaleh , 2011) Presentan un diseño de un sistema automatizado de silla de
ruedas eléctrica que integra las últimas tecnologías, para ayudar a los usuarios con discapacidad
motora, en el desplazamiento de la misma y en el envío de mensajes de ayuda a cuatro destinos
diferentes por medio de mensajes SMS. Un usuario puede mover la silla de ruedas con una de las
tres técnicas integradas en ella: un joystick, botones de dirección o de voz. Por otra parte, la
velocidad de la silla de ruedas se puede controlar mediante dos botones (lento y rápido). Para el
reconocimiento de los comandos de voz, el sistema utiliza wavelets (Ondiculas) y redes
neuronales para la extracción de características y la clasificación, respectivamente.
Control neural de los movimientos de una silla de ruedas 8.1.10
De acuerdo con (Boquete, García, Barea, & Mazo, 1999) existen problemas al controlar los
movimientos de la silla de ruedas motorizada de una persona con discapacidad desde un punto de
vista práctico. El sistema de control implementado se ha dividido en dos plantas: el "bajo nivel",
que consiste en un sistema electrónico que controla directamente los controladores de los motores
de la silla. El objetivo de este nivel es asegurar que las velocidades de cada una de las ruedas sean
similares a la velocidad de entrada de estos tableros de control. El segundo nivel de control ("alto
29
nivel"), ejecutado por medio de técnicas neuronales, asegura que las velocidades lineales y
angulares de la silla de ruedas son los indicados por un generador de trayectoria.
Desarrollo de un sistema inteligente para una silla de ruedas para 8.1.11
un usuario con discapacidad motriz severa.
“Los usuarios con deficiencia motora severa pueden tener dificultades para operar una silla de
ruedas cuando están en espacio reducido (por ejemplo, puerta de entrada que pasa) o al evitar
obstáculos ya que no pueden ordenar a la silla de ruedas por medio de una palanca de mando
convencional.” (Tomari, Kobayashi, & Kuno , 2012). Estos autores proponen un marco teórico
que puede ser útil a los usuarios a superar las circunstancias adversas utilizando una estrategia de
control semiautónomo jerárquica. Inicialmente, las entradas de usuario multimodal basado en el
ángulo de guiñada y la cabeza del interruptor momentáneo se analizan para decidir un modo de
maniobra y asignar la dirección de la marcha. A continuación, la información ambiental se
percibe mediante la combinación de un telémetro láser y el sensor Kinect para determinar el
mapa de seguridad alrededor de la vecindad de la silla de ruedas.
La silla Robótica SENA. Un Enfoque Basado en la Interacción 8.1.12
Hombre-Máquina
Los autores (González, y otros, 2008) presentan la silla de ruedas robotizada SENA. “SENA se
basa en una silla eléctrica comercial a la que se ha integrado una serie de sensores y dispositivos
que son gestionados mediante un ordenador portátil”. Dicho dispositivo está caracterizado por la
capacidad que posee para navegar de forma autónoma en espacios interiores, su habilidad para
interactuar, de un forma fácil, y cooperar con el usuario o personas del entorno gracias, entre
otros, a una arquitectura software desarrollada específicamente para robots asistente.
30
9 Marco Teórico
Inteligencia artificial 9.1
Según (Álvarez, 1991), La inteligencia artificial es considerada una rama de la computación y
relaciona un fenómeno natural con una analogía artificial a través de programas de computador.
La inteligencia artificial puede ser tomada como ciencia si se enfoca a la elaboración de
programas basados en comparaciones con la eficiencia del hombre, contribuyendo a un mayor
entendimiento del conocimiento humano.
La Inteligencia Artificial incluye varios campos de desarrollo tales como: la robótica, usada
principalmente en el campo industrial; comprensión de lenguajes y traducción; visión en
máquinas que distinguen formas y que se usan en líneas de ensamblaje; reconocimiento de
palabras y aprendizaje de máquinas; sistemas computacionales expertos. (Henao, 2000, pág. 10).
La silla de rueda ha suplido necesidades de muchas personas discapacitadas, pero algunas no
están del todo satisfechas por lo que estas no presentan las mismas necesidades, por este motivo
tantos ingenieros como diseñadores han acoplado la Inteligencia artificial, ya que permiten que
las máquinas analicen y reconozcan patrones de comportamiento y adquieran estrategias para la
solución de problemas mediante ejemplos, de forma análoga a como lo haría la mente humana.
(Gómez Barrios, 2013)
Los investigadores desarrollaron unos algoritmos que permiten a la silla adaptarse a la densidad y
la velocidad de los objetos en su camino para encontrar una forma más eficaz de funcionar y no ir
por ejemplo, a contracorriente de una multitud que va en cierta dirección. Finalmente, después de
31
traducir las señales y saber hacia dónde se quiere mover, se transmiten los resultados a un
actuador.
Características de la Inteligencia Artificial. 9.2
1. Los Métodos de inteligencia artificial se distingue de los métodos numéricos por una
característica principal y es el uso de símbolos no matemáticos, no obstante esto no es suficiente
para distinguirlo completamente. Otros programas como los sistemas de bases de datos y
compiladores, procesan símbolos también y estos no se les consideran el uso de técnicas de
Inteligencia Artificial.
2. El comportamiento de los programas no es descrito explícitamente por el algoritmo. La
secuencia de pasos seguidos por el programa es influenciado por el problema particular presente.
El programa especifica cómo encontrar la secuencia de pasos necesarios para resolver un
problema dado (programa declarativo). En contraste con los programas que no son de
Inteligencia Artificial, que siguen un algoritmo definido, que especifica, explícitamente, cómo
encontrar las variables de salida para cualquier variable dada de entrada (programa de
procedimiento). Las conclusiones de un programa declarativo no son fijas y son determinadas
parcialmente por las conclusiones intermedias alcanzadas durante las consideraciones al
problema específico. Los lenguajes orientados al objeto comparten esta propiedad y se han
caracterizado por su afinidad con la Inteligencia Artificial.
3. Estos programas incorporan factores y relaciones del mundo real y del ámbito del
conocimiento en que ellos operan, es decir, implementan el Razonamiento basado en el
conocimiento. Programas como los de contabilidad y cálculos científicos, son programas
32
realizados para un propósito específico, a diferencia de estos; los programas de Inteligencia
Artificial pueden distinguir entre el programa de razonamiento y base de conocimientos dándole
la capacidad de exponer discrepancias entre ellas.
4. Aplicabilidad a datos y problemas mal estructurados, sin las técnicas de Inteligencia Artificial
los programas no pueden trabajar con este tipo de problemas. Un ejemplo es la resolución de
conflictos en tareas orientadas a metas como en planificación, o el diagnóstico de tareas en un
sistema del mundo real: con poca información, con una solución cercana y no necesariamente
exacta.
Automatización 9.3
La automatización es la acción de convertir un proceso manual o semiautomático en uno
automático, es decir que el proceso se lleve a cabo de forma totalmente automática, con el fin de
reducir y facilitar trabajos.
En la actualidad la tecnología ha avanzado de manera drástica y más en áreas de la ingeniería,
innovando para satisfacer necesidades que antes no era posible. Una de las primeras innovaciones
tecnológicas, la silla de rueda fue desarrollada por ingenieros mecatrónicos debido a las
diferentes necesidades que han tenido las personas discapacitadas. Dado que las discapacidades
que estas personas padecen no generan las mismas necesidades, por este motivo se necesita que
la silla de rueda sea lo más automatizada posible. De esta manera ingenieros y diseñadores han
analizados estas discapacidades para diseñar una silla de rueda que satisfaga todas esas
33
necesidades, en general la innovación de la silla de rueda ha avanzado para que esta tenga una
mejor capacidad en cuanto a movimiento, y en cuanto a la interfaz hombre-máquina.
34
10 Marco Conceptual
Pwm 10.1
Según ( Torrente Artero , 2013), PWM es una señal digital cuadrada que simula ser una señal
analógica. El valor simulado de la señal analógica dependerá de la duración que tenga el pulso
digital (es decir, el valor ALTO de la señal PWM). Si el segundo parámetro de esta función vale
0, significa que su pulso no dura nada (es decir, no hay señal) y por tanto su valor analógico
“simulado” será el mínimo (0v).
PWM o modulación por ancho de pulso es una técnica de control con base a la variación del
ciclo útil de una onda cuadrada para controlar el voltaje de entrada a una carga. Básicamente con
esta técnica se le suministra tensión a la carga mientras esté en su ciclo útil y la tensión
que llega a la carga se considera como la tensión de entrada multiplicada por el ciclo útil
de la señal ( Grupo de Arquitectura y Tecnología de Computadore, 2007).
Módulo Arduino 10.2
Según (Arduino, 2014), un módulo Arduino es una plataforma electrónica de código abierto (C)
basado en un hardware y el software fácil de usar. Está dirigido a cualquier persona que realice
proyectos interactivos. Fue inventado por primera vez en finales de 2005 en Ivrea, Italia por
35
Massimo Banzi y David Cuartielles y consiste básicamente de una pieza sencilla de hardware.
(Bayle , 2013).
Arduino Mega 2560 R3 Como su nombre indica, la Mega 2560 es una placa más grande que el
Arduino Uno. Es para personas que quieren más: más entradas, salidas, más y más potencia de
procesamiento. El Mega tiene 54 pines digitales y 16 pines analógicos en comparación con los 15
digital y 6 pines analógicos de la Uno. (Nussey, 2013).
Android 10.3
Android es un sistema operativo multi-dispositivo, inicialmente diseñado para teléfonos móviles.
En la actualidad se puede encontrar también en múltiples dispositivos, como ordenadores,
tabletas, GPS, televisores, discos duros multimedia, mini ordenadores, cámaras de fotos, etcétera.
Incluso se ha instalado en microondas y lavadoras. (Robledo Fernández, 2000, pág. 11).
Este sistema operativo permite programar aplicaciones empleando una variación de Java llamada
Dalvik, y proporciona todas las interfaces necesarias para desarrollar fácilmente aplicaciones que
acceden a las funciones del teléfono (como el GPS, las llamadas, la agenda, etcétera) utilizando el
lenguaje de programación Java. Como se observa en la Figura 1 vemos el logo del sistema
Android muy simple. Su sencillez, junto a la existencia de herramientas de programación
gratuitas, es principalmente la causa de que existan cientos de miles de aplicaciones disponibles,
que amplían la funcionalidad de los dispositivos y mejoran la experiencia del usuario. (Robledo
Fernández, 2000, pág. 11)
36
Figura 1: Logo oficial de Android. Fuente: https://es.wikipedia.org/wiki/android
Android Studio 10.4
El IDE oficial para Android, Android Studio proporciona las herramientas más rápidas para la
creación de aplicaciones en todo tipo de dispositivo Android. Depuración, herramientas de
rendimiento, un sistema de construcción flexible y una acumulación instantánea / sistema de
desplegar todos le permiten centrarse en la construcción aplicaciones únicas y de alta calidad.
(Google, s.f.). En la Figura 2 se puede ver la mesa de trabajo de Android Studio la cual está en la
fase de creación de una activity, con la paleta de objetos a la izquierda y la activity en el centro.
La interface se desarrolló en Android, por ser una plataforma de desarrollo libre para aplicaciones
con gran riqueza e innovaciones (sensores, localización, servicios, etc.). “Una de las mayores
fortalezas del entorno de aplicación de Android es que se aprovecha del lenguaje de
programación Java. El SDK de Android no acaba de ofrecer todo lo disponible para su estándar
del entorno de ejecución Java (JRE), pero es compatible con una fracción muy significativa de la
misma”.
37
Figura 2: Mesa de trabajo Android Studio. Fuente: Propia
Componentes de Android Studio 10.4.1
Toda Aplicación Android posee elementos esenciales denominados Componentes. Cada uno de
estos componentes es un punto distinto de entrada por medio del cual el sistema operativo puede
interactuar con la aplicación. Ahora bien, no siempre un componente es un punto de entrada, sino
que unos dependen de otros, aunque cada uno exista como una entidad aislada en Android y
ejecute un papel determinado que define el comportamiento general de la aplicación. (Robledo ,
Fernández, & Robledo, 2011, pág. 37)
Carpeta de archivos
Paleta de objetos
Actividad
38
Actividades (Activities): Una pantalla única con una interfaz de usuario se denomina actividad,
por ejemplo, una aplicación de correo electrónico puede tener una actividad que muestra una lista
de correo electrónico nuevo, otra actividad que compone un correo y otra actividad que lee los
mensajes. Aunque las actividades trabajan conjuntamente para dar la sensación de una única
aplicación, cada una de es autónoma de las otras. Por lo tanto, otra aplicación externa diferente
podría arrancar cualquiera de estas actividades (si la aplicación de correo electrónico lo permite).
Por ejemplo, una aplicación que gestiona los contactos podría iniciar la actividad que compone
nuevos mensajes de correo indicando como destinatario del mensaje al contacto elegido en la
primera aplicación. Tal como se muestra en la Figura 3 podemos ver dos actividades
interactuando entre sí, una actividad invoca a la otra, para el usuario esto sería como pasar página
en un libro.
Figura 3: Ejemplo de una activity. Fuente: http://www.itcsolutions.eu/2011/08/31/android-tutorial how-to-create-and-display-a-new-form-window-or-activity/
39
Componentes de la pantalla de inicio (Widgets): Estos tipos de componentes son visuales y son
usados principalmente en la Pantalla de inicio (HomeScreen) de Android para dar a conocer
información que se actualiza habitualmente como, por ejemplo, un reloj, la previsión del tiempo,
etcétera. (Ver Figura 4)
Figura 4: Widgets en pantalla Android. Fuente: http://www.pcworld.com.mx/Articulos/24531.htm
Servicios (Services): Es aquel componente que se ejecuta en segundo plano y no está en
constante uso, es decir, realiza operaciones cada cierto tiempo. Un servicio no brinda una interfaz
gráfica al usuario. Por ejemplo, un servicio puede reproducir música en segundo plano mientras
40
el usuario está en otra aplicación, o puede obtener información de Internet sin la interacción del
usuario. Un servicio es implementado a partir de la clase Java Service. En la Figura 5 podemos
ver una clase de java que representa un servicio, esta clase de ejemplo al ser llamada por una
actividad (Ver sección 7.4 - Actividades) esperará 5 segundos en segundo plano y luego se
detendrá.
Figura 5: Ejemplo de código java que invoca un servicio. Fuente: https://developer.android.com/guide/components/services.html
41
Puente H 10.5
Según ( Torrente Artero , 2013), “Un puente H es un circuito electrónico que permite a un motor
eléctrico DC girar en ambos sentidos, avance y retroceso”. Estos componentes electrónicos son
usados ampliamente en el campo de la robótica como convertidores de potencia.
Figura 6: Estructura de un puente H, fuente :(Mancilla, Crespo, & Navarro, 2012, pág. 7)
Los puentes H son utilizados en la construcción de una silla de ruedas automatizada para invertir
el giro de un motor, pero a su vez puede usarse para frenarlos (de una manera brusca), al hacer un
corto entre las bornes del motor, o hasta puede usarse para permitir que el motor frene bajo su
propia inercia, es decir, cuando desconectamos el motor de la fuente de energía que lo alimenta.
(Mancilla, Crespo, & Navarro, 2012).
42
Estructura de un Puente H 10.5.1
Figura 7: Estados básicos del puente h, fuente: (Mancilla, Crespo, & Navarro, 2012)
Como se puede apreciar en la Figura 6, los interruptores S1-S3, nunca deberán ser cerrados al
mismo tiempo, esto ocasionaría un cortocircuito en la fuente de tensión de entrada. Lo mismo,
ocurre con los interruptores S2-S4. Este estado, se conoce con el término inglés “shoot-
through”, algo así, como, “paso a través”. (Gia, 2014) Ver Figura 7 estado básicos del puente
H.
Si los interruptores todos los interruptores (S1, S2, S3 y S4) están abiertos, el motor estará
libre, por el contrario, si el motor está girando y queremos frenarlo o pararlo, la tensión
inducida que se genera con la inercia, se debe derivar hacia un sistema llamado de frenado. En
general, los cuatro elementos de conmutación se pueden activar y desactivar de forma
independiente, aunque hay algunas restricciones evidentes, (Gia, 2014).
43
WIFI 10.6
Según (Aliance, s.f.) Una Red WiFi es la creación de una estructura de red implementando como
base principal la utilización de tecnología inalámbrica WiFi (802.11a - 802.11b - 802.11g -
802.11n) como forma para que los equipos se conecten entre sí y a internet. El uso más frecuente
de esta tecnología es la conexión de portátiles a internet desde las cercanías de un punto de
acceso. La emisión y recepción de datos se realiza a través de radiofrecuencia. Existen diferentes
formatos de conexión, pero el más popular es el conocido como 802.11b, que opera en la banda
de los 2,4 gigahertzios.
Módulo CC3000 10.7
Según (Instruments, 2013) El módulo CC3000 es un procesador de red inalámbrica
independiente que simplifica la implementación de la conectividad a Internet. El módulo CC3000
Wi-Fi simplifica el diseño y crea una mejor experiencia de usuario para aplicaciones tales como
la automatización del hogar, electrodomésticos, energía inteligente, seguridad y salud y bienestar.
Este módulo posee un regulador de 3.3V a bordo que pueda manejar la corriente máxima de 350
mA, y un cambiador de nivel para permitir nivel lógico 3 o 5V, este no posee una antena. En la
sección 14.1.5 se puede apreciar cada pin y su funcionalidad. Es importante resaltar que Texas
Instruments sacó al mercado dos nuevos microcontroladores, el microcontrolador CC3100 y el
CC3200 para sustituir al microcontrolador CC3000. Por tal motivo actualmente, desde Texas
Instruments no se recomienda el uso del microcontrolador CC3000, por presentación de
problemas en su codificación y promueve la adquisición o migración hacia el microcontrolador
CC3200 (adafruit, 2013).
44
Odometría 10.8
Según (Borenstein & Feng, December 1996) Odometría es el método más utilizado para
determinar la posición momentánea de un robot. En las aplicaciones más prácticas de odometría,
ofrece fácil acceso al posicionamiento en tiempo real, La frecuencia a la que las medidas
absolutas se deben llevar a cabo depende en gran medida de la precisión del sistema de
odometría.
En este orden de ideas se debe tener claro que la odometría es la información relativa que nos
dice cuánto hemos avanzado, pero no en donde estamos. Si sabemos dónde empezamos, entonces
podemos añadir el movimiento con relación a la posición inicial y obtener una estimación de
nuestra posición actual. Odometría nos da una respuesta muy rápida, pero debido a errores
acumulados, que está sujeta a la deriva. Se necesitarán otras técnicas para corregir la estimación
de odometría periódicamente. Algunos de estas pueden corregir todos los ejes, y algunos pueden
corregir uno o dos. Ahora bien, la odometría de un vehículo es directamente proporcional a la
capacidad de su navegación, es decir, entre mejor sea su odometría mejor será capaz de navegar.
(Holland, 2004).
45
11 Marco contextual
El proyecto se encuentra enfocado en la implementación de una aplicación móvil para controlar
la silla de ruedas, por medio del panel táctil del celular, poder controlar también por voz, y
predefinir una ruta la cual la silla recorrerá, destinada a usuarios con movimiento reducido con el
fin de aumentar su calidad de vida.
“Este tipo de dispositivos mejora gratamente la calidad de vida de las personas discapacitadas y
en muchos casos puede permitir manejar una silla de ruedas a personas que de otra manera serían
incapaces de realizarlo”. El software desarrollado para la silla de ruedas es capaz de conducir el
sistema de movimiento en situaciones de difícil maniobrabilidad, las cuales son complicadas para
personas con patologías relacionas con el Parkinson o movimientos espasmódicos, por ejemplo.
(Alcubierre , y otros, 2005).
46
12 Metodología
Área del conocimiento, área temática y tema 12.1
El área del conocimiento en el que se desarrolló el proyecto fue la de ingeniería de sistemas, el
área temática fue; Desarrollo de software; El tema de investigación, fue la movilidad en la
población con movimiento reducido.
Título y área de investigación 12.2
El título del proyecto fue: Sistema de control con redes neuronales para silla de Ruedas asistida
por comandos de voz, programación de ruta, manejada por Aplicación celular y con un sistema
de carga mediante celdas solares Y abarco las áreas de investigación de: implementación de
inteligencia artificial y programación en plataformas móviles.
Tipo de investigación. 12.3
Las investigaciones pueden ser de diferentes tipos, bien sea de campo, de proyectos especiales,
factibles o de tipo documental, todo esto según (Balestrini, 2002). La presente investigación es
del tipo factible puesto que está en concordancia con los objetivos planteados y la finalidad con la
47
que se desarrolló el proyecto, es decir, se un prototipo orientado a proporcionar una solución a
un problema planteado en un ambiente real. Este proyecto se apoyó en un diseño de
campo, puesto que los datos requeridos para la investigación fueron obtenidos directamente
de una silla de ruedas en funcionamiento.
Para alcanzar el éxito de los objetivos planteados, el desarrollo del proyecto se ha separado
en fases según la metodología de descomposición de trabajo WBS (Work Breakdown
Structure) y basando la constitución y desarrollo de las actividades en la gestión de
proyectos, que es la disciplina que permite gestionar de manera organizada y administrar
recursos de manera tal que se pueda alcanzar con exito los objetivos dentro del alcance, el tiempo
y los costos definidos. En este orden de ideas y teniendo en cuenta lo expuesto por (Pereira Z. ,
2011) el tipo de investigación es mixta porque recolecta, analiza y vincula datos cualitativos y
cuantitativos en un solo proyecto de investigación.
48
Método de investigación 12.4
El proyecto se dividió en tres fases, la fase de búsqueda de información, la fase de
implementación, y la fase generación de documentos, los cuales se describen en la Figura 8.
Figura 8: Método de investigación Fuente: Propia
Proyecto
Fase
Acción
Generación de
documentación
49
Fases de la investigación. 12.5
Fase 1: Desarrollo del estado del arte 12.5.1
En esta fase se investigó sobre proyectos relacionados con la silla de ruedas con movimientos
autónomos, luego de tener una idea sólida, se plantearon puntos clave que sirvieron en la fase de
creación de código, tales como, la plataforma móvil a trabajar (Android), y la comunicación con
la silla de ruedas (Arduino)
Fase 2: Construcción e implementación de código 12.5.2
En esta fase se consolidaron en documentos las fuentes de información, en base a estas se creó el
posterior código que luego fue probado reiterativas veces en la silla de ruedas.
Fase 3: Generación documento y manual. 12.5.3
Cuando culmine la etapa práctica, se reunirá toda la información y material utilizados con la cual
se redactará un documento que evidencia los pasos del desarrollo del proyecto, para dar a conocer
a toda la comunidad interesada los resultados del trabajo realizado.
50
Técnicas e instrumentos metodológicos 12.6
Técnicas 12.6.1
12.6.1.1 Fuente primaria
Como primera instancia se contó con la información del proyecto anterior, Implementación de
silla de ruedas guiada por señales electrooculograficas desarrollada por Jose Lozano Mendoza
Jorge Núñez Jiménez, la cual proporciono las bases necesarias para proyección en el desarrollo
de este proyecto. Revisión del manual de usuario de la silla de ruedas para comprender su
funcionamiento y posterior planificación para la incorporación de los aplicativos de software.
12.1.1.1 Fuente secundaria.
Se realizaron consultas en diversas fuentes como en la base de datos de la universidad
cooperativa de Colombia, artículos, trabajos, tesis y trabajos de grado para profundizar y ampliar
los conocimientos referentes a los distintos temas que se abordaron a lo largo del desarrollo de
este proyecto, también se reforzaron conocimientos en Arduino (Arduino, 2014) y Android
Studio (Robledo Fernández, 2000) ya que no se presentó antes la oportunidad de manejar este
tipo de tecnología, la cual fue muy útil, dada su sencillez de uso.
12.1.1.2 Instrumentos
La silla de ruedas utilizada en el proyecto de investigación anterior, lo que nos facilitó el trabajo,
ya que teníamos una base sólida muy cerca de nuestra comunidad, los elementos usados fueron:
51
1 Arduino Mega 2560 muy fácil de programar, un módulo adaptable a Arduino Mega 2560, el
CC3000 darle conectividad wifi a la silla de ruedas.
Planificación 12.7
1. Análisis del tema
2. Dar un orden de prioridad a las actividades (cual se realiza primero)
3. Recopilación de la información.
4. Análisis de la información y planteamiento del problema.
5. Planteamiento de soluciones al problema.
6. Selección de materiales.
7. Diseño, construcción e implementación del proyecto.
8. Entrega de resultados.
Recursos Humanos 12.8
El laboratorio de la Universidad Cooperativa de Colombia, que nos brindó el espacio para
trabajar.
52
Cronograma de actividades 12.9
Aplicación Android para silla de ruedas, que permita controlarla por comandos de voz, pantalla táctil
y programación de ruta.
Objetivo Actividad Tarea Meses
1 2 3 4 5 6 7 8 9 10 11 12 13
Desarrollo de
aplicación celular
para maniobrar la
silla de ruedas por
manejo del panel
táctil del celular.
Investigar
Los
diferentes
sistemas
operativos
de
dispositivos
móviles
Buscar
documentos
relacionado
s con sillas
de ruedas
automatizad
as
controlados
por
dispositivos
móviles
Estudiar los
datos
encontrados
Diseñar un Recopilar
53
prototipo los datos y
diseñar un
prototipo de
software
adecuado
Construir el
aplicativo
móvil
Crear a
partir del
modelo la
aplicación
que se
conecta con
la silla de
ruedas
Incorporación de
un sistema de
manejo de la silla
por comandos de
voz.
Acoplar al
aplicativo
móvil
Acoplar la
investigació
n de
comandos
de voz en
dispositivos
móviles
con la
54
aplicación
final
Programación de
ruta en entorno
definido para la
silla.
Acoplar al
aplicativo
móvil
Acoplar lo
investigado
en creación
de rutas
predetermin
adas
En la
aplicación
principal
Diseño de un
sistema de control
con redes
neuronales.
Diseñar un
prototipo de
control con
una red
neuronal
Investigar
sobre redes
neuronales
para el
control de
las silla de
ruedas
55
Acoplar los
datos
investigados
en la
aplicación
principal
56
13 Delimitaciones del proyecto
Delimitación del problema 13.1
Este proyecto está orientado al desarrollo de un sistema de control mediante dispositivos móviles,
que permiten manipular la silla de ruedas desde cualquier parte que tenga acceso a la red de la
silla, la silla de ruedas se puede adaptar a diferentes tipos de control y con diferentes métodos de
acceso y comunicación con ella, todo esto se hizo sin quitarle merito a los métodos de control
comunes, como lo puede ser el clásico joystick (palanca de manejo) que en el entorno real sería
mucho más práctico.
Delimitaciones del espacio 13.2
Este proyecto fue ejecutado en la costa caribe Colombiana, en el departamento de Magdalena,
específicamente en la ciudad de Santa Marta, su planeación, creación, implementación, pruebas y
designación de trabajos se llevaron a cabo en las instalaciones del laboratorio de electrónica de la
Universidad Cooperativa de Colombia.
57
Delimitaciones del tiempo. 13.3
Para el proceso de recolección de información, y todo lo relacionado con el desarrollo del
proyecto, imprevistos y su sustentación, se programaron 12 meses a partir del 1ro de Julio del año
2015, dado el esfuerzo dedicado al proyecto, se espera finalice Antes de que se culmine el
tiempo.
58
14 Descripción del sistema
Diagramas del sistema 14.1
Diagrama de envío de datos 14.1.1
Figura 9: Diagrama de envió de datos desde el aplicativo Android. Fuente: Propia
59
La Figura 9 describe el proceso completo de envío de datos desde el aplicativo móvil, Para
generar movimiento en la silla de ruedas.
El aplicativo cuenta con tres distintas formas de enviar datos a la silla de ruedas por medio del
aplicativo, el envío de datos capturados por la pantalla táctil, esta captura los movimientos
realizados en la pantalla, mover hacia arriba envía el comando “adelante” mover hacia abajo
envía el comando “abajo”, mover hacia la derecha, envía “derecha”, mover hacia la izquierda,
envía “izquierda”, y soltar la pantalla, envía “detener”. Él envió de comandos por voz, recibe las
palabras anteriores y envía el comando especificado para ellos, “adelante, abajo, izquierda,
derecha, detener”, Él envió de ruta definida nos permite dibujar en la pantalla, lo cual hace que la
silla de ruedas se mueva igual a como se le indique en el aplicativo.
60
Figura 10: Envío de datos por ruta definida. Fuente: propia
En la Figura 10, el diagrama de envió de datos por ruta, muestra como la aplicación procesa la
información y la envía en el seccional de ruta definida, el programa espera a que el usuario digite
la IP a la cual va a enviar los datos, (la cual debe ser la IP del módulo cc300), luego, espera a que
el usuario dibuje los 4 trazos permitidos y procede a enviar estos a la silla.
61
Figura 11: Envío de datos por pantalla táctil. Fuente: Propia
En la Figura 11, el diagrama de envió de datos por pantalla táctil, muestra como la aplicación
procesa la información y la envía en el seccional de táctil, el programa espera a que el usuario
digite la IP a la cual va a enviar los datos, (la cual debe ser la IP del módulo cc300), luego, espera
62
a que el usuario dibuje el trazo que quiere (arriba, abajo, izquierda, derecha) y procede a
enviarlos a la silla.
Figura 12: Envío de datos por comando de voz. Fuente: Propia
En la Figura 12, el diagrama de envió de datos por comando de voz, muestra como la aplicación
procesa la información y la envía en el seccional de Comando de voz, el programa espera a que el
usuario digite la IP a la cual va a enviar los datos, (la cual debe ser la IP del módulo cc300),
luego, espera a que el usuario Diga el comando (adelante, atrás, izquierda, derecha, detener) y
procede a enviar a la silla.
63
Diagrama de recepción de datos 14.1.2
Figura 13: Diagrama de recepción de datos en el módulo Arduino en la silla de ruedas. Fuente: Propia
64
En la Figura 13 El diagrama muestra como el módulo CC3000 recibe los datos. Los procesos
principales en resumen son: encendido del módulo, detectar comando, procesar comando y enviar
dato a la silla de ruedas. El modulo según el dato recibido procederá a enviar la señal a la silla de
ruedas, que, según el comando, la silla generará el movimiento deseado.
Esquema representativo del sistema de conexión 14.1.3
Figura 14: Esquema de conexión Fuente: Propia, Utilizando fritzing
65
La Figura 14 muestra el esquema a través del cual se establecerá la estructura de la conexión
entre los dispositivos, estos se deben configurar como lo especifica el protocolo de conexión que
se encuentra en la tabla 1
Protocolo de conexión con módulo cc3000 14.1.4
Tabla 1 Protocolo de conexión con modulo. Fuente: propia
Como se muestra en la Tabla 1, se debe conectar los pines del Arduino a los pines del módulo
CC3000 para que el código presentado en los anexos pueda funcionar.
PINES ARDUINO PINES CC3000
PIN 3 IRQ
PIN 5 VBEN
PIN 10 CS
PIN 51 MOSI
PIN 50 MISO
PIN 52 CLOCK
5v Vin
GND GND
66
Protocolo conexión con silla de ruedas 14.1.5
Pines Arduino Pines Silla de ruedas
PIN 2 M1
PIN 6 M1
PIN 9 PWM1
PIN 4 M2
PIN 8 M2
PIN 13 PWM2
Tabla 2 Protocolo de conexión con silla de ruedas. Fuente: propia
De igual forma que en la tabla 1, la tabla 2 presenta la forma en la cual los pines del Arduino
deben ser colocados en la placa de la silla de ruedas, para que el aplicativo presentado en los
anexos pueda funcionar correctamente.
Explicación de pines de las tablas 1 y 2 14.1.6
IRQ – se usa para interrumpir las actividades del modulo
VBEN – se usa para iniciar las actividades del modulo
CS – indica cuando la transferencia de datos inicia
MOSI – maneja datos desde un microcontrolador
MISO - y salida de datos al microcontrolador
67
CLOCK - configura la frecuencia a la cual trabaja el modulo
Vin – 5 Voltios
GND - Tierra
M1 <- - controla el giro del motor 1 de la silla de ruedas (hacia la izquierda)
M1 -> - controla el giro del motor 1 de la silla de ruedas (hacia la derecha)
M2 <- - controla el giro del motor 2 de la silla de ruedas (hacia la izquierda)
M2 -> - controla el giro del motor 2 de la silla de ruedas (hacia la derecha)
PWM1 – controla el pwm del motor 1
PWM2 – controla el pwm del motor 2
68
Diagrama de clases del aplicativo Android 14.1.7
Figura 15: Diagrama de clases. Fuente: propia, Paint Con el estilo Enterprise Architect
La Figura 15 presenta el diagrama de clases utilizado en el aplicativo Android, el cual está
dividido en 4 clases principales, MainActivity (Clase principal que captura datos necesarios para
el envío hacia el Arduino que controla la silla de ruedas, en este caso la IP generada por el
69
modulo), la clase voz (que maneja todo lo necesario para capturar datos del módulo de voz del
dispositivo móvil para posteriormente enviarlo a las silla), MainActivity2(que maneja todo lo
relacionado con el envío de la ruta hacia la silla) y la clase MyClientTask (que maneja el envío de
datos en un nuevo hilo, (necesario cuando se realiza programación en Android) , que evita que la
aplicación se congele cuando envía datos).
Explicación de variables 14.1.8
VARIABLE TIPO EXPLICACION
downXValue Float Esta variable captura el valor
del eje X al presionar la
pantalla, para ser una
precisión exacta de donde se
está presionando su valor es
flotante.
Ejemplo: 0.123456789
downYValue Float Esta variable captura el valor
del eje Y al presionar la
pantalla, para ser una
precisión exacta de donde se
está presionando su valor es
flotante.
Ejemplo: 0.123456789
editTextAddress EditText En esta variable es donde se
70
escribirá la IP a la cual se
enviaran los datos, EditText
es un tipo especial de clase
que representa un objeto
capturador de texto en
android
enviar String Variable que guarda el dato
capturado que se va a enviar
a la ip, es de tipo texto.
textResponse TextView Esta variable es utilizada
para las pruebas, en dado
caso el arduino envíe una
respuesta sea cual sea al
dispositivo Android esta
variable imprimirá en
pantalla ese resultado, es de
tipo TextView que representa
un objeto mostrador de texto
en android
bitmap Bitmap Esta variable está relacionada
con el manejo de los objetos
de tipo imagen en Android
canvas Canvas Esta variable está relacionada
71
con el manejo de los objetos
de tipo imagen en Android
VOICE_.... Int Esta variable funciona para
capturar el dato recibido por
el módulo de voz de
Android.
downx float Esta variable captura el valor
del eje X al presionar la
pantalla, para ser una
precisión exacta de donde se
está presionando su valor es
flotante.
Ejemplo: 0.123456789
downy float Esta variable captura el valor
del eje Y al presionar la
pantalla, para ser una
precisión exacta de donde se
está presionando su valor es
flotante.
Ejemplo: 0.123456789
imagenView imagenView Esta variable es un objeto
especial de Android que
representa un panel al cual se
72
le van a dibujar objetos.
paint paint Esta variable es un objeto
especial de Android que
representa un panel al cual se
le van a dibujar objetos.
upx Float Esta variable representa el
cálculo que se hace cuando la
persona que está presionando
la pantalla táctil deja de
presionar, esto se usa para
capturar el eje X
upy float Esta variable representa el
cálculo que se hace cuando la
persona que está presionando
la pantalla táctil deja de
presionar, esto se usa para
capturar el eje Y
dsport int Puerto de la ip al cual se le
va a enviar datos.
dsAddress String La ip a la cual se le va a
enviar un dato.
Tabla 3 Explicación de las variables utilizadas. Fuente Propia
73
Diseño de aplicativo 14.2
Figura 16: Pantalla de inicio de aplicación Android. Fuente: propia.
En la Figura 16 se muestra la pantalla de inicio. El aplicativo movil presenta tres opciones de
control. Trazar ruta, modulo de voz y pantalla tactil, es necesario para cualquiera de las opciones
digitar primero la ip a la cual se le van a enviar los datos.
74
Figura 17: Pantalla de Ruta de la aplicación Android. Fuente: propia.
En la Figura 17, se muestra la parte encargada de la ruta, la pantalla en al cual se puede dibujar
hasta 4 trazos y una casilla de texto que dice Debug, la cual nostrara datos relacionados con el
envio de los datos.
75
Figura 18: Pantalla de voz de la aplicación Android. Fuente: propia.
76
En la pestaña de voz, la aplicación muestra un boton el cual activara el modulo de voz,
permitiento leer el comando que se desea enviar, tambien se muestra un cuadro de texto
“DEBUG”, el cual muestra informacion relacionada con el envio de los datos.Ver Figura 18
Figura 19: Panel de captura de voz dela aplicación Android. Fuente: propia
77
La Figura 19 se muestra cuando se hace click en el boton de voz en la parte de voz del aplicativo.
Las opciones que se pueden enviar son adelante, atrás, izquierda, derecha y detener, cualquier
otro comando no sera enviado.
Figura 20: Pantalla de panel táctil de la aplicación Android. Fuente: propia.
78
En la Figura 20 se peude ver la ventana respectiva para la parte tactil del aplicativo, se pueden
enviar comandos tan solo con dibujar en la pantalla, cuenta con un cuadro de texto “Debug” el
cual muestra informacion relacionada con el envio.
79
Figura 21: Foto silla de ruedas. Fuente: propia.
80
En la Figura 21 se muestra al estudiante Omar Carreño ocupando la silla de ruedas automatizada
conectándose desde su móvil a la Red wifi para controlarla, posterior a esto comienza a generar
datos desde su móvil para que la silla empiece andar.
Etapa de procesamiento 14.3
Figura 22: Panel de control Silla de Ruedas. Fuente: propia.
Para la etapa de procesamiento se utilizó un módulo Arduino, el cc3000 el cual fue configurado
para recibir y procesar los comandos posteriormente enviados para generar el movimiento de la
silla, según el comando recibido se procede a determinar las señales enviadas al circuito de
potencia.
El circuito de potencia está conformado por 4 relés (12V – 40 Amp), encargados de polarizar los
motores de acuerdo a las órdenes enviadas por el módulo. El PWM se calibra automáticamente
para conmutar los motores y poder controlar la velocidad de éstos. Esta etapa es robusta debido a
Breaker- Protección del sistema
Controlador de carga
Puente H-PWM
Tarjeta de distribución
Arduino - Microcontrolador
Módulo Arduino CC3000
81
la cantidad de corriente que se maneja. Los terminales que tienen polarización son los que
proveen la energía al circuito de una batería de 12V, 600 Ah. Los terminales que sobran son los
que controlan la activación del circuito puente H.
82
15 Pruebas
Prueba Funcional: Panel Táctil, ruta, voz
Elaborado por:
Omar Carreño
Identificador:
Objetivo
Mostrar el funcionamiento del aplicativo enviado datos y la recepción de estos
por parte del modulo
ITEM Se
cumple:
SI / NO
Observaciones
1. Se logró la conexión del módulo a la red
SI Es necesario que el modulo esté conectado a una
red que no tenga proxys ya que puede influir en
los envíos de datos. Ver Figura 23
2. Envió de comando “Adelante” desde el
aplicativo.
SI Es necesario que el aplicativo esté conectado a
la misma red a la que está conectada el modulo
y digitar la IP del mismo en la interface de
Android. El comando adelante, está
representado por la letra w. Ver Figura 24
83
3. Envió de comando “izquierda” desde el
aplicativo.
SI Es necesario que el aplicativo esté conectado a
la misma red a la que está conectada el modulo
y digitar la IP del mismo en la interface de
Android. El comando “izquierda”, está
representado por la letra a. Ver Figura 25
4. Envío de comando “atrás” desde el
aplicativo.
SI Es necesario que el aplicativo esté conectado a
la misma red a la que está conectada el modulo
y digitar la IP del mismo en la interface de
Android. El comando atrás, está representado
por la letra s. Ver Figura 28
5. Envío de comando “derecha” desde el
aplicativo.
SI
Es necesario que el aplicativo esté conectado a
la misma red a la que está conectada el modulo
y digitar la IP del mismo en la interface de
Android. El comando derecha, está representado
por la letra d. Ver Figura 26.
6. Envío de comando “detener” desde el
aplicativo.
SI Es necesario que el aplicativo esté conectado a
la misma red a la que está conectada el modulo
y digitar la IP del mismo en la interface de
Android. El comando detener, está representado
por la letra m. Ver Figura 27.
84
7. Recepción de comandos
SI Se presenta un inconveniente al recibir los datos
por parte del módulo, puesto que este tarda
cierto tiempo para responder y ejecutar los
comandos, esto puede ser debido a la red wifi a
la que esté conectado. Ver figura 29
Ver Figura 23.
Tabla 4 Tabla de pruebas. Fuente Propia
Figura 23: Verificación de la conexión del módulo wifi en la interface de Arduino. Fuente: Propia
85
Figura 24: Envío de comando adelante por parte del aplicativo. Fuente: Propia
86
Figura 25: Envío de comando izquierda por parte del aplicativo. Fuente: Propia
87
Figura 26: Envío de comando derecha por parte del aplicativo. Fuente: Propia
88
Figura 27: Envío de comando detener por parte del aplicativo. Fuente: Propia
89
Figura 28: Envío de comando atrás por parte del aplicativo. Fuente: Propia
90
Figura 29: Recepción de los comandos. Fuente: Propia
Figura 30: Mapas de pruebas. Fuente: Propia
En la Figura 30 se representa el mapa de las pruebas realizadas en un ambiente controlado cual
está representado de color verde en todas las etapas, el color azul representa el movimiento
esperado, y el color rojo el movimiento realizado por la silla. En las tablas 5, 6, 7 se pueden
observar los valores obtenidos en las pruebas.
91
Los datos de las pruebas realizadas en el método de control de ruta pueden verse reflejadas en la
tabla 5 las cuales fueron realizadas en un espacio abierto delimitado en de 18 x 22,8 metros.
Los datos de las pruebas realizadas en el método de control por comando de voz pueden verse
reflejadas en la tabla 6 las cuales fueron realizadas en un espacio abierto delimitado en de 18 x
22,2 metros.
Los datos de las pruebas realizadas en el método de control por pantalla táctil pueden verse
reflejadas en la tabla 7 las cuales fueron realizadas en un espacio abierto delimitado en de 18 x
22,8 metros.
En el mapa número 1 de la figura 32 se describe el movimiento realizado por la silla de ruedas
utilizando el método de control ruta definida en este se trazó una ruta en el aplicativo
representada en la figura 31, como se puede observar en la figura 30 mapa 1 los tramos
v hasta w se presentó un desvió aproximado de 5°, w hasta x se presentó un desvío aproximado
de 4,5° , de x hasta y se presentó un desvió aproximado de 10° , de y hasta z presento un desvío
de 15°, estos desvíos se deben a que el sistema de la silla de ruedas cuenta con dos motores los
cuales van a velocidades distintas, también varía por la carga sé que tenga en la batería al
momento de arrancar, también es debido a que en este proyecto no se implementó odometría, por
lo cual el sistema no sabe realmente como se debe ubicar en el espacio. En el aplicativo el diseño
de ruta ya viene previamente diseñado para esperar cierto tiempo entre los comandos. En los
cuales 3 segundos representan 3 metros, los trazos realizados en la pantalla son independientes de
su distancia, esto quiere decir que no importa el tamaño del trazo realizado siempre va
representar el mismo tiempo de envío.
92
Tramo Distancia Esperado Realizado
De a hasta b 3 metros x
De b hasta c 4,2 metros x
De c hasta d 3,6 metros x
De d hasta e 4,2 metros x
De v hasta w 4,8 metros x
De w hasta x 5,4 metros x
De x hasta y 3,6 metros x
De y hasta z 5,4 metros x
Tabla 5 Detalles del mapa N1, por pantalla ruta. Fuente: Propia
93
Figura 31: Ruta definida en el aplicativo desde el dispositivo móvil. Fuente: Propia
94
En el mapa número 2 de la figura 30 se describe el movimiento realizado por la silla de ruedas
utilizando el método de control por voz en este se trazó una ruta en el aplicativo representada en
la figura 32, como se puede observar en la figura 30 mapa 2 los tramos
v hasta w se presentó un desvió aproximado de 4°, w hasta x se presentó un desvío aproximado
de 8° , de x hasta y se presentó un desvió aproximado de 5° , de y hasta z presento un desvío de
7°, estos desvíos se deben a que el sistema de la silla de ruedas cuenta con dos motores los cuales
van a velocidades distintas, también varía por la carga sé que tenga en la batería al momento de
arrancar, también es debido a que en este proyecto no se implementó odometría, por lo cual el
sistema no sabe realmente como se debe ubicar en el espacio. Se enviaron datos desde el
aplicativo con tiempo intermedio de 3 segundos. Los cuales representaron aproximadamente 6
metros.
Tramo Distancia Esperado Realizado
De a hasta b 6,6 metros X
De b hasta c 6,6 metros X
De c hasta d 6,6 metros X
De d hasta e 6 metros X
De v hasta w 8,4 metros x
De w hasta x 8,4 metros x
De x hasta y 9 metros x
De y hasta z 10,5 metros x
Tabla 6 Detalles del mapa N2, por comando de voz. Fuente: Propia
95
Figura 32: Ruta definida por comando en el aplicativo desde el dispositivo móvil. Fuente: Propia
96
En el mapa número 3 de la figura 30 se describe el movimiento realizado por la silla de ruedas
utilizando el método de control por panel táctil en este se trazó una ruta en el aplicativo
representada en la figura 33, como se puede observar en la figura 30 mapa 1 los tramos:
De v hasta w se presentó un desvió aproximado de 10°, w hasta x se presentó un desvío
aproximado de 10° , de x hasta y se presentó un desvió aproximado de 5° , de y hasta z presento
un desvío de 5°,como logra apreciar los grados desvíos en los dos primeros tramos se deben a que
van en la misma dirección y sentido, lo mismo pasa en los siguientes dos tramos, dichos desvíos
se deben a que el sistema de la silla de ruedas cuenta con dos motores, los cuales van a
velocidades distintas, también varía por la carga sé que tenga en la batería al momento de
arranca. En el aplicativo, mantener presionada la pantalla 3 segundos representa
aproximadamente 3 metros.
Tramo Distancia Esperado Realizado
De a hasta b 4,2 metros x
De b hasta c 5,4 metros x
De c hasta d 5,4 metros x
De d hasta e 5,4 metros x
De v hasta w 7,2 metros x
De w hasta x 6,2 metros x
De x hasta y 6 metros x
De y hasta z 6,6 metros x
Tabla 7 Detalles del mapa N3, panel táctil. Fuente: Propia
97
Figura 33: Ruta definida por pantalla táctil en el aplicativo desde el dispositivo móvil. Fuente: Propia
98
La ruta esperada se marcó en el suelo del espacio donde se realizaron las pruebas lo que hace
más precisa la obtención de los datos de desvío. El tiempo especificado en cada una de las
pruebas es diferente, es decir, equivalen a distancias diferentes las cuales están representadas en
cada una de las pruebas.
Es de resaltar que en todas las pruebas realizadas el recorrido de la silla se desplazó más de lo
indicado en todos los tramos, esto es debido al tiempo que hay entre los envíos y la recepción de
datos, hacen parte también en este margen de desvíos de la silla de ruedas otros factores ajenos al
aplicativo y a la odometría, como por ejemplo:
1) La cantidad de presión de aire que posee cada llanta.
2) La alineación de las llantas y lubricación de las mismas.
99
16 Nuevos aportes y controversias conceptuales
Tras investigaciones realizadas en este proyecto se optó por utilizar la red WIFI con módulos
Arduino para la conexión de la aplicación con la silla de ruedas, esto con el fin de utilizar la silla,
no solo en el mismo entorno en donde este se encuentre, si no en cualquier parte del mundo que
cuente con acceso a la red donde está esta, una amplia gama de dispositivos tienen conexión a
WIFI lo cual permite que cualquiera, sea celular, tablets, computador, módulo Arduino o
cualquier otro dispositivo pueda controlar la silla.
Como aporte se agregó el componente Arduino con el fin de reducir los costos al momento de
la creación de la silla y la fácil utilización de este y sus módulos acoplables para facilitar los
futuros proyectos, se resalta también el uso de dispositivos móviles, planteando distintas formas
de control en un mismo dispositivo pensando en los diferentes tipos de incapacidad y en la
facilidad de uso por parte del usuario.
100
17 Descripción de las dificultades y las estrategias para confrontarlas creativamente
Dificultades 17.1
1) Desconfiguración del módulo cc3000.
2) Alcance de la señal.
3) Recepción de datos.
4) Perdida de datos.
5) Desconexión inesperada del módulo cc3000.
Soluciones 17.2
1) Para solucionar el inconveniente de la desfiguración del módulo se crearon clases de
configuración las cuales, el Arduino al detectar una desconexión de la red, procede a
reconfigurar con los patrones establecidos al módulo cc3000, esto se realza en la etapa de
recepción de datos (Ver Figura 13)
2) Existen diferentes soluciones planteadas para dar solución al alcance del módulo:
1.1) Dotar al módulo CC3000 con una antena de mayor potencia, eso ampliara el
alcance del módulo para recepción de señal wifi
1.2) Mantener cerca el modulo cerca del alcance del receptor de señal wifi.
1.3) Mantener la aplicación móvil cerca del alcance del receptor de señal wifi.
3) Para la solución al problema de recepción de datos se plantean diferentes soluciones:
101
1.1) Mantener tanto el modulo como el aplicativo al alcance de la señal wifi.
1.2) Solo conectar 1 aplicativo al momento de usar la silla de ruedas.
4) Para evitar perder la mayor cantidad de datos es necesario que la red a la cual se están
conectando tanto el modulo como el aplicativo esté libre de cualquier configuración tal
como proxys que dificultan la comunicación directa entre dos equipos dentro de la red
wifi.
102
18 Conclusiones y recomendaciones
Conclusiones 18.1
En este trabajo se manejó el sistema de envió de datos a través de un dispositivo móvil, el cuales
sirvió para desarrollar un aplicativo en Android para gobernar unos motores dc y así mejorar el
estilo de vida de la población con movilidad reducida.
El móvil cada día hace parte fundamental en la sociedad actual, por eso se necesitan más
desarrollos en donde se vean involucrados dispositivos móviles, ya que estos brindan un aporte
de comodidad por su fácil uso.
El PWM es un sistema de regulación de motores muy efectivo si se utilizan frecuencias altas se
puede evitar las corrientes de arranque grandes, por esa razón en la industria utilizan los
variadores de motor en corriente alterna.
La conectividad radica en los módulos utilizados para comunicar el aplicativo con la silla, se optó
por utilizar el WIFI, porque no se limita a un rango de distancia, cualquier persona puede acceder
desde cualquier parte del mundo a la silla, pero para problemas más específicos se podrían
utilizar módulos de conexión como lo son el bluetooth o el uso de los infrarrojos.
Con conocimientos básicos de programación se pueden logar diferentes maneras de solucionar el
problema integrando distintas carreras.
La conexión con el módulo WIFI Arduino cc3000 presento problemas de conectividad, los datos
enviados desde cualquier dispositivo (PC, MOVIL) no fueron recibidos en un 100%, esto puede
deberse a múltiples cuestiones, las principales tales como, distancia del dispositivo al punto de
103
conexión WIFI, la configuración del router o modulo que provee de WIFI al módulo, esta última
puede bloquear la comunicación directa con el modulo.
Recomendaciones 18.2
Se recomienda no utilizar el sistema en una versión anterior a Android 4.0 ya que las librerías
podrían no funcionar adecuadamente, dado que se programó específicamente para esta versión.
Se recomienda mejorar el sistema mecánico para futuras aplicaciones.
Se recomienda mantener cerca el punto de conexión WIFI al módulo y al aplicativo.
No superar los 100kg en la silla de ruedas, para no dañar los motores.
104
19 Anexos
Código Arduino para el control de la silla de ruedas. 19.1
/*-------------------------------------------------------------------------------------------------------
En esta sección del código se incluyen todas las variables necesarias para que el proyecto pueda
Funcionar y la inicialización esta, con los valores predeterminados por aquel que quiera hacer
Réplica del código.
-------------------------------------------------------------------------------------------------------*/
#include <Adafruit_CC3000.h> // Se adicionan las librerías para manejar el modulo
#include <sensores.h>
#include <SPI.h>
#include "utility/debug.h"
#include "utility/socket.h"
// Estos son los interruptores y el control de los pines del módulo cc3000
#define ADAFRUIT_CC3000_IRQ 3
#define ADAFRUIT_CC3000_VBAT 5
#define ADAFRUIT_CC3000_CS 10
//se inicia el objeto de la clase cc3000 del módulo para poder utilizarlo.
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS,
ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT,
SPI_CLOCK_DIV2);
// Las variables WLAN configuran la conexión al wifi, se deben especificar el id del wifi la
contraseña y el tipo de seguridad
#define WLAN_SSID "OMAR WIFI"
105
#define WLAN_PASS "123456789"
#define WLAN_SECURITY WLAN_SEC_WPA2
#define LISTEN_PORT 7 // Cual es el puerto por donde van a entrar los datos, el puerto
para imprimir datos es el 7
Adafruit_CC3000_Server server(LISTEN_PORT); //Se le dice al módulo que utilice ese puerto
uint8_t ch; // Esta variable guarda los datos recibidos por el aplicativo
int
Avanzar_M1=2,Retroceder_M1=7,PWM_M1=9,Avanzar_M2=4,Retroceder_M2=8,PWM_M2=
13; // Estas variables controlan los motores, se deben especificar cuáles pines del Arduino
// Controlan que motores
Motor
M1(Avanzar_M1,Retroceder_M1,PWM_M1),M2(Avanzar_M2,Retroceder_M2,PWM_M2);//
para poder utilizarlos se inicializa el objeto que controla los motores.
/*
-------------------------------------------------------------------------------------------------------
Configuración inicial
En esta sección se da inicio al a configuración de las variables, se inicia el módulo cc3000 y
configura para que esté dispuesto a recibir datos
-------------------------------------------------------------------------------------------------------
*/
void setup() {
delay(500);//En toda etapa del código que se utilice delay , le dirá al Arduino que debe esperar.
Serial.begin(115200);// El cc3000 trabaja con una velocidad para poder imprimir en el puerto
serial del arduino de 115200
106
Serial.println(F("nInitializing..."));
if (!cc3000.begin()) //Se inicia el modulo
{
Serial.println(F("Couldn't begin()! Check your wiring?"));
while (1);
}
Serial.println(F("\nDeleting old connection profiles"));
if (!cc3000.deleteProfiles()) { // Si existe una configuración guardada anterior de una red wifi se
elimina para evitar inconvenientes
Serial.println(F("Failed!"));
while(1);
}
listSSIDResults(); // Se imprimen la lista de redes de wifi disponibles, esto no es necesario pero
se utiliza para verificar la cantidad de señal
Serial.println(F("INTENTANDO CONECTAR"));
if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) {// Se intenta
conectar a la red wifi definida anteriormente
Serial.println(F("Failed!"));
while (1);
}
Serial.println(F("Connected!"));
Serial.println(F("Request DHCP"));
while (!cc3000.checkDHCP()) // Se verifica cuáles son los datos dados por la red wifi, la ip, la
máscara.
{
delay(100);
}
while (! displayConnectionDetails()) { // Se imprimien los detalles de la conexion
delay(1000);
}
107
// El módulo cc3000 comienza a recibir datos.
server.begin();
Serial.println(F("Listening for connections..."));
}
int a = 0;
/*
-------------------------------------------------------------------------------------------------------
Ejecución de código:
Una vez el módulo cc3000 este configurado este procederá a esperar datos de cualquier fuente
que pueda enviarlos, ejecutando comandos programados, (w- arriba, s- abajo, a- izquierda, d-
derecha) y no ejecutando nada cuando se le envía otro tipo de comando diferente.
-------------------------------------------------------------------------------------------------------
*/
void loop() {
// Se espera a que un cliente esté conectado
Adafruit_CC3000_ClientRef client = server.available();
if (client) { // Si está conectado un cliente se procede a verificar que dato se está recibiendo
Serial.println("Conectado");
if (client.available() > 0) { // Se verifica si se envio un dato
ch = client.read(); // Se lee que dato fue enviado
switch (ch) { // Dependiendo del dato enviado se procede a realizar una acción : a-izquierda , s -
atrás , d-derecha, w-adelante , m-detener , u -gira derecha j- gira izquierda k-gira abajo l-gira
arriba
case 'a':
108
Serial.println("a");
Serial.println("izquierda");
M1.Retroceder(a);
M2.Avanzar(a);
break;
case 's':
Serial.println("s");
Serial.println("ABAJO");
M1.Retroceder(a);
M2.Retroceder(a);
break;
case 'd':
Serial.println("d");
Serial.println("derecha");
M1.Avanzar(a);
M2.Retroceder(a);
break;
case 'w':
Serial.println("w");
Serial.println("adelante");
M1.Avanzar(a);
M2.Avanzar(a);
break;
case 'm':
109
Serial.println("detener");
M1.Detener();
M2.Detener();
break;
case 'u':
gira_der();//gira derecha
break;
case 'j':
gira_izq(); // gira izquierda
break;
case 'k':
gira_der(); // gira abajo
break;
case 'l':
gira_der(); // gira arriba
break;
}
}else {
Serial.println("NO CONECTADO");
}
110
}
restartWifi();
}
bool displayConnectionDetails(void) // Esta función imprime los detalles de la conexión wifi
{
uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv;
if (!cc3000.getIPAddress(&ipAddress, &netmask, &gateway, &dhcpserv, &dnsserv))
{
Serial.println(F("Unable to retrieve the IP Address!rn"));
return false;
}
else
{
Serial.print(F("nIP Addr: ")); cc3000.printIPdotsRev(ipAddress);
Serial.print(F("nNetmask: ")); cc3000.printIPdotsRev(netmask);
Serial.print(F("nGateway: ")); cc3000.printIPdotsRev(gateway);
Serial.print(F("nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
Serial.print(F("nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.println();
return true;
}
}
void gira_der() // Esta función controla el giro a la derecha
{
111
M1.Avanzar(a);
M2.Retroceder(a);
delay(2000);
M1.Avanzar(a);
M1.Avanzar(a);
}
/*Función, girar a la izquierda*/
void gira_izq()
{
M1.Retroceder(a);
M2.Avanzar(a);
delay(2000);
M1.Avanzar(a);
M1.Avanzar(a);
}
void listSSIDResults(void) // Esta función verifica cuales son los puntos wifi a las que el modulo
puede conectarce
{
uint32_t index;
uint8_t valid, rssi, sec;
char ssidname[33];
if (!cc3000.startSSIDscan(&index)) {
Serial.println(F("SSID scan failed!"));
return;
}
Serial.print(F("Networks found: ")); Serial.println(index);
112
Serial.println(F("================================================"));
while (index) {
index--;
valid = cc3000.getNextSSID(&rssi, &sec, ssidname);
Serial.print(F("SSID Name : ")); Serial.print(ssidname);
Serial.println();
Serial.print(F("RSSI : "));
Serial.println(rssi);
Serial.print(F("Security Mode: "));
Serial.println(sec);
Serial.println();
}
Serial.println(F("================================================"));
cc3000.stopSSIDscan();
}
void restartWifi() { // Esta función controla si se a desconectado de la red indicada e intenta
conectar nuevamente
while (cc3000.getStatus() != STATUS_CONNECTED) {
Serial.println(F(""));
Serial.print(F("Disconnected from "));
Serial.print(F(WLAN_SSID));
Serial.println(F(" network!"));
Serial.println(F(""));
Serial.print(F("Attempting to reconnect to "));
Serial.print(F(WLAN_SSID));
113
Serial.println(F(" ..."));
cc3000.reboot();
if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) {
while (1);
}
while (!cc3000.checkDHCP()) {
delay(100);
}
Serial.println();
while (!displayConnectionDetails()) {
delay(500);
}
restartWifi();
}
}
Código Arduino neurona 19.2
/*
-------------------------------------------------------------------------------------------------------
Importe de librerías utilizadas
-------------------------------------------------------------------------------------------------------
*/
114
#include <math.h>
/*
-------------------------------------------------------------------------------------------------------
Creación de variables que se utilizan para poner en funcionamiento la neurona.
-------------------------------------------------------------------------------------------------------
*/
//primera etapa
double PsiR;
double Psi;
double b1;
double w11;
double w12;
//segunda etapa
double w21;
double w22;
115
double b21;
double b22;
//tercera etapa
double w31;
double w32;
double b31;
double b32;
//salida
double w41;
double w42;
double b4;
double b5;
double b6;
/*
-------------------------------------------------------------------------------------------------------
Configuración de los pesos según el diseño de la neurona
-------------------------------------------------------------------------------------------------------
*/
void setup() {
116
// pesos iniciales
Serial.begin(9600);
//primera etapa
PsiR=127.5;
Psi=0;
b1=0;
w11=1;
w12=1;
//segunda etapa
w21=0.4;
w22=0.2;
b21=-2;
b22=10;
//tercera etapa
w31=-45;
w32=-45;
b31=0;
b32=45;
//salida
w41=1;
w42=1;
b4=87;
b5=87;
b6=87;
117
pinMode(4, OUTPUT);
}
void loop() {
//varias los pesos por ciclo y llamar funcion final
Serial.println(capaSalida());
}
/*
-------------------------------------------------------------------------------------------------------
Métodos por los cuales la neurona funciona
-------------------------------------------------------------------------------------------------------
*/
int hardlim(double n){
if(n<0){
return 0;
}else if(n>=0){
return 1;
}
118
}
int hardlims(double n){
if(n<0){
return -1;
}
if(n>=0){
return 1;
}
}
double purelin(double n){
return n;
}
double satlin(double n){
if(n<0){
return 0;
}
if(0<=n && n<=1){
return n;
}
if( n>0 ){
return 1;
}
}
119
double satlins ( double n ){
if(n<-1){
return -1;
}
if(-1<=n && n<=1){
return n;
}
if(n>1){
return 1;
}
}
double logsig(double n){
return 1/(1+exp(-n)) ;
}
double tansig(double n){
return (exp (n) - exp (-n)) / (exp (n)+exp (-n) ) ;
}
double poslin(double n){
if(n<0){
return 0;
}
120
if(0<=n){
return n;
}
}
/*
-------------------------------------------------------------------------------------------------------
Métodos utilizados en las capas de la neurona según el diseño presentado
-------------------------------------------------------------------------------------------------------
*/
double primeraCapa(){ // primera capa del diseño de la neurona
double primero = PsiR*w11;
double segundo = Psi*w12;
return purelin(primero+segundo+b1);
}
double segundaCapa1(){ // segunda capa parte a del diseño de la neurona
121
return logsig((primeraCapa()*w21)+b21);
}
double segundaCapa2(){ // segunda capa parte b del diseño de la neurona
return logsig((primeraCapa()*w22)+b22);
}
double terceraCapa1(){// tercera capa parte a del diseño de la neurona
return purelin((segundaCapa1()*w31)+b31);
}
double terceraCapa2(){ // tercera capa parte b del diseño de la neurona
return purelin((segundaCapa2()*w32)+b32);
}
double capaSalida(){// capa de salida del diseño de la neurona
return purelin(((terceraCapa1()*w41)+b5)+((terceraCapa2()*w42)+b6)+b4);
}
Código Android 19.3
MainActivity.java (ENVIO POR PANTALLA TACTIL) 19.3.1
package semillero.ucc.edu.co.wheelchair;
// Se importan todas las librerias necesarias para poder utilizar el aplicativo
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.widget.EditText;
122
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
public class MainActivity extends AppCompatActivity {
String enviar =""; // esta variable guarda que dato se esta enviando
private float downXValue;
private float downYValue;
private EditText editTextAddress;
@Override
protected void onCreate(Bundle savedInstanceState) {//este metodo es utilizado por android
para inicializar las variables al momento de abrir una activity
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
editTextAddress= (EditText)findViewById(R.id.address);
}
@Override
public boolean onTouchEvent(MotionEvent event) {//este metodo captura los datos recibidos al
presionar la pantalla y ejecuta una accion.
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN: { // esta function guarda el valor de x al momento
que el dedo presiona la pantalla
downXValue = event.getX();
downYValue = event.getY();
break;
}
case MotionEvent.ACTION_UP:{
// esta envia el valor al momento en que se levanta el dedo de la pantalla
if(enviar!="m") {
Log.v("", "stop");
enviar = "m";
MyClientTask myClientTask = new
MyClientTask(editTextAddress.getText().toString(),enviar);
myClientTask.execute();
}
}
case MotionEvent.ACTION_MOVE: { //captura el valor cuando se mueve el dedo por la
123
pantalla y hacienda unos calculus verifica hascia donde se movio
float currentX = event.getX();
float currentY = event.getY();
if (Math.abs(downXValue - currentX) > Math.abs(downYValue
- currentY)) {
// going backwards: pushing stuff to the right
if (downXValue < currentX) {
if(enviar!="d") {
Log.v("", "right");
enviar = "d";
MyClientTask myClientTask = new
MyClientTask(editTextAddress.getText().toString(),enviar);
myClientTask.execute();
}
}
// going forwards: pushing stuff to the left
if (downXValue > currentX) {
if (enviar != "a"){
Log.v("", "left");
enviar = "a";
MyClientTask myClientTask = new
MyClientTask(editTextAddress.getText().toString(),enviar);
myClientTask.execute();
}
}
} else {
if (downYValue < currentY) {
if(enviar!="s") {
Log.v("", "down");
enviar = "s";
MyClientTask myClientTask = new
MyClientTask(editTextAddress.getText().toString(),enviar);
myClientTask.execute();
}
}
if (downYValue > currentY) {
if(enviar!="w") {
Log.v("", "up");
enviar = "w";
MyClientTask myClientTask = new
124
MyClientTask(editTextAddress.getText().toString(),enviar);
myClientTask.execute();
}
}
}
break;
}
}
return true;
}
public class MyClientTask extends AsyncTask<Void, Void, Void> {//esta es la funcion que
envia los datos al modulo cc3000
String Data = "";
String ip="";
MyClientTask(String Ip, String data){
Data = data;
ip = Ip;
}
@Override
protected Void doInBackground(Void... arg0) {
Socket socket = null;
try {
socket = new Socket(ip, 7);
PrintWriter salida = new PrintWriter(new
OutputStreamWriter(socket.getOutputStream()),true);
Log.d("enviado",Data);
salida.println(Data);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
Log.d("UnknownHostException: " , e.toString());
} finally{
if(socket != null){
try {
socket.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
125
}
return null;
}
@Override
protected void onPostExecute(Void result) {
super.onPostExecute(result);
}
}
public void Voz(View v){//active la activity vo
Intent intent = new Intent(MainActivity.this,voz.class);
startActivity(intent);
}
public void preder(View v){ //active la activity ruta
Intent intent = new Intent(MainActivity.this,Main2Activity.class);
startActivity(intent);
}
}
Main2Activity.java (ENVIO DE RUTA) 19.3.2
package semillero.ucc.edu.co.wheelchair;
//se importan las librerias
import android.app.Activity;
import android.app.ProgressDialog;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.Display;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.widget.EditText;
import android.widget.ImageView;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
126
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
public class Main2Activity extends Activity implements OnTouchListener {
//se inician las variables que se utilizan
ImageView imageView; //controla la pantalla que va a realizar el dibujo
String enviar ="";//guarda el dato que se va a enviar
Bitmap bitmap;//variable relacionada con las imagenes
Canvas canvas;//variable relacionada con las imagenes
Paint paint; ;//variable relacionada con las imagenes
float downx = 0, downy = 0, upx = 0, upy = 0;
String[] datos = new String[4];
String[] envio = new String[5];
EditText editTextAddress;
int pos = 0;
private ProgressDialog p = null;
@Override
public void onCreate(Bundle savedInstanceState) {
// al momento de iniciar la activity se inicializan todas las variables necesarias para la ejecucion
del codigo.
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main2);
editTextAddress = (EditText)findViewById(R.id.address);
imageView = (ImageView) this.findViewById(R.id.imageView);
Display currentDisplay = getWindowManager().getDefaultDisplay();
float dw = currentDisplay.getWidth();
float dh = currentDisplay.getHeight();
bitmap = Bitmap.createBitmap((int) dw, (int) dh,
Bitmap.Config.ARGB_8888);
canvas = new Canvas(bitmap);
paint = new Paint();
paint.setColor(Color.GREEN);
imageView.setImageBitmap(bitmap);
imageView.setOnTouchListener(this);
}
//esta funcion controla los datos capturados por la pantalla tactil y procede a enviarlos segun las
especificaciones del programa
public boolean onTouch(View v, MotionEvent event) {
if (pos < 4){
int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
downx = event.getX();
downy = event.getY();
127
break;
case MotionEvent.ACTION_MOVE:
break;
case MotionEvent.ACTION_UP:
upx = event.getX();
upy = event.getY();
canvas.drawLine(downx, downy, upx, upy, paint);
imageView.invalidate();
if (Math.abs(downx - upx) > Math.abs(downy
- upy)) {
if (downx < upx) {
Log.v("", "right");
enviar = "d";
// MyClientTask myClientTask = new
MyClientTask(editTextAddress.getText().toString());
// myClientTask.execute();
datos[pos] = "d";
pos++;
}
// going forwards: pushing stuff to the left
if (downx > upx) {
Log.v("", "left");
enviar = "a";
// MyClientTask myClientTask = new
MyClientTask(editTextAddress.getText().toString());
// myClientTask.execute();
datos[pos] = "a";
pos++;
}
} else {
Log.v("", "y ");
if (downy < upy) {
Log.v("", "down");
enviar = "s";
// MyClientTask myClientTask = new
MyClientTask(editTextAddress.getText().toString());
// myClientTask.execute();
datos[pos] = "s";
pos++;
}
if (downy > upy) {
128
Log.v("", "up");
enviar = "w";
// MyClientTask myClientTask = new
MyClientTask(editTextAddress.getText().toString());
// myClientTask.execute();
datos[pos] = "w";
pos++;
}
}
break;
case MotionEvent.ACTION_CANCEL:
break;
default:
break;
}
}else if(pos>=4) {
Log.v("enviando", "true");
int x=0;
envio[x]=datos[0];
for (int i=0;i<datos.length-1;i++){
x++;
if((datos[i]=="a"||datos[i]=="d") && (datos[i+1]=="w"||datos[i+1]=="s")){
if(datos[i+1]=="w"){
envio[x]="o";
}else if(datos[i+1]=="s"){
envio[x]="i";
}
}
if((datos[i]=="w"||datos[i]=="s") && (datos[i+1]=="a"||datos[i+1]=="d")){
if(datos[i+1]=="a"){
envio[x]="u";
}else if(datos[i+1]=="d"){
envio[x]="y";
}
}
if(datos[i]==datos[i+1]){
envio[x]=datos[i];
}
}
envio[4]="m";
MyClientTask myClientTask = new
129
MyClientTask(editTextAddress.getText().toString(),envio);
myClientTask.execute();
}
return true;
}
//este metodo envia los datos capturados.
public class MyClientTask extends AsyncTask<Void, Void, Void> {
String dstAddress;
int dstPort;
String response = "";
String enviar ="";
String envio[] = null;
MyClientTask(String addr,String env){
dstAddress = addr;
dstPort = 7;
enviar = env;
}
public MyClientTask(String addr, String[] Envio) {
dstAddress = addr;
envio = Envio;
}
@Override
protected Void doInBackground(Void... arg0) {
Socket socket = null;
try {
socket = new Socket(dstAddress,dstPort);
PrintWriter salida = new PrintWriter(new
OutputStreamWriter(socket.getOutputStream()),true);
Log.d("enviado", enviar);
for (int i=0;i<envio.length-1;i++){
try {
Thread.sleep(1000);
salida.println(envio[i]);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
130
BufferedReader in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
String response = in.readLine();
Log.d("respuesta del server", response);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
Log.d("UnknownHostException: " , e.toString());
} finally{
if(socket != null){
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return null;
}
@Override
protected void onPostExecute(Void result) {
super.onPostExecute(result);
}
}
}
Voz.java (ENVIO POR VOZ) 19.3.3
package semillero.ucc.edu.co.wheelchair;
//se importan las liberias que se van a utilizar
import android.app.Activity;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.speech.RecognizerIntent;
import android.util.Log;
131
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
public class voz extends Activity {
private static final int VOICE_RECOGNITION_REQUEST_CODE = 1;
// esta variable controla el metodo de reconocimiento de voz
TextView textResponse;//esta variable controla los datos enviados y los muestra en pantalla
EditText editTextAddress; // captura la ip a la que se le va a enviar
String enviar ="";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_voz);
editTextAddress = (EditText)findViewById(R.id.address);
textResponse = (TextView)findViewById(R.id.response);
}
public class MyClientTask extends AsyncTask<Void, Void, Void> {
//este metodo controla el envio de datos.
String dstAddress;
int dstPort;
String response = "";
MyClientTask(String addr, int port){
dstAddress = addr;
dstPort = port;
}
@Override
protected Void doInBackground(Void... arg0) {
Socket socket = null;
try {
socket = new Socket(dstAddress,dstPort);
132
PrintWriter salida = new PrintWriter(new
OutputStreamWriter(socket.getOutputStream()),true);
Log.d("enviado",enviar);
salida.println(enviar);
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
Log.d("UnknownHostException: " , e.toString());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
Log.d("IOException: " ,e.toString());
}finally{
if(socket != null){
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return null;
}
@Override
protected void onPostExecute(Void result) {
textResponse.setText(response);
super.onPostExecute(result);
}
}
public void voz(View v){
Log.d("iniciando voz","Iniciando reconocimiento de voz");
startVoiceRecognitionActivity();
}
private void startVoiceRecognitionActivity() {
Log.d("iniciando","Iniciando reconocimiento de voz");
// Definición del intent para realizar en análisis del mensaje
Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
// Indicamos el modelo de lenguaje para el intent
intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
// Definimos el mensaje que aparecerá
133
intent.putExtra(RecognizerIntent.EXTRA_PROMPT,"Diga la opcion que quiere enviar
(adelante, atras,izquierda,derecha,detener");
// Lanzamos la actividad esperando resultados
startActivityForResult(intent, VOICE_RECOGNITION_REQUEST_CODE);
}
@Override
//Recogemos los resultados del reconocimiento de voz
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
//este método controla los datos recibidos al hablarle al celular
//Si el reconocimiento a sido bueno
if(requestCode == VOICE_RECOGNITION_REQUEST_CODE && resultCode ==
RESULT_OK){
//El intent nos envia un ArrayList aunque en este caso solo
//utilizaremos la pos.0
ArrayList<String> matches = data.getStringArrayListExtra
(RecognizerIntent.EXTRA_RESULTS);
//Separo el texto en palabras.
String [ ] palabras = matches.get(0).toString().split(" ");
//Si la primera palabra esta entre las variables aceptadas se procede a enviarla
if(palabras[0].equals("adelante")){
enviar = "w";
MyClientTask myClientTask = new MyClientTask(
editTextAddress.getText().toString(),7);
myClientTask.execute();
}else if(palabras[0].equals("atras")){
enviar = "s";
MyClientTask myClientTask = new MyClientTask(
editTextAddress.getText().toString(),7);
myClientTask.execute();
}else if(palabras[0].equals("derecha")){
enviar = "a";
MyClientTask myClientTask = new MyClientTask(
editTextAddress.getText().toString(),7);
myClientTask.execute();
}else if(palabras[0].equals("izquierda")){
enviar = "d";
MyClientTask myClientTask = new MyClientTask(
editTextAddress.getText().toString(),7);
myClientTask.execute();
}else if(palabras[0].equals("detener")){
enviar = "m";
MyClientTask myClientTask = new MyClientTask(
editTextAddress.getText().toString(),7);
myClientTask.execute();
}
134
}
}
}
135
Diagrama de flujo Código Arduino 19.4
136
137
138
Proyecto App Silla de Ruedas 19.5
Organización 19.5.1
Organización Universidad Cooperativa de Colombia
Dirección Carretera Troncal del Caribe Sector Mamatoco
Teléfono (57) (5) 432 69 10
Fax PD
Comentarios Ninguno
139
Participantes 19.6
Participante Sergio Andrés Guerrero Palencia
Organización Universidad Cooperativa de Colombia
Rol Estudiante
Es desarrollador Sí
Es cliente No
Es usuario No
Comentarios Ninguno
Participante Omar de Jesús Carreño Aguirre
Organización Universidad Cooperativa de Colombia
Rol Estudiante
Es desarrollador Sí
Es cliente No
Es usuario No
Comentarios Ninguno
Participante Luis Edgardo Arias Mercado
Organización Universidad Cooperativa de Colombia
Rol Estudiante
Es desarrollador Sí
Es cliente No
Es usuario No
Comentarios Ninguno
140
Participante José Noguera
Organización Universidad Cooperativa de Colombia
Rol Investigador Principal
Es desarrollador No
Es cliente No
Es usuario No
Comentarios Ninguno
141
Reuniones 19.7
Reunión Primera Reunión
Fecha 27/05/2016
Hora
Lugar Laboratorio de Electrónica
Asistentes José Noguera
Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Resultados Se definieron las actividades del proyecto
Comentarios Ninguno
Reunión Segunda Reunión
Fecha 08/02/2016
Hora
Lugar Laboratorio de Electrónica
Asistentes José Noguera
Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Resultados Se presentaron adelantos de código de aplicativo
Comentarios Ninguno
142
Reunión Tercera Reunión
Fecha 08/03/2016
Hora
Lugar Laboratorio de Electrónica
Asistentes José Noguera
Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Resultados Se presentó adelanto de código de aplicativo
Comentarios Ninguno
Reunión Cuarta Reunión
Fecha 27/04/2016
Hora 19:12
Lugar Laboratorio de Electrónica
Asistentes José Noguera
Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Resultados Se presentó adelanto de código arduino
Comentarios Ninguno
143
Reunión Quinta Reunión
Fecha 27/05/2016
Hora
Lugar Laboratorio de Electrónica
Asistentes José Noguera
Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Resultados Se presentó adelanto de la monografía, quedaron pendiente la respuesta con las correcciones
necesarias
Comentarios Ninguno
Reunión sexta Reunión
Fecha 08/06/2016
Hora
Lugar Laboratorio de Electrónica
Asistentes José Noguera
Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Resultados Se presentó adelanto de la monografía, quedaron pendiente la respuesta con las correcciones
necesarias
Comentarios Ninguno
Reunión Septima
Reunión
Fecha 15/07/2016
144
Hora
Lugar Laboratorio de Electrónica
Asistentes José Noguera
Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Resultados Se presentó adelanto de la monografía
Comentarios Ninguno
145
Objetivos 19.8
OBJ-0001 General
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes José Noguera
Descripción El sistema deberá controlar la silla de ruedas por medio de panel tactil, reconocimiento de voz y tener
programación de ruta.
Subobjetivos Ninguno
Importancia importante
Urgencia hay presión
Estado en construcción
Estabilidad alta
Comentarios Ninguno
OBJ-0002 Panel Táctil
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes José Noguera
Descripción El sistema deberá tener una aplicación celular para maniobrar la silla de ruedas por medio del panel
táctil del celular.
Subobjetivos Ninguno
Importancia vital
Urgencia hay presión
146
Estado en construcción
Estabilidad alta
Comentarios Ninguno
OBJ-0003 Comando voz
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes José Noguera
Descripción El sistema deberá Incorporar un sistema de manejo de la silla por comandos de voz.
Subobjetivos Ninguno
Importancia vital
Urgencia hay presión
Estado en construcción
Estabilidad media
Comentarios Ninguno
OBJ-0004 Programación de ruta
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes José Noguera
Descripción El sistema deberá Programar un sistema de manejo por ruta en entorno definido para la silla.
Subobjetivos Ninguno
Importancia importante
Urgencia hay presión
147
Estado en construcción
Estabilidad media
Comentarios Ninguno
Requisitos 19.9
Funcionales 19.9.1
FRQ-0001 Requisito 1
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes José Noguera
Dependencias [OBJ-0001] General
Descripción El sistema deberá Tener la funcionalidad de control de la silla de ruedas por medio de la pantalla
táctil
Importancia importante
Urgencia hay presión
Estado en construcción
Estabilidad media
Comentarios Ninguno
FRQ-0002 Requisito 2
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
148
Fuentes José Noguera
Dependencias [OBJ-0001] General
Descripción El sistema deberá Tener la funcionalidad de control a la silla de ruedas por medio voz, enviados a
través del celular
Importancia importante
Urgencia hay presión
Estado en construcción
Estabilidad media
Comentarios Ninguno
FRQ-0003 Requisito 3
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes José Noguera
Dependencias [OBJ-0001] General
Descripción El sistema deberá Tener la funcionalidad de control de la silla de ruedas por medio del envió de una
ruta definida a través de un dibujo en la pantalla táctil.
Importancia importante
Urgencia hay presión
Estado en construcción
Estabilidad media
Comentarios Ninguno
149
No funcionales 19.9.2
NFR-0001 Internet
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes
Dependencias Ninguno
Descripción El sistema deberá Contar con conexión a internet en todo momento
Importancia vital
Urgencia PD
Estado PD
Estabilidad PD
Comentarios Ninguno
NFR-0002 Versión del sistema
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes
Dependencias Ninguno
Descripción El sistema deberá Contar con una versión de sistema operativo mayor a 4.0
Importancia PD
Urgencia PD
Estado PD
Estabilidad PD
Comentarios Ninguno
150
20 Actores
ACT-0001 Usuario
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes José Noguera
Descripción Este actor representa a cualquier persona que utilice el aplicativo móvil.
Comentarios Ninguno
[ACT-0001]
151
21 Casos de uso
UC-0001 General
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes ?
Dependencias [FRQ-0001] Requisito 1
[FRQ-0003] Requisito 3
[FRQ-0002] Requisito 2
Descripción El sistema deberá comportarse tal como se describe en el siguiente caso de uso cuando Inicio de
aplicación
Precondición PD
Secuencia
normal
Paso Acción
1 El sistema La aplicación Pide digitar la ip al cual se enviaran los datos capturados
2 Si se selecciona ENVIAR POR VOZ, se realiza el caso de uso Enviar por voz (UC-0002)
3 Si se traza en la pantalla un tramo, se realiza el caso de uso Enviar por voz (UC-0002)
4 Si se selecciona CREAR RUTA, se realiza el caso de uso Ruta (UC-0009)
Postcondición PD
Excepciones Paso Acción
- -
Rendimiento Paso Tiempo máximo
- -
Frecuencia
esperada PD
Importancia Vital
152
Urgencia hay presión
Estado en construcción
Estabilidad Media
Comentarios Ninguno
[UC-0001] General
153
Envío por voz 21.1
UC-0002 Enviar por voz
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes ?
Dependencias [FRQ-0002] Requisito 2
Descripción El sistema deberá comportarse tal como se describe en el siguiente caso de uso cuando seleccione el
botón VOZ o durante la realización de los siguientes casos de uso: [UC-0001] General
Precondición Se necesita la ip para enviar datos
Secuencia
normal
Paso Acción
1 Si Ya está la digitada la ip, el actor Usuario (ACT-0001) Presiona el botón VOZ
2 Si se presionó el botón Voz, el sistema verifica la ip ingresada y procede a activar el módulo
de voz
3 El actor Usuario (ACT-0001) le dirá en el idioma español que desea hacer
4 Si el modulo detecta que se le dijo algo, el sistema verificara si la opción está dentro del
rango de opciones
5 Si el usuario dijo "Adelante", se realiza el caso de uso Adelante (UC-0003)
6 Si el usuario dijo "Atrás", se realiza el caso de uso Atrás (UC-0004)
7 Si el usuario dijo "Izquierda", se realiza el caso de uso Izquierda (UC-0005)
8 Si el usuario dijo "Derecha", se realiza el caso de uso Derecha (UC-0006)
9 Si el usuario dijo "Detener", se realiza el caso de uso Detener (UC-0008)
Postcondición PD
Excepciones Paso Acción
4 Si el usuario dice alguna opción que no se encuentra dentro del rango de opciones, el sistema
no procesara ninguna acción., a continuación este caso de uso queda sin efecto ( Si el usuario
154
dice alguna opción incorrectamente o no se encuentra dentro del rango de opciones el sistema
no ejecutara ninguna acción, por lo cual el usuario deberá presionar el botón voz otra vez)
4 Si El usuario dice más de una opción antes de que el modulo procese su petición, el sistema
procesara la primera acción dicha por el usuario, a continuación este caso de uso continúa (
Si el usuario Dice por ejemplo "ADELANTE ATRAS IZQUIERDA DERECHA" el sistema
intentara procesar la primera palabra ejecutando el comando "ADELANTE" )
Rendimiento Paso Tiempo máximo
- -
Frecuencia
esperada PD
Importancia Importante
Urgencia hay presión
Estado en construcción
Estabilidad Media
Comentarios Ninguno
155
[UC-0002] Enviar por voz
Pantalla Táctil 21.2
UC-0007 Pantalla Táctil
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
156
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes ?
Dependencias [FRQ-0001] Requisito 1
Descripción El sistema deberá comportarse tal como se describe en el siguiente caso de uso cuando se dibujó un
tramo en la pantalla
Precondición Se necesita la ip para enviar datos
Secuencia
normal
Paso Acción
1 Si Ya está la digitada la ip, el actor Usuario (ACT-0001) Dibuja un tramo en cualquier
parte de la pantalla
2 Si se dibujó el tramo en la pantalla, el sistema verifica el tramo y procede a verificar si es una
opción válida (ejemplo : al trazar un tramo de hacia arriba el sistema detectara que se quiere
dirigir hacia adelante, de igual forma con la izquierda, derecha y atrás.
Un tramo es una sección dibujada por el usuario, la cual comienza desde que pone "dedo" en
la pantalla )
3 Si el usuario trazo "Adelante", se realiza el caso de uso Adelante (UC-0003)
4 Si el usuario trazo "Atrás", se realiza el caso de uso Atrás (UC-0004)
5 Si el usuario trazo "Izquierda", se realiza el caso de uso Izquierda (UC-0005)
6 Si el usuario trazo "Derecha", se realiza el caso de uso Derecha (UC-0006)
7 Si el usuario dijo levanto el/los "dedos" con los que este haciendo los trazos, se realiza el caso
de uso Detener (UC-0008)
Postcondición PD
Excepciones Paso Acción
2 Si el usuario dibuja un tramo que no se encuentra dentro del rango de opciones, el sistema
mediante sus cálculos verificara que quiso decir y tomara la opción que mediante el cálculo le
indique, a continuación este caso de uso continúa (si el usuario crea un tramo en diagonal, es
posible que el sistema envíe el comando "adelante o atrás, o izquierda o derecha"
dependiendo hacia qué lado de la pantalla apunte.)
2 Si el usuario traza más de un tramo al mismo tiempo, el sistema el sistema procesara
dependiendo los valores capturados de la pantalla y ejecutara los diferentes comandos leídos,
a continuación este caso de uso continúa ( si el usuario traza con más de un dedo un tramo el
sistema detectara mediante sus cálculos cual opción es la que desea enviar)
157
Rendimiento Paso Tiempo máximo
- -
Frecuencia
esperada PD
Importancia importante
Urgencia hay presión
Estado en construcción
Estabilidad media
Comentarios Ninguno
158
[UC-0007] Pantalla táctil
Ruta Definida 21.3
UC-0009 Ruta
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
159
Sergio Andrés Guerrero Palencia
Fuentes ?
Dependencias [FRQ-0003] Requisito 3
Descripción El sistema deberá comportarse tal como se describe en el siguiente caso de uso cuando seleccione el
botón CREAR RUTA o durante la realización de los siguientes casos de uso: [UC-0001] General
Precondición Se necesita la ip para enviar datos
Secuencia
normal
Paso Acción
1 Si ya está digitada la ip, el actor Usuario (ACT-0001) dibuja un máximo de 4 tramos antes
de enviar los datos
2 Si ya están definimos los 4 tramos, el sistema el siguiente tramo dibujado en la pantalla
enviara los datos a la ip escrita anteriormente ( un tramo es una sección dibujada por el
usuario, y está comprendida desde que el usuario presiona la pantalla táctil hasta que le
levante el "dedo")
3 Si el usuario trazo "Adelante", se realiza el caso de uso Adelante (UC-0003)
4 Si el usuario trazo "Atrás", se realiza el caso de uso Atrás (UC-0004)
5 Si el usuario trazo "Izquierda", se realiza el caso de uso Izquierda (UC-0005)
6 Si el usuario trazo "Derecha", se realiza el caso de uso Derecha (UC-0006)
7 Si el usuario trazo "Detener", se realiza el caso de uso Detener (UC-0008)
Postcondición PD
Excepciones Paso Acción
2 Si el usuario traza un tramo que no está en las opciones, el sistema el sistema procesara el
dato y según crea guardara la opción, a continuación este caso de uso continúa
2 Si no traza en orden o no crea una ruta, el sistema procesara los comando descritos por el
trazo independiente si es una ruta o no, a continuación este caso de uso continúa ( si el usuario
crea trazos aleatorios no importa en qué lugar de la pantalla este, el sistema interpretara que
opción quiere enviar y procederá después de 4 trazos dibujados a enviar los datos)
Rendimiento Paso Tiempo máximo
- -
Frecuencia
esperada PD
160
Importancia Importante
Urgencia hay presión
Estado en construcción
Estabilidad Media
Comentarios Ninguno
[UC-0009] Ruta Definida
UC-0008 Detener
161
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes ?
Dependencias Ninguno
Descripción El sistema deberá comportarse tal como se describe en el siguiente caso de uso cuando Se enviara el
comando detener o durante la realización de los siguientes casos de uso: [UC-0002] Enviar por
voz, [UC-0007] Pantalla Táctil, [UC-0009] Ruta
Precondición Ser seleccionado el comando detener
Secuencia
normal
Paso Acción
1 El sistema enviara el comando Detener al módulo de la silla de ruedas
Postcondición PD
Excepciones Paso Acción
- -
Rendimiento Paso Tiempo máximo
- -
Frecuencia
esperada PD
Importancia vital
Urgencia hay presión
Estado en construcción
Estabilidad media
Comentarios Ninguno
162
[UC-0008] Detener
UC-0003 Adelante
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes ?
Dependencias Ninguno
Descripción El sistema deberá comportarse tal como se describe en el siguiente caso de uso cuando PD o durante
la realización de los siguientes casos de uso: [UC-0002] Enviar por voz, [UC-0007] Pantalla
Táctil, [UC-0009] Ruta
Precondición ser seleccionado el comando adelante
Secuencia
normal
Paso Acción
1 El sistema Enviara el comando Adelante al módulo de la silla de ruedas
Postcondición PD
Excepciones Paso Acción
- -
Rendimiento Paso Tiempo máximo
- -
Frecuencia
esperada PD
Importancia Vital
Urgencia hay presión
163
Estado en construcción
Estabilidad media
Comentarios Ninguno
[UC-0003] Adelante
UC-0004 Atrás
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes ?
Dependencias Ninguno
Descripción El sistema deberá comportarse tal como se describe en el siguiente caso de uso cuando Se enviara la
opción atrás o durante la realización de los siguientes casos de uso: [UC-0002] Enviar por voz,
[UC-0007] Pantalla Táctil, [UC-0009] Ruta
Precondición Ser seleccionado el comando atrás
Secuencia
normal
Paso Acción
1 El sistema enviara el comando Atrás al módulo de la silla de ruedas
Postcondición PD
Excepciones Paso Acción
- -
Rendimiento Paso Tiempo máximo
- -
164
Frecuencia
esperada PD
Importancia Vital
Urgencia hay presión
Estado en construcción
Estabilidad Alta
Comentarios Ninguno
[UC-0004] Atrás
UC-0005 Izquierda
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes ?
Dependencias Ninguno
Descripción El sistema deberá comportarse tal como se describe en el siguiente caso de uso cuando Se enviara el
comando izquierda o durante la realización de los siguientes casos de uso: [UC-0002] Enviar por
voz, [UC-0007] Pantalla Táctil, [UC-0009] Ruta
Precondición Ser seleccionado el comando izquierda
Secuencia
normal
Paso Acción
1 El sistema enviara el comando izquierda al módulo de la silla de ruedas
Postcondición PD
165
Excepciones Paso Acción
- -
Rendimiento Paso Tiempo máximo
- -
Frecuencia
esperada PD
Importancia vital
Urgencia hay presión
Estado en construcción
Estabilidad Media
Comentarios Ninguno
[UC-0005] Izquierda
UC-0006 Derecha
Versión 1.0 ( 27/05/2016 )
Autores Luis Edgardo Arias Mercado
Omar de Jesús Carreño Aguirre
Sergio Andrés Guerrero Palencia
Fuentes ?
Dependencias Ninguno
Descripción El sistema deberá comportarse tal como se describe en el siguiente caso de uso cuando Se enviara el
comando derecha o durante la realización de los siguientes casos de uso: [UC-0002] Enviar por
voz, [UC-0007] Pantalla Tactil, [UC-0009] Ruta
166
Precondición Ser seleccionado el comando Derecha
Secuencia
normal
Paso Acción
1 El sistema enviara el comando derecha al módulo de la silla de ruedas
Postcondición PD
Excepciones Paso Acción
- -
Rendimiento Paso Tiempo máximo
- -
Frecuencia
esperada PD
Importancia Vital
Urgencia hay presión
Estado en construcción
Estabilidad Media
Comentarios Ninguno
[UC-0006] Derecha
167
Digitar ip
168
22 Pruebas
Módulo de voz 22.1
SOP-0001 Prueba Izquierda
Tipo del
resultado
El sistema debe envío "a" a la ip digitada
Versión 1.0 ( 29/05/2016 )
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara el comando "izquierda" a la ip previamente digitada para realizar el moviendo
izquierda en la silla de ruedas
Parámetros Comando IZQUIERDA : String -- a
Expresiones
de
precondición
Se dice el comando: IZQUIERDA
Expresiones
de
precondición
(OCL)
Se dice el comando: a
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
(OCL)
true
Comentarios Ninguno
Excepción Prueba Izquierda::No se conectó con la silla
Condición Envío de comando Izquierda
169
Condición
(OCL)
false
Expresión "a"
Expresión
OCL
false
Comentarios si el sistema no se conecta con la silla no enviara ningún comando, y no avisara de ninguna manera al
usuario
SOP-0002 Prueba derecha
Tipo del
resultado
El sistema debe envío "d" a la ip digitada
Versión 1.0 ( 06/06/2016 )
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara el comando "derecha" a la ip previamente digitada para realizar el movimiento
derecha en la silla de ruedas
Parámetros Comando IZQUIERDA : String -- a
Expresiones
de
precondición
Se dice el comando: DERECHA
Expresiones
de
precondición
(OCL)
Se dice el comando: d
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
(OCL)
true
Comentarios Ninguno
Excepción Prueba derecha::No se conectó con la silla
170
Condición Envío de comando DERECHA
Condición
(OCL)
false
Expresión "a"
Expresión
OCL
false
Comentarios si el sistema no se conecta con la silla no enviara ningún comando, y no avisara de ninguna manera al
usuario
SOP-0003 Prueba arriba
Tipo del
resultado
El sistema debe envío "w" a la ip digitada
Versión 1.0 ( 06/06/2016 )
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara el comando "arriba" a la ip previamente digitada para realizar el movimiento arriba
en la silla de ruedas
Parámetros Comando ADELANTE : String -- w
Expresiones
de
precondición
Se dice el comando: ADELANTE
Expresiones
de
precondición
(OCL)
Se dice el comando: w
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
(OCL)
true
Comentarios Ninguno
171
Excepción Prueba arriba::No se conectó con la silla
Condición Envío de comando ADELANTE
Condición
(OCL)
false
Expresión "a"
Expresión
OCL
false
Comentarios si el sistema no se conecta con la silla no enviara ningún comando, y no avisara de ninguna manera al
usuario
SOP-0004 Prueba abajo
Tipo del
resultado
El sistema debe envío "s" a la ip digitada
Versión 1.0 ( 06/06/2016 )
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara el comando "abajo" a la ip previamente digitada para realizar el movimiento abajo
en la silla de ruedas
Parámetros Comando ATRAS : String -- s
Expresiones
de
precondición
Se dice el comando: ATRAS
Expresiones
de
precondición
(OCL)
Se dice el comando: s
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
(OCL)
true
172
Comentarios Ninguno
Excepción Prueba abajo::No se conectó con la silla
Condición Envío de comando ABAJO
Condición
(OCL)
false
Expresión "a"
Expresión
OCL
false
Comentarios si el sistema no se conecta con la silla no enviara ningún comando, y no avisara de ninguna manera al
usuario
SOP-0005 Prueba detener
Tipo del
resultado
El sistema debe envío "m" a la ip digitada
Versión 1.0 ( 06/06/2016 )
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara el comando "detener" a la ip previamente digitada para realizar el movimiento
detener en la silla de ruedas
Parámetros Comando DETENER : String -- m
Expresiones
de
precondición
Se dice el comando: DETENER
Expresiones
de
precondición
(OCL)
Se dice el comando: m
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
true
173
(OCL)
Comentarios Ninguno
Excepción Prueba detener::No se conectó con la silla
Condición Envío de comando DETENER
Condición
(OCL)
false
Expresión "m"
Expresión
OCL
false
Comentarios si el sistema no se conecta con el usuario no enviara ningún comando, y no avisara de ninguna manera
al usuario
Pantalla Táctil 22.2
SOP-0006 Prueba Izquierda
Tipo del
resultado
El sistema debe envío "a" a la ip digitada
Versión 1.0 ( 06/06/2016 )
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara el comando "izquierda" a la ip previamente digitada para realizar el moviendo
izquierda en la silla de ruedas
Parámetros Comando IZQUIERDA : String -- a
Expresiones
de
precondición
Se trazó el comando: IZQUIERDA
Expresiones
de
precondición
Se trazó el comando: d
174
(OCL)
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
(OCL)
true
Comentarios Ninguno
Excepción Prueba Izquierda::No se conectó con la silla
Condición Envío de comando Izquierda
Condición
(OCL)
false
Expresión "a"
Expresión
OCL
false
Comentarios si el sistema no se conecta con la silla no enviara ningún comando, y no avisara de ninguna manera al
usuario
SOP-0007 Prueba derecha
Tipo del
resultado
El sistema debe envío "d" a la ip digitada
Versión 1.0 ( 06/06/2016 )
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara el comando "derecha" a la ip previamente digitada para realizar el movimiento
derecha en la silla de ruedas
Parámetros Comando IZQUIERDA : String -- a
Expresiones
de
precondición
Se dice el comando: DERECHA
Expresiones Se dice el comando: d
175
de
precondición
(OCL)
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
(OCL)
true
Comentarios Ninguno
Excepción Prueba derecha::No se conectó con la silla
Condición Envío de comando DERECHA
Condición
(OCL)
false
Expresión "a"
Expresión
OCL
false
Comentarios si el sistema no se conecta con la silla no enviara ningún comando, y no avisara de ninguna manera al
usuario
SOP-0008 Prueba arriba
Tipo del
resultado
El sistema debe envío "w" a la ip digitada
Versión 1.0 ( 06/06/2016 )
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara el comando "arriba" a la ip previamente digitada para realizar el movimiento arriba
en la silla de ruedas
Parámetros Comando ADELANTE : String -- w
Expresiones
de
precondición
Se dice el comando: ADELANTE
176
Expresiones
de
precondición
(OCL)
Se dice el comando: w
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
(OCL)
true
Comentarios Ninguno
Excepción Prueba arriba::No se conectó con la silla
Condición Envío de comando ADELANTE
Condición
(OCL)
false
Expresión "a"
Expresión
OCL
false
Comentarios si el sistema no se conecta con la silla no enviara ningún comando, y no avisara de ninguna manera al
usuario
SOP-0009 Prueba abajo
Tipo del
resultado
El sistema debe envío "s" a la ip digitada
Versión 1.0 ( 06/06/2016 )
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara el comando "abajo" a la ip previamente digitada para realizar el movimiento abajo
en la silla de ruedas
Parámetros Comando ATRAS : String -- s
Expresiones
de
Se dice el comando: ATRAS
177
precondición
Expresiones
de
precondición
(OCL)
Se dice el comando: s
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
(OCL)
true
Comentarios Ninguno
Excepción Prueba abajo::No se conectó con la silla
Condición Envío de comando ABAJO
Condición
(OCL)
false
Expresión "a"
Expresión
OCL
false
Comentarios si el sistema no se conecta con la silla no enviara ningún comando, y no avisara de ninguna manera al
usuario
SOP-0010 Prueba detener
Tipo del
resultado
El sistema debe envío "m" a la ip digitada
Versión 1.0 ( 06/06/2016 )
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara el comando "detener" a la ip previamente digitada para realizar el movimiento
detener en la silla de ruedas
Parámetros Comando DETENER : String -- m
178
Expresiones
de
precondición
Se dice el comando: DETENER
Expresiones
de
precondición
(OCL)
Se dice el comando: m
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
(OCL)
true
Comentarios Ninguno
Excepción Prueba detener::No se conectó con la silla
Condición Envío de comando DETENER
Condición
(OCL)
false
Expresión "m"
Expresión
OCL
false
Comentarios si el sistema no se conecta con el usuario no enviara ningún comando, y no avisara de ninguna manera
al usuario
Ruta Definida 22.3
SOP-0011 Prueba Tramo
Tipo del
resultado
El sistema debe enviar los 4 tramos dibujados los cuales fueron Arriba Izquierda Derecha Abajo
Versión 1.0 ( 06/06/2016 )
179
Autores Sergio Andrés Guerrero Palencia
Dependencias Ninguno
Descripción el sistema enviara los comandos
Arriba
Izquierda
Derecha
Abajo
a la ip previamente digitada para realizar los movimientos en la silla de ruedas
Parámetros ENVIAR : String -- w
a
d
s
Expresiones
de
precondición
Se trazaron los comandos: arriba
izquierda
derecha
abajo
Expresiones
de
precondición
(OCL)
Se trazaron los comandos: w a d s
Expresiones
de
postcondición
Ninguno
Expresiones
de
postcondición
(OCL)
true
Comentarios Ninguno
Excepción Prueba Tramo::No se conectó con la silla
Condición Envío de trazo
Condición
(OCL)
false
Expresión "a"
Expresión
OCL
false
180
Comentarios si el sistema no se conecta con la silla no enviara ningún comando, y no avisara de ninguna manera al
usuario
181
23 Diagrama de secuencia
Pantalla táctil 23.1
[SEC-0001] Pantalla Táctil
182
Modulo de voz 23.2
[SEC-0002] modulo de voz
183
Ruta Definida 23.3
[SEC-0003] Ruta Definida
184
24 Bibliografía
Grupo de Arquitectura y Tecnología de Computadore. (2007). Introducción a PWM. Obtenido de
http://www.arcos.inf.uc3m.es/~infostr/lib/exe/fetch.php?media=introduccionpwm.pdf
Torrente Artero , Ó. (2013). ARDUINO.Curso práctico de formación. RC Libros .
adafruit. (16 de 09 de 2013). Obtenido de https://learn.adafruit.com/adafruit-cc3000-wifi/
Alcubierre , J., Minguez, J., Montesano , L., Montano , L., Saz, O., & Lleida, E. (2005). Silla de Ruedas
Inteligente Controlada por Voz. I Congreso Internacional sobre Domótica, Robótica y
Teleasistencia para Todos (págs. 349-360). Madrid, España: Fundación ONCE.
Aliance, W. (s.f.). Wiffi. Obtenido de http://www.wi-fi.org/discover-wi-fi
AL-Rousan , M., & Assaleh , K. (2011). 1.10.9 Una Ondícula y sistema de voz basado en red neuronal para
el control de una silla de ruedas inteligente. Revista del Instituto Franklin, 90-100.
Arduino. (2014). Arduino. Obtenido de Obtenido de www.arduino.cc
Balestrini, M. (2002). Metodología de la Investigación. Mérida: Universidad de los Andes.
Bayle , J. ( 2013). C Programming for Arduino. Packt Publishing Ltd.
Bishop, C. (1995). Neural Networks for Pattern Recognition. Oxford: Oxford University Press.
Boquete, L., Barea, R., García, R., Mazo, M., & Espinosa, F. (1999). Identificación y control de una silla de
ruedas usando redes neuronales recurrentes. Aplicaciones de Ingeniería de la Inteligencia
Artificial.
Boquete, L., García, R., Barea, R., & Mazo, M. (1999). Control neural de los movimientos de una silla de
ruedas. Diario de sistemas inteligentes y roboticos, 213-226.
Borenstein, J., & Feng, L. (December 1996). Measurement and Correction of Systematic Odometry Errors
in Mobile Robots. IEEE Transactions on Robotics and Automation, 869-880. .
Flóres López, R., & Fernández Fernández, J. M. (2008). Las Redes Neuronales Artificiales. En R. Flóres
López, & J. Fernández Fernández, Las Redes Neuronales Artificiales (pág. 11). netbiblo, S. L.
Fundacion caminos por colombia. (2010). EL IMPACTO DE UNA SILLA DE RUEDAS DE BAJO COSTO EN LA
CALIDAD DE VIDA DE LAS PERSONAS CON DISCAPACIDAD EN EL MUNDO EN DESARROLLO.
Obtenido de
http://www.fundacioncaminosporcolombia.org/userfiles/file/ESTUDIO%20TECNICO%20DE%20L
A%20SILLA%20DE%20RUEDAS.pdf
Garcia Pardo, A., feizzola, Y. J., & calderon, Z. m. (2003). AUTOMATIZACIION DE UNA SILLA DE RUEDAS
CONTROLADA POR COMANDOS DE VOZ. Revista Colombiana de Tecnologias de Avanzada,
Volumen 2.
185
Gia, V. (27 de 8 de 2014). Hispavila. Obtenido de http://hispavila.com/el-puente-h
Gómez Barrios, P. (29 de 4 de 2013). Radio Canada Internacional. Obtenido de
http://www.rcinet.ca/es/2013/04/29/silla-de-ruedas-inteligente/
González, A., Morales, R., & Feliu , V. (2010). Optimizacion para la evasion de obstaculos por generacion
de una trayectoria reconfigurables para una silla de ruedas que sube escaleras. Robótica y
Sistemas Autónomos, 97-114.
González, J., Galindo, C., Fernández, J., Blanco, J., Muñoz, A., & Arévalo, V. (2008). La silla Robótica SENA.
Un Enfoque Basado en la Interacción Hombre-Máquina. Revista Iberoamericana de Automática e
Informática Industrial RIAI, 38-47.
Google. (s.f.). Android Studio. Obtenido de https://developer.android.com/studio/intro/index.html
google, i. (2011). Android. Obtenido de http://source.android.com/
Henao, D. (2000). Inteligencia artificial. El Cid.
Holland, J. (2004). Diseños Róvil de Robots Autónomos:Dentro de la mente de una máquina inteligente
(1). Newnes.
Instruments, T. (10 de 07 de 2013). Digi-Key Electronics. Obtenido de
http://www.digikey.com/en/product-highlight/t/texas-instruments/cc3000-module
Mancilla, J. A., Crespo, H. G., & Navarro, N. A. (2012). Control de una Silla de Ruedas por Medio de un
Dispositivo Móvil con Sistema Operativo Android. Revista Tecnología Digital, 13.
Michael Boninger, M. (2011). La silla de ruedas eléctrica: Lo que el consumidor con LME necesita saber.
Obtenido de Model Systems Knowledge Translation Center (MSKTC):
http://www.msktc.org/lib/docs/SCI-electric_wheelchair-Span_BZEdit.pdf
Mjumder, s. i., Banerjee, N. ,., & cresta, C. B. (2011). Diseño de una silla de ruedas automatico
encontrando la trayectoria con el sisstema de orientacion inteligente. Toronto: IFSA
Publishing,SL.
Nguyen, T. N., Su, S., & Nguyen, H. T. (2013). Neural Network Based Diagonal Decoupling Control of
Powered Wheelchair Systems. IEEE Transactions on Neural Systems e Ingeniería de
Rehabilitación, 371-378.
Nussey, J. (2013). Arduino For Dummies (1). Microprocessors.Electronics -- Data processing.
Pasteau, F., Narayanan, V., Babe, M., & Chaumette, F. (2016). Un enfoque de control visual autónomo
para el paso de una silla de ruedas a través de una puerta en un corredor. Robótica y Sistemas
Autónomos, 28-40.
Pereira, Z. (2011). Los diseños de método mixto en la investigación en educación: Una experiencia
concreta. Revista Electrónica Educare, 15-29.
Robledo , S., Fernández, C., & Robledo, D. (2011). Programacion en Android. Ministerio de Educación de
España.
186
Robledo Fernández, D. (2000). Desarrollo de aplicaciones para Android II. España: Ministerio de
Educación de España.
Rowe , R., & Colbourn, E. (1996). Modelling and optimization of a tablet formulation using neural
networks and genetic algorithms. Pharm. Tech. Eur, 46-55.
Tian, F., Chao , K.-M., Feng, Z., Xing , K., & Shah , N. (2016). Uso de una red inalámbrica de sensores
visuales para navegar armónicamente varias sillas de ruedas de bajo costo en un ambiente
interior. Diario de Red y Aplicaciones Informáticas, 88-99.
Tomari, M., Kobayashi, Y., & Kuno , Y. (2012). 1.10.10 Desarrollo de un sistema inteligente para una silla
de ruedas para un usuario con discapacidad motriz severa. Ingeniería Procedia, 538-546.
Yu-Kuang, W., Hsin-Yi, L., Annmarie, K., Jonathan, P., & Rory, A. (6 march 2015). Evaluating the usability
of a smartphone virtual seating coach application for powered wheelchair users. Elsevier Ltd on,
7.
