Grado en Ingeniería en Tecnologías Industriales

Curso 2018 - 2019

Trabajo Fin de Grado

“DESARROLLO DE APP EN MATLAB PARA

REHABILITACIÓN DE ESPASTICIDAD CON
AYUDA DEL ROBOT COLABORATIVO KUKA LBR
IIWA”

Laura Toledano Vivar

Tutor
Alberto Jardón Huete
Leganés, 2019
II
 RESUMEN
La aplicación creada y desarrollada realiza el papel de ser la interfaz entre el robot
colaborativo y el usuario de esta misma. Permite seleccionar diferentes opciones a través
de las cuales interactúan el paciente y el robot.
Al ser un prototipo inicial de un software de aplicación posee únicamente tres opciones
de trabajo, las cuales son la evaluación, rehabilitación y la generación de un informe.
Como su propio nombre indica, en la opción de evaluación se realiza una monitorización
de los movimientos laterales y rotativos del brazo y hombro del paciente, todos estos
datos interceptados por el robot son almacenados para su posterior uso en futuras terapias
de rehabilitación. Se extraen los datos más significativos de los diferentes movimientos
del paciente y se genera una trayectoria acorde a la limitación de movilidad articular de
dicho paciente. Como última opción, es posible generar un informe con los datos más
importantes del paciente, a través de los cuales la aplicación puede acceder gracias a la
creación de hojas de datos generadas durante la monitorización de los movimientos del
paciente.
Tanto la creación de las hojas de datos como el fichero con los datos más elocuentes son
la fuente principal de información que permiten al fisioterapeuta realizar un correcto y
preciso seguimiento de cada paciente.

Palabras clave:
Automatización, Salud, Robótica,

III
IV
 DEDICATORIA
Sería un gran honor poder gratificar todo este esfuerzo realizado en la elaboración de este
proyecto a mi familia, y en especial a mis padres, los cuales me ha apoyado día tras día
en la realización del trabajo y me ha alentado a dar lo mejor de mí cada día, sin su ánimo
no habría sido posible crear esta aplicación Matlab, por ello deseo dedicarles esta
publicación, y, no olvidar a aquellas personas tan cercanas a mí con las que convivo día
a día, en especial a mi pareja, la cual me ha escuchado y ayudado en cada momento y ha
sido uno de los pilares más importantes durante el proyecto. De la misma forma,
agradezco a todos aquellos profesores que me han acompañado durante el transcurso de
mi formación universitaria.

V
VI
 ÍNDICE DE CONTENIDOS

1. INTRODUCCIÓN ................................................................................................... 1
Motivación del trabajo ....................................................................................... 1
Objetivos ............................................................................................................ 2
2. MATLAB ................................................................................................................. 5
2.1 Historia............................................................................................................... 5
2.2 Software ........................................................................................................... 12
2.3 Lenguaje........................................................................................................... 13
2.4 Aplicaciones ..................................................................................................... 16
2.4.2 Comunicaciones inalámbricas .................................................................. 18
2.4.3 Deep Learning .......................................................................................... 21
2.4.4 Visión artificial ......................................................................................... 22
2.4.5 Procesamiento de señales ......................................................................... 24
2.4.6 Robótica .................................................................................................... 25
3. MATLAB APP DESIGNER................................................................................. 27
3.1 Software ................................................................................................................ 27
3.2 Componentes ........................................................................................................ 28
3.2.1 Ejes ................................................................................................................. 28
3.2.2 Botón .............................................................................................................. 29
3.2.3 Lista desplegable ............................................................................................ 30
3.2.4 Editor de campo ............................................................................................. 32
3.2.5 Etiqueta........................................................................................................... 35
4. DISEÑO DE INTERFAZ ..................................................................................... 38
4.1. Ventana INICIO ............................................................................................... 38
4.1.1 Propiedades ............................................................................................... 41
4.1.2 Función Startup ........................................................................................ 41
4.1.3 Funciones Callback .................................................................................. 43
4.2. Ventana PACIENTE ........................................................................................ 44
4.2.1. Propiedades ............................................................................................... 45
4.2.2. Función Startup ........................................................................................ 46
4.2.3. Funciones Callback .................................................................................. 47
4.3. Ventana NUEVO ............................................................................................. 48
4.3.1. Propiedades ............................................................................................... 50
4.3.2. Función Startup ........................................................................................ 51

VII
 4.3.3. Funciones Callback .................................................................................. 52
4.3.4. Otras funciones ......................................................................................... 55
4.4. Ventana EXISTENTE ...................................................................................... 57
4.4.1. Propiedades ............................................................................................... 59
4.4.2. Función Startup ........................................................................................ 59
4.4.3. Funciones Callback .................................................................................. 60
4.4.4 Otras funciones ............................................................................................... 63
4.5. Ventana PRINCIPAL ...................................................................................... 67
4.5.1. Propiedades ............................................................................................... 68
4.5.2. Función Startup ........................................................................................ 69
4.5.3 Funciones Callback ........................................................................................ 70
5. CONCLUSIONES ................................................................................................. 72
6. BIBLIOGRAFÍA ................................................................................................... 73

VIII
IX
 ÍNDICE DE FIGURAS

Figura 1.1: Robot KUKA LBR IIWA. ............................................................................ 3

Figura 2.1: J. H. Wilkinson and the Pilot ACE, 1951, National Physical Laboratory,
Teddington, England ........................................................................................................ 5
Figura 2.2: Institute for Numerical Analysis, early 1950s, UCLA. George Forsythe is in
the center, and John Todd is looking over Forsythe’s shoulder. ...................................... 6
Figura 2.3: The Burroughs 205 Datatron. ....................................................................... 6
Figura 2.4: Tarjeta perforada de programa Fortran. ........................................................ 7
Figura 2.5: Membrana en forma de L. ............................................................................ 8
Figura 2.6: Libro sobre computación matricial, 1967. .................................................... 8
Figura 2.7: Libro editado por Wilkinson yReinsch. ........................................................ 9
Figura 2.8: Autores de LINPACK................................................................................... 9
Figura 2.9: Primeras funciones de MATLAB. .............................................................. 10
Figura 2.10: Primeros gráficos en MATLAB ............................................................... 10
Figura 2.11: Tektronix 4081. ........................................................................................ 11
Figura 2.12: Jack Little, fundador de The MathWorks ................................................. 12
Figura 2.13: Logotipo de MATLAB ............................................................................. 12
Figura 2.14: Análisis de datos en MATLAB. ............................................................... 17
Figura 2.15: Machine Learning en MATLAB. ............................................................. 18
Figura 2.16: Esquema de MATLAB aplicado a multiplataforma. ................................ 18
Figura 2.17: Herramienta 5G MATLAB. ..................................................................... 19
Figura 2.18: Código HDL en MATLAB. ...................................................................... 20
Figura 2.19: Ejemplo red Deep Learning en MATLAB. .............................................. 21
Figura 2.20: Esquema interoperabilidad de MATLAB................................................. 21
Figura 2.21: Ejemplo app de imagen en MATLAB. ..................................................... 23
Figura 2.22: Ejemplo de procesamiento y corrección de imagen. ................................ 23
Figura 2.23: Esquema de procesamiento de señal en MATLAB. ................................. 24
Figura 2.24: Ejemplo de mapa creado por sensor LiDAR. ........................................... 26
Figura 3.1: Componente Ejes. ....................................................................................... 28
Figura 3.2: Componente Botón. .................................................................................... 29
Figura 3.3: Componente Lista desplegable. ................................................................. 31
Figura 3.4: Ejemplo Lista desplegable. ......................................................................... 31
Figura 3.5: Value e Items de la Lista desplegable. ....................................................... 32

X
Figura 3.6: Propiedad BackgroundColor de la Lista desplegable. ............................... 32
Figura 3.7: Propiedad FontColor de la Lista desplegable. ............................................ 32
Figura 3.8: Componente Editor de campo. ................................................................... 33
Figura 3.9: Uso de editores de campo para la búsqueda del paciente. .......................... 33
Figura 3.10: Uso de editores de campo para mostrar resultados de la búsqueda. ......... 33
Figura 3.11: Propiedad Label del componente Editor de campo. ................................ 34
Figura 3.12: Propiedad Alineación horizontal del componente Editor de campo. ....... 34
Figura 3.13: Ejemplo del componente Etiqueta ............................................................ 35
Figura 3.14: Componente Etiqueta ............................................................................... 35
Figura 3.15: Propiedad Text del componente Etiqueta. ................................................ 35
Figura 3.16: Propiedad VerticalAlignment del componente Etiqueta. ......................... 36
Figura 3.17: Propiedad FontSize del componente Etiqueta. ......................................... 36
Figura 3.18: Propiedad FontWeight del componente Etiqueta. .................................... 36
Figura 3.19: Propiedad BackgroundColor del componente Etiqueta............................ 36
Figura 4.1: Ventana INICIO.......................................................................................... 39
Figura 4.2: Componentes ventana INICIO. .................................................................. 40
Figura 4.3: Función generada automáticamente con ajustes en eje app.Roboespas. ... 40
Figura 4.4: Propiedades ventana INICIO. ..................................................................... 41
Figura 4.5: Función Startup de la ventana de INICIO. ................................................. 42
Figura 4.6: Función Callback del botón de Inicio en la ventana de INICIO................. 43
Figura 4.7: Función Callback al cerrar ventana INICIO. .............................................. 44
Figura 4.8: Ventana PACIENTES. ............................................................................... 44
Figura 4.9: Componentes ventana PACIENTE............................................................. 45
Figura 4.10: Propiedades ventana PACIENTE. ........................................................... 46
Figura 4.11: Código función Startup de la ventana PACIENTE. ................................ 46
Figura 4.12: Función Callback botón Nuevo paciente en ventana PACIENTE. ......... 47
Figura 4.13: Función Callback del botón Paciente existente en ventana PACIENTE. . 47
Figura 4.14: Ventana NUEVO. ..................................................................................... 48
Figura 4.15: Componentes ventana NUEVO. ............................................................... 49
Figura 4.16: Propiedades ventana NUEVO. ................................................................. 50
Figura 4.17: Función Startup de la ventana NUEVO.................................................... 51
Figura 4.18: Función Callback del componente NombreEditField. ............................. 52
Figura 4.19: Función Callback del componente SegundoapellidoEditField. ................ 53

XI
Figura 4.20: Función Callback del componente PrimerapellidoEditField. ................... 53
Figura 4.21: Función Callback del componente Ladoafectado. .................................... 53
Figura 4.22: Función Callback del componente Edad. ................................................. 53
Figura 4.23: Función Callback de GenerarcdigoButton. .............................................. 54
Figura 4.24: Función Callback del botón Terminar. ..................................................... 55
Figura 4.25: Primera parte de la función Rellenar_Lista. ............................................. 56
Figura 4.26: Segunda parte de la función Rellenar_Lista. ............................................ 57
Figura 4.27: Ventana EXISTENTE. ............................................................................. 58
Figura 4.28: Componentes ventana EXISTENTE. ....................................................... 59
Figura 4.29: Propiedades de la ventana EXISTENTE. ................................................. 59
Figura 4.30: Función Startup de la ventana EXISTENTE. ........................................... 60
Figura 4.31: Función Callback del componente NombreEditField. ............................. 61
Figura 4.32: Función Callback del componente Apellido1EditField............................ 61
Figura 4.33: Función Callback del componente Apellido2EditField. ........................... 61
Figura 4.34: Función Callback del componente EdadEditField. .................................. 61
Figura 4.35: Función Callback del botón Buscar. ......................................................... 62
Figura 4.36: Función Callback del componente SiguienteButton. ............................... 63
Figura 4.37: Función Buscar_Nombre. ......................................................................... 63
Figura 4.38: Función Buscar_Apellidos1. .................................................................... 64
Figura 4.39: Función Buscar_Apellidos2. ................................................................... 65
Figura 4.40: Función Buscar_Edad. .............................................................................. 66
Figura 4.41: Función Buscar_Codigo. .......................................................................... 67
Figura 4.42: Función Buscar_Lado. .............................................................................. 67
Figura 4.43: Componentes ventana PRINCIPAL. ........................................................ 68
Figura 4.44: Ventana PRINCIPAL. .............................................................................. 68
Figura 4.45: Propiedades ventana PRINCIPAL. ........................................................... 69
Figura 4.46: Función Startup de la ventana PRINCIAPAL. ......................................... 69
Figura 4.47: Función Callback del botón Evaluación. .................................................. 70
Figura 4.48: Función Callback del botón Rehabilitación. ............................................. 71
Figura 4.49: Función Callback del botón Generar informe. ......................................... 71

XII
XIII
 ÍNDICE DE TABLAS

Tabla 4.1: Explicación código automático app.Roboespas ........................................... 41

Tabla 4.2: Descripción componentes ventana NUEVO. ............................................... 50

XIV
XV
 1. INTRODUCCIÓN

En esta primera sección del trabajo se realizará una pequeña percepción de lo que es el
proyecto en sí, a lo que hay que añadir la motivación del trabajo, es decir, qué motivos
han sido los causantes de la elección de la creación de una aplicación como tema principal
de este Trabajo de Fin de Grado. A estos motivos hay que añadirles cuál o cuáles son los
objetivos principales del proyecto.

Motivación del trabajo

Año tras año, la tecnología incrementa su nivel de avance, y a día de hoy está tomando
una velocidad abismal. Realizó su gran despegue con la Revolución Industrial, y a partir
de ahí ha ido mejorando y se han producido grandes innovaciones. La tecnología ha
sufrido una extensa ramificación en diversas materias, de entre las cuales destaca la
tecnología informática, siendo el tema principal de este proyecto.
La tecnología informática se define como la parte de la tecnología encargada del estudio,
diseño, desarrollo, innovación, puesta en práctica, ayuda o gerencia de los sistemas
informáticos [1]. Con todo esto aparece el término de software, el cual define la RAE
como el conjunto de programas, instrucciones y reglas informáticas para ejecutar ciertas
tareas en un ordenador computadora [2].
Además de este concepto, cabe destacar el término de interfaz, el cual es la definición
principal de este trabajo. Se define interfaz como aquella conexión, física o lógica, entre
una computadora y el usuario, un dispositivo periférico o un enlace de comunicaciones
(definición extraída de la RAE [3]).
Tanto el concepto de interfaz como el de software, son una de las principales
características de lo que hoy en día se denomina Experiencia de Usuario (o User
Experience). Cuando se hace referencia a este término, se hace alusión al conjunto de
factores y elementos relativos a la interacción del usuario, con un entorno o dispositivo
concretos, cuyo resultado es la generación de una percepción positiva o negativa de dicho
servicio, producto o dispositivo [4]. Se tienen en cuenta tanto los factores relacionados
con el diseño, como a los aspectos involucrados con las emociones, sentimientos,
construcción y transmisión de la marca, etc. También, no se debe olvidar que, la
experiencia del usuario, además profundiza en la compresión de los usuarios, qué
necesitan, qué es lo que valoran, sus habilidades, y sus limitaciones [5].
La experiencia de usuario tuvo sus comienzos en sistemas informáticos y diseños de
páginas web, pero con el paso del tiempo, ha incrementado su alcance a diversos campos.
Uno de los objetivos principales de esta temática es crear una interfaz sencilla de
comprender para el usuario, ya que, por el contrario, si fuese algo más compleja,
emplearía más tiempo en descifrar las diferentes prestaciones que ofrece la aplicación,
haciendo que la misma se vea escasamente eficaz. Es decir, se busca hacer uso directo de
ella de una forma más sencilla y rápidamente comprensible.

1
Por tanto, la motivación en la realización de este trabajo es un breve resumen de todo lo
anterior. Se desea generar un interfaz, capaz de producir en el usuario experiencias
satisfactorias, fusionando los aspectos emocionales con los relativos al diseño. Además,
se busca eliminar esas barreras fronterizas entre el humano y la máquina [6]. A esto se le
debe añadir la búsqueda de una aplicación con diferentes prestaciones y que aporte una
alta usabilidad, es decir, la facilidad con que las personas pueden utilizar una herramienta
particular o cualquier otro objeto fabricado por humanos con el fin de alcanzar un objetivo
concreto. Todo esto se quiere utilizar para tratar de una manera diferente un trastorno
motor conocido como espasticidad, del que se hablará y profundizará en él más adelante.

Objetivos

La espasticidad es el motivo principal por el cual se ha desarrollado este proyecto. Cuando

se habla de espasticidad, se habla de un trastorno motor que afecta al sistema nervioso,
haciendo que algunos músculos se mantengan contraídos de forma permanente [7]. Como
consecuencia de esta acción, los músculos sufren una rigidez y acortamiento que
dificultan los diversos movimientos y funciones del mismo, como, por ejemplo, la
deambulación, que se produce cuando una persona camina sin rumbo fijo, sobre todo se
da en personadas con alteraciones mentales (Alzheimer o demencia senil) [8]. Además,
afecta a la manipulación, el equilibrio, el habla, la deglución, etc.
La espasticidad se debe a daños del cerebro o de la médula espinal, y suele estar
acompañada de hipertonía, cuando se produce un aumento del tono muscular; calambres,
se tratan rápidas contracciones sin movimiento notable; espasmos, que son contracciones
con movimiento; e hiperreflexia de tendones profundos. La espasticidad puede ir desde
una leve rigidez muscular, hasta graves, dolorosos e incontrolables espasmos musculares.
Algunas de las causas de este trastorno son la adrenoleucodistrofia (trastorno que
interfiere con la absorción de algunas grasas), algún daño cerebral como consecuencia de
falta de oxígeno, parálisis cerebral, traumatismo craneal, esclerosis múltiple, enfermedad
neurodegenerativa, fenilcetonuria, lesión de la médula espinal, accidente cerebrovascular,
etc [9].
La espasticidad se manifiesta en cualquier grupo musculas, aunque los más comunes son
las extremidades inferiores, afectando a la musculatura extensora de cuádriceps, gemelos
y aductores de la cadera. Y en las extremidades superiores, refiriéndose a los músculos
flexores de los dedos, muñeca, bíceps y aductores del hombro [10]. Y es en este grupo en
el que nos centraremos para la realización del proyecto.
Los movimientos de rehabilitación se realizan con el robot KUKA LBR IIWA, este robot
es el primero fabricado en serie con capacidad sensitiva, lo que le hace ser el primero
preparado para la colaboración entre personas y robots, rompiendo esa barrera entre
humano y máquina. Las siglas LBR hacen referencia a ”Leichtbauroboter”, un vocablo
de origen alemán, que significa “Robot ligero”; mientras que IIWA se refiere a
‘Intelligent Industrial Work Assistan’.

2
 Figura 1.1: Robot KUKA LBR IIWA.

Este modelo de robot KUKA es uno de los primeros robots colaborativos capaces de
realizar tareas que poseen una gran precisión y cuidado, contando con medidas de
seguridad que permiten la interacción entre el paciente, en este caso, y el entorno de
trabajo, existiendo una cantidad ínfima de daños [11]. La característica principal y más
importante que posee este robot es su capacidad de aprendizaje, es decir, el robot es capaz
de memorizar las coordenadas de diversos puntos en una trayectoria. Esta prestación es
de gran importancia ya que permitirá realizar una correcta evaluación de la limitación de
movilidad que padece el paciente, memorizando los puntos pertenecientes a la trayectoria
realizada por el mismo, y que servirá para poder determinar las trayectorias para futuras
terapias de rehabilitación del afectado.
Finalmente, definido el trastorno motor denominado como espasticidad, y explicadas
algunas de sus características y causas, sumado a la existencia del robot Kuka, con sus
características más importantes, se llega a la conclusión del objetivo principal de este
proyecto. El propósito primordial de este proyecto es generar la interfaz a través de la
cual el paciente realizará sus terapias de rehabilitación, siendo la misma manipulada por
el fisioterapeuta, por lo que tiene una fácil manipulación, haciendo que posea una gran
usabilidad. Sus tres funciones principales son la de evaluación, rehabilitación y
generación de informe.
En la parte de evaluación, el paciente debe mover el brazo robótico para que el mismo
pueda memorizar la trayectoria realizada la cual servirá para determinar el área de
limitación móvil que posee el paciente. A raíz de trayectoria y esos puntos obtenidos, será
posible generar nuevas trayectorias acordes a la movilidad del paciente, las cuales serán
empleadas en la opción de “Rehabilitación”. Cada movimiento y trayectoria que se
realicen serán monitorizadas en todo momento, permitiendo así obtener un conjunto de

3
valores, que podrán mostrarse en unas gráficas. Estos datos obtenidos se añaden a los
resultados, de los cuales es posible obtener un parte médico, para ello se encuentra creada
la opción de “Generar informe”.

4
 2. MATLAB

2.1 Historia

Esta gran herramienta de cálculo nace en 1984, como primera versión, gracias a Cleve
Moler. Él creó este programa con el fin de evitar el uso del lenguaje Fortran, aunque
hacía uso de los paquetes de subrutinas de este lenguaje en los cursos de Análisis
Numérico y de Álgebra Lineal, evitando así cualquier programa que hiciera uso del
lenguaje Fortran. El lenguaje empleado por MATLAB se creó en 1970, permitiendo
acceder al lenguaje de matrices LINPACK y EISPACK, logrando así el objetivo con el
que fue creado, obviando el uso de Fortran [12].

Para indagar de manera más profunda en la historia de este potente software se hace
referencia a un artículo que escribió el creador del programa, Cleve Moler, por el
vigésimo aniversario del software:

“MATLAB es ahora un entorno informático técnico con todas las funciones, pero
comenzó como un simple "Laboratorio Matrix". Tres hombres, JH Wilkinson, George
Forsythe y John Todd, desempeñaron papeles importantes en los orígenes de
MATLAB. Nuestra cuenta comienza hace más de 50 años.

Figura
Figura 2.1: J. H. 2.1: J. H. Wilkinson
Wilkinson andACE,
and the Pilot the Pilot
1951,ACE, 1951,
National
National Physical Physical Laboratory,
Laboratory, Teddington,Teddington,
England England
England.

Figura 2.1: J. H. Wilkinson and the Pilot ACE, 1951,

Wilkinson era un matemático británico que pasó toda su carrera en el Laboratorio
Nacional de Física (NPL) en Teddington, en las afueras de Londres. Trabajando en
una versión simplificada de un diseño sofisticado de Alan Turing, Wilkinson y sus
colegas de NPL construyeron el Pilot Automatic Computing Engine (ACE), una de
las primeras computadoras digitales de programa almacenado de Gran Bretaña. El
piloto ACE ejecutó su primer programa en mayo de 1950. Wilkinson realizó cálculos

5
matriciales en la máquina y se convirtió en la principal autoridad mundial en álgebra
lineal numérica.

Figura 2.2: Institute for Numerical Analysis, early 1950s,

UCLA. George Forsythe is in the center, and John Todd is
looking over Forsythe’s shoulder.

Aproximadamente al mismo tiempo, los matemáticos del Instituto de Análisis

Numérico (INA), una rama de la Oficina Nacional de Estándares, ubicada en UCLA,
estaban trabajando con la Computadora Automática Occidental de Estándares
(SWAC), una de las primeras computadoras de los Estados Unidos. Los
investigadores del INA incluyeron a George Forsythe, John Todd y Olga Taussky-
Todd. Cuando el INA se disolvió en 1957, Forsythe se unió a la facultad de Stanford
y los Todds se unieron a la facultad de Caltech.

Fui a Caltech como estudiante de primer año en 1957 y dos años más tarde tomé
John Todd's Math 105, Numerical Analysis. Hicimos algunos de nuestros deberes con
calculadoras mecánicas, pero también utilizamos el Burroughs 205 Datatron, una de
las pocas docenas de computadoras en el sur de California en ese momento.

Figura 2.3: The Burroughs 205 Datatron.

6
En 1961, era hora de graduarse. Todd me recomendó que fuera a Stanford y
trabajara con su amigo George Forsythe. En ese momento, Forsythe era profesor en
el departamento de matemáticas, pero estaba comenzando el proceso que crearía el
departamento de informática de Stanford, uno de los primeros del mundo, en 1965.
En 1962, después del curso de análisis numérico de Forsythe y una visita de Stankin
a Wilfordson, escribí un programa Fortran para resolver sistemas de ecuaciones
lineales simultáneas. Las barajas de tarjetas perforadas para el programa se
distribuyeron bastante ampliamente en ese momento, incluso a través de SHARE, el
Grupo de Usuarios de IBM.

Figura 2.4: Tarjeta perforada de programa Fortran.

Alston Householder del Laboratorio Nacional de Oak Ridge y la Universidad de

Tennessee comenzaron una serie de conferencias de investigación sobre álgebra
numérica a fines de la década de 1950. Estos se llevan a cabo cada tres o cuatro años
y se llaman las Conferencias de los Hogares. Como estudiante de posgrado, fui a la
tercera conferencia de la serie en 1964 y obtuve una foto del comité organizador.
La tesis bajo la dirección de Forsythe se tituló "Métodos de diferencia finita para los
valores propios del operador de Laplace". El ejemplo principal, en el que tanto
Forsythe como Wilkinson habían trabajado antes, era la membrana en forma de L,
ahora el logotipo de MathWorks.

7
 Figura 2.5: Membrana en forma
de L.

Forsythe y yo publicamos un libro de texto sobre computación matricial en 1967 que

luego fue incluido por la Association for Computing Machinery como un texto temprano
importante en informática porque contenía software de trabajo: programas en Algol,
Fortran y PL / I para resolver sistemas de sistemas simultáneos ecuaciones lineales.

Figura 2.6: Libro sobre

computación matricial, 1967.

Durante varios años a finales de la década de 1960, Wilkinson y varios colegas

publicaron artículos enNumerische Mathematik que incluían algoritmos en Algol
para varios aspectos de la computación matricial.Estos algoritmos finalmente se
recopilaron en un libro de 1971 editado por Wilkinson y Reinsch.

8
 Figura 2.7: Libro editado por
Wilkinson yReinsch.

Cada verano, durante 15 años, Wilkinson daba una clase en un curso corto en la
Universidad de Michigan y luego visitaba el Laboratorio Nacional de Argonne
durante una o dos semanas. Los investigadores de Argonne tradujeron el código
Algol para el cálculo del valor propio de la matriz del manual de Wilkinson y Reinsch
a Fortran para producir EISPACK. Esto fue seguido por LINPACK, un paquete de
programas Fortran para resolver ecuaciones lineales.

Figura 2.8: Autores de LINPACK.

Cuando estábamos desarrollando EISPACK y LINPACK, era profesor de

matemáticas en la Universidad de Nuevo México, enseñando análisis numérico y
teoría de matrices. Quería que mis alumnos pudieran usar nuestros nuevos paquetes
sin escribir programas Fortran, así que estudié un libro de Niklaus Wirth para
aprender a analizar los lenguajes de computadora.

A fines de la década de 1970, siguiendo la metodología de Wirth, utilicé Fortran y

partes de LINPACK y EISPACK para desarrollar la primera versión de MATLAB. El

9
único tipo de datos era "matriz". El comando AYUDA enumeró todas las funciones
disponibles, con sus nombres abreviados.

Figura 2.9: Primeras funciones de MATLAB.

Solo había 80 funciones. No había archivos M ni cajas de herramientas. Si deseaba

agregar una función, tenía que modificar el código fuente de Fortran y volver a
compilar todo el programa. Aquí hay un programa de muestra. Si
cambia long a format long, funciona con MATLAB de hoy. Además, los primeros
gráficos eran muy primitivos.

Figura 2.10: Primeros gráficos en MATLAB

Este primer Fortran MATLAB era portátil y podía compilarse para ejecutarse en
muchas de las computadoras que estaban disponibles a fines de los años setenta y
principios de los ochenta. Lo instalamos en los sistemas interactivos de tiempo
compartido que fueron alojados por computadoras centrales en universidades y
laboratorios nacionales.

La primera "computadora personal" que utilicé fue la Tektronix 4081, que Argonne
adquirió en 1978. La máquina era del tamaño de un escritorio y consistía en una
pantalla gráfica Tektronix conectada a una Interdata 7/32, la primera
minicomputadora de 32 bits. Solo había 64K, eso es 64 kilobytes de memoria.Pero

10
había un compilador Fortran y, por lo tanto, al usar la superposición de memoria,
pudimos ejecutar MATLAB.

Figura 2.11: Tektronix 4081.

Visité Stanford en 1979 y enseñé CS237, el curso graduado de análisis

numérico. Hice que los estudiantes usaran MATLAB para algunos de los deberes. La
mitad de los estudiantes en la clase eran de matemáticas y ciencias de la
computación, y mi nuevo programa no los impresionó. Se basaba en Fortran, no era
un lenguaje de programación particularmente poderoso y no representaba el trabajo
de investigación actual en análisis numérico . La otra mitad de los estudiantes eran
de ingeniería, y les gustaba MATLAB. Estaban estudiando temas sobre los que no
sabía nada, como el análisis de control y el procesamiento de señales , y el énfasis en
las matrices en MATLAB resultó ser muy útil para ellos.

Algunos de los estudiantes de ingeniería de Stanford de mi clase se unieron a dos

empresas de consultoría en Palo Alto. Estas compañías ampliaron MATLAB para
tener más capacidad en análisis de control y procesamiento de señales y, a principios
de la década de 1980, ofrecieron el software resultante como productos comerciales.

Jack Little, un ingeniero de control capacitado en Stanford y el MIT, fue el

desarrollador principal de uno de los primeros productos comerciales basados en
Fortran MATLAB. Cuando IBM anunció su primera PC en agosto de 1981, Jack
anticipó rápidamente la posibilidad de usar MATLAB y la PC para computación
técnica. Él y su colega Steve Bangert reprogramaron MATLAB en C y agregaron
archivos M, cajas de herramientas y gráficos más potentes.

11
Los tres fundamos The MathWorks en California en 1984. [13]”

Figura 2.12: Jack Little, fundador de

The MathWorks

Es de gran importancia destacar, que tanto la narración biográfica como las imágenes
extraídas han sido directamente copiadas de la página original, debido que, al tratarse de
datos biográficos personales, se debe de mantener la redacción original.

2.2 Software

MATLAB es un sistema de cómputo y cálculo numérico el cual ofrece al usuario que

utilisza este software un entorno de desarrollo integrado, lo que se conoce como IDE,
además posee un lenguaje propio, del cual se hablará más adelante [14]. Una de las
ventajas de este software es que es un programa multiplataforma, es decir, se encuentra
disponible para Unix, Windows, Mac OS X Y GNU/Linux.

Figura 2.13: Logotipo de MATLAB

12
El nombre de este programa viene de la abreviatura de MATrix LABoratory, ya que una
de sus principales utilidades es la que se encarga de realizar operaciones matriciales,
aparte de poder representar en gráficas diferentes conjuntos de datos y funciones, crear
algoritmos, crear y desarrollar diferentes interfaces (MATLAB App Designer), y hace
que sea posible la comunicación con otros programas, aunque posean un lenguaje
diferente.

2.3 Lenguaje

Cualquier aplicación que haya sido creada en MATLAB se desarrolla con un lenguaje de
programación propio. Además, este lenguaje es interpretado, es decir, es un lenguaje que
necesita un compilador para poder realizar su procesado, evitando la acción de leer y
traducir el código en su totalidad. Pero esto no sería posible sin un programa llamado
intérprete, el cual realiza la función de traducir cada orden o instrucción, que el humano
introduce, al código máquina, que son las instrucciones de la CPU del ordenador. Cada
instrucción es leída una a una conforme se ejecuta el programa y se descomponen en
instrucciones del sistema, incluso es capaz de automatizar tareas tales como las
declaraciones de variables, haciendo que sea mucho más ágil la programación de los
códigos [15].

A pesar de estas características, este tipo de lenguaje (lenguaje interpretado), puede

poseer ciertas desventajas como por ejemplo la velocidad. Cuando se habla de que la
velocidad supone una desventaja se debe a que es de vital importancia se estén en
equilibrio tanto la portabilidad del software con la velocidad. De igual manera, la
portabilidad supone una desventaja ya que la mayoría de los lenguajes compilados que
existen se encuentran disponibles en todas las plataformas.

Dejando a un lado los aspectos negativos que posee este tipo de lenguaje, hay que destacar
también sus ventajas, entre las cuales destacan la independencia existente entre la
máquina y el sistema operativo, ya que no posee órdenes propias del procesador, en su
lugar posee las llamadas a funciones, las cuales son reconocidas por el intérprete. Al
existir un intérprete en un sistema operativo, se garantiza que cualquier programa escrito
en ese lenguaje funcionará correctamente. Además, es posible realizar pequeñas
modificaciones en el código mientras que el mismo se está ejecutando, evitando así la
acción de tener que compilar de nuevo el código en su totalidad.

Una vez explicado el término de lenguaje interpretado, se debe añadir que este lenguaje
puede ejecutarse en archivos de script, los llamados archivos *.m, como en escenarios
interactivos. Gracias a este lenguaje, MATLAB perite realizar operaciones con vectores
y matrices, representación de datos y funciones, implementar logaritmos, realizar cálculos

13
lambda, crear interfaces de usuarios, realizar programación orienta a objetos (conocido
como POO), y finalmente, la comunicación con programas en otros lenguajes y con otros
dispositivos hardware [16].

Para finalizar con esta sección que hace referencia al lenguaje que se emplea en
MATLAB, se va a proceder a explicar brevemente algunas de las funciones que ofrecidas
por MATLAB que han sido las más empleadas en la realización de este proyecto.

• Imread (filename). Esta función se encarga de leer el archivo que se indica en el

espacio denominado como filename, a partir del cual determinarará de ue tipo de
archivo se trata. Además, si filename es un archivo en el que hay varias imágenes, la
función imread leerá sólo la primera imagen del conjunto [17].

• Imshow (filename, ‘Parent’, appName): Su finalidad es mostrar la imagen

almacenada en el archivo llamado filename. Si además se quiere mostrar la imagen
en unos ejes específicos, es necerario añadir el segmento de sentencia ‘Parent’, y
separados por una coma se añade el nombre que se ha designado a los ejes deseados
[18]. (Ej.: app.UIAxes ).

• Delete (obj): De lo que se encara esta función es de eliminar el objeto que se encuentre
entre sus paréntesis. En este caso lo que se desea es eliminar la aplicación que en ese
mismo instante se está ejecutando [19].

• Xlswrite (filename, A): Sea A el nombre del archivo de la hoja de Excel, y filename
el nombre que recibe este archivo de Excel, al hacer uso de esta función se escribirá
esa matriz de datos A en el fichero Excel especificado con el nombre de filename [20].

• Xlsread (filename): Gracias a esta función es posible leer un archivo de Excel que
posee el nombre del valor que contenga la variable filename. Por una parte, generará
un conjunto de valores numéricos y por otra parte generará datos alfabéticos como
cadenas de caracteres y demás [21].

• Randi ( [iMin, iMax], n, m ): Esta función se usa para la generación de números

aleatorios que se encuentran en el intervalo designado por [iMin, iMax]. Además, el
valor n hace referencia al número de filas de la matriz que deseamos crear, y el valor
m indica el número de columnas de esta matriz [22].

• For: Es utilizado para realizar bucles o loops un número de veces indicado por el
usuario. Seguido de la sentencia for es obligatoria añadir un índice, que se empleará
dentro del código, y unos valores, que indicarán el número de veces que se ejecutará
el bucle. Dentro del bucle se encuentran las sentencias o funciones que se desean
ejecutar en cada iteración [23].

14
• Char (A): Consiste en una matriz compuesta por caracteres, es decir, una secuencia
de caracteres. Su función es convertir el valor de A, que puede ser una matriz, un
vector o un número en concreto, en caracteres. Esta función sobre todo se ha usado
en la parte de en la que se genera un código aleatorio para cada paciente [24].

• Readtable (filename, Name, Value): Esta función es la encargada de crear una tabla a
partir del archivo con el que se denomina a filename, siendo el modo de lectura
columna a columna. Además, es capaz de importar unas opciones específicas que son
indicadas a través del valor de Name y Value [25].

• Switch switch_expression: Se trata de un bloque en el que se ejecuta una instrucción

determinada dentro de un grupo de instrucciones en función del valor que cada vez
posea switch_expression. Lo ventajoso de este bloque de instrucciones es que para
cada caso se pueden ejecutar funciones diferentes, justo lo contrario de lo que ocurre
cuando se hace uso del bucle for [26].

• Transpose (A): Al hacer uso de esta función, lo que ocurre es que se transpone el
valor de A, ya sea una matriz o un vector. Esta función se ha usado principalmente a
la hora de leer y escribir datos en la tabla [27].

• Strcmp (s1, s2): Hacer uso de esta función permite comparar dos cadenas de
caracteres s1 y s2. El valor que devuelve es de tipo bool, es decir, puede ser un 1 o un
0. Esto es de gran utilidad a la hora de realizar la búsqueda de un paciente en el archivo
Excel [28].

• Find (X): Esta función se utiliza para buscar valores diferentes de 0 que existen en el
dato X, este dato puede ser tanto un vector como una matriz. El resultado al hacer uso
de esta función es un vector con las posiciones en las que los números pertenecientes
a X tienen un valor superior a 0. Si se trata de una matriz, su lectura se realizará
primero seleccionando una columna, y leyendo cada fila de esa columna,
obteniéndose así un vector lineal. Además, es posible que el dato X se trate de una
sentencia como >,<,=, que es como se ha empleado en el código para deducir en qué
posición se encuentra el paciente buscado [29].

• Length (X): La función lentgh devuelve el valor de la longitud tanto de un vector

como de una matriz. Cuando se desea saber la longitud de una matriz, el valor que
devolverá esta función será el mayor entre el número de columnas y el de filas, en el
caso del vector es mucho más sencillo, ya que el vector es lineal. Esta función se usa
en el proyecto para evitar establecer un número fijo de pacientes, ya que el número
de los mismos puede ir variando, y se producirían errores en el código [30].

• If/elseif/else: Esta función es la encargada de comprobar que una condición sea

verdadera o no. Si la condición se cumple, se ejecutarán las sentencias asociadas a esa
condición, es posible que existan diferentes condiciones, entonces es cuando se hará

15
 uso de la sentencia elseif. La diferencia entre switch y if/elseif/else es que para que se
ejecute cada sentencia en switch solo se debe comprobar un único valor, al contrario
que al hacer uso de if/elseif/else, ya que esta función puede comprobar más de una
condición para cada valor. En el código se usa para poder llevar un recuento del
número de coincidencias entre el nombre, apellido o edad introducido del paciente y
los que se encuentran en el documento de Excel [31].

• String (A): Esta función es la encargada de transformar el valor introducido en A en

una cadena de caracteres. Se usa en el código principalmente para transformar algunos
datos en cadenas de caracteres para poder introducirlos en la tabla y así poder escribir
en el documento Excel [32].

2.4 Aplicaciones

MATLAB es un programa que hoy en día se encuentra al alcance de todo el mundo, sobre
todo es usado por millones de ingenieros y científicos. Gracias a su gran profesionalidad
a la hora de desarrollar las toolboxes, son capaces de pasar pruebas muy rigurosas y todas
ellas se encuentran documentadas en su totalidad. MATLAB se puede aplicar a varios
campos de investigación, que se explicarán brevemente a continuación.

2.4.1 Analítica de datos

Gracias a esta aplicación, es posible analizar una gran cantidad de datos, crear diferentes
modelos de machine learning y predictivos, y poder implementar estos mismos en los
sistemas de la Tecnología Informática de las empresas.
Al mismo tiempo permite el acceso a los datos que se encuentran almacenados en
archivos planos, bases de datos, historiadores de datos y la nube, ofreciendo también la
opción de conectarse a fuentes en directo, como por ejemplo hardware de adquisición de
datos y datafeeds financieros. Además, estos datos se pueden administrar y gestionar en
función del tipo de dato que se trate y sus capacidades de procesamiento, para que estén
organizados a la hora de crear algún programa que hará uso de estos datos, los cuales
pueden ser representados mediante gráficos MATLAB y el entorno Live Editor [33].

16
También ofrece la opción de poder aplicar técnicas de ingeniería que poseen
características específicas de dominio que existen en los datos de sensores, texto, imagen,
vídeo, etc. Posee apps de machine learning y deep learning que permiten modelizar de
diferentes maneras los datos a analizar, estos modelos pueden ajustarse gracias a
algoritmos que seleccionan de manera automática las características de los datos que se
están estudiando. A parte de ajustarse automáticamente, estos modelos se pueden
implementar en sistemas de producción que hagan uso de la Tecnología Informática,
evitando así escribir el código en otro lenguaje, además, es capaz de convertir los modelos
a código C/C++.

Figura 2.14: Análisis de datos en MATLAB.

Una de las ventajas del uso de MATLAB en el análisis de datos es la reducción del tiempo
a la hora de realizar el procesado de los datos, siendo estos desde datos de sensores, hasta
imágenes o texto, gracias al tipo de datos del que hace uso MATLAB. Algunas tareas,
como por ejemplo la sincronización de series temporales dispares, o la sustitución de
valores atípicos con otros interpolados, el filtrado de señales que poseen ruido, o la
separación de texto, se realizan de una manera mucho más sencilla gracias a sus funciones
de alto nivel. Como se ha mencionado antes, es posible representar los datos en gráficos,
lo cual permite la rápida visualización de los datos y así ayudar a comprender la tendencia
y detectar posibles problemas de calidad [33].
MATLAB también ofrece la oportunidad de trabajar con Machine Learning, ya que
brinda al usuario con apps para la clasificación y regresión, obteniendo así unos rápidos
resultados, esto es debido a la gran variedad de algoritmos que ofrece, ya sean tanto de
clasificación como de regresión. A parte, ofrece la posibilidad de comparar modelos y de
poder exportar modelos para realizar análisis más tarde. También ofrece la opción de
facilitar la escritura en código gracias a la optimización de hiperparámetros que se
encuentran en las funciones, buscando una manera más sencilla de encontrar los
parámetros más óptimos a la hora de realizar el ajuste del modelo [33].

17
 Figura 2.15: Machine Learning en MATLAB.

Como última ventaja cabe destacar la implementación multiplataforma, pudiendo así

implementar os diferentes modelos en código C/C++, código CUDA, sistemas IT
empresariales o la nube. Es capaz de generar código C a partir del código MATLAB
cuando existe un alto rendimiento, dando como resultado un alto nivel de predicción y
una necesidad de memoria ínfima. Además, los modelos pueden exportarse a Simulink o
implementarlos en MATLAB Production Server, pudiendo integrarse en aplicaciones
web, ya sean sobre bases de datos o empresariales [33].

Figura 2.16: Esquema de MATLAB aplicado a

multiplataforma.

2.4.2 Comunicaciones inalámbricas

MATLAB es de gran ayuda cuando se busca reducir el tiempo de desarrollo en programas
pertenecientes a la ingeniería de control, deshacerse de problemas de diseño lo antes
posible y hacer que los procesos de prueba e investigación se hagan de una manera ágil.
En este campo de las comunicaciones, MATLAB permite simular algunos conceptos del
diseño de algoritmos y sistemas, generar formas de ondas personalizadas por el usuario y
poder verificar el grado de conformidad respecto a las conexiones 5G, WLAN y LTE.
Permite crear modelos con elementos digitales, RF y antenas para un mejor
comportamiento del sistema, además, estos modelos pueden ser de referencia

18
reutilizables, para poder verificar iterativamente diseños o prototipos de este tipo de
comunicaciones. Una de las ventajas que también ofrece MATLAB es la generación
automática de código HDL o C, como se había mencionado en el apartado anterior,
acelerando así el proceso de implementación del código en otros lenguajes. También es
capaz de automatizar el análisis de datos y pruebas, y proceder a la posterior simulación
de los resultados [34].

Cuando se habla de la creación de algoritmos, MATLAB permite a sus usuarios la

oportunidad de demostrar y explorar nuevas tecnologías, creando de esta manera
propiedad intelectual. Este software ofrece una serie de toolboxes, las cuales se pueden
personalizar de forma que se puedan explorar diseños diferentes, o incluso usar datos en
directo para la realización de pruebas analizando los resultados [34].

Si se desea realizar diseños cuya base está sostenida por los estándares de capa física
3GPP y 802.11, MATLAB pone a disposición del usuario una serie de herramientas de
soporte completo, evitando la dependencia de simuladores ni entornos de prueba para los
modelos que se creen. Estas herramientas permiten crear modelos de referencia para su
posterior verificación de conformidad con modelos estándares, medir el rendimiento que
se encuentra en el nivel de enlace y personalizar estas herramientas [34].

Figura 2.17: Herramienta 5G MATLAB.

Asimismo, brinda al usuario con la opción de realizar simulaciones multidominio para el

diseño de futuras tecnologías de comunicación, como por ejemplo arrays MIMO masivos,
arquitecturas de conformación del haz híbrida y transceptores de RF adaptables y
frontales radio. Cualquier interacción del componente puede ser simulada gracias a los
modelos de alto nivel, los cuales permiten una rápida evaluación de los ajustes empleados
en los diseños y realizar un análisis del impacto que supondría en cada opción utilizada
en el diseño [34].

19
Los modelos de hardware creados en Simulink pueden ser compartidos y utilizados por
los diferentes usuarios de MATLAB, los cuales son capaces de generar de manera
automática código HDL que garantiza ser legible y sintetizable para la implementación
de FPGA, SoC y ASIC. El rendimiento de sistemas LTE, así como la reducción del
tiempo de desarrollo se debe a las aplicaciones de referencia que posee, al igual que los
bloques IP de LTE que se encuentran optimizados para HDL [34].

Figura 2.18: Código HDL en MATLAB.

Tanto MATLAB como Simulink ayudan a sus usuarios en la automatización de pruebas

para la verificación del diseño de los mismos, de manera precia a la implementación del
hardware. Los modelos validados pueden ser empleados como bancos de pruebas para la
verificación de prototipos hardware e implementaciones de producción. Los diseños
creados y desarrollados por los usuarios pueden ser probados en una variada gama de
hardware SDR, además de instrumentos RF, a lo que hay que sumar el análisis eficiente
de extensos conjuntos de datos originados en la simulación, pruebas de laboratorio y de
campo [34].

20
2.4.3 Deep Learning

Una de las ventajas que ofrece MATLAB a la hora de trabajar en Deep Learning, es el
fácil acceso a modelos tan recientes como GoogLeNet, VGG-16, VGG-19 y AlexNet
entre otros. Permite acelerar algoritmos de los diferentes recursos de centros de datos
evitando la necesidad de una programación especializada. Por otro lado, a la hora de
trabajar con redes neuronales, es posible la creación, modificación y análisis de
arquitectura de las mismas, haciendo uso de herramientas de visualización y de apps
brindadas por MATLAB. Estas mismas apps aceleran el proceso de etiquetado de ground-
truth de imágenes, vídeos y audios, gracias a su capacidad de automatización [35].

Figura 2.19: Ejemplo red Deep Learning en MATLAB.

MATLAB se usa en el Deep Learning gracias a su interoperabilidad, es decir, posee la

capacidad de compartir datos y, información entre diferentes sistemas de información,
con marcos dedicados a Deep Learning permitiendo así la existencia de código abierto,
debido a las facilidades para importar y exportar que ofrece ONNX [35].

Figura 2.20: Esquema interoperabilidad de MATLAB.

Algunas de las apps específicas pertenecientes a los campos de datos de audio, vídeo e
imagen que ofrece MATLAB hacen que sea posible un rápido procesado de conjuntos de

21
datos, comprobando así problemas y su posterior solución antes del entrenamiento. Un
ejemplo de estas apps mencionadas es la app Deep Network Designer, la cual permite la
creación de arquitecturas de red complejas o modificar redes que hayan sido previamente
entrenadas para la transferencia de aprendizaje [35].

Una vez creados los modelos de Deep Learning, ya sea CUDA, código C, sistemas
empresariales o la nube, pueden ser implementados en cualquier lugar. Esto se debe a la
existencia de una excelente calidad de rendimiento, que posibilita la opción de hacer uso
de librerías optimizadas pertenecientes a Intel, NVIDIA y ARM [35].

2.4.4 Visión artificial

Como ya se ha mencionado en el apartado anterior, MATLAB ofrece un amplio abanico

de posibilidades a la hora de recoger datos en imágenes, vídeos y audios, a través de los
cuales desarrollar algoritmos para su posterior implementación. Con los datos
recolectados, es posible diseñar soluciones de visión gracias a un extenso conjunto de
algoritmos que servirán de referencia al usuario para procesar imágenes, Deep Learning
y visión artificial. Otra de las opciones que pone a disposición del usuario, es la
colaboración con otros equipos gracias al uso de OpenCV, Python y C o C++, las cuales
hacen uso de herramientas de integración. Como siempre, MATLAB ofrece la opción de
automatizar algunas tareas comunes, acelerando así el proceso que explora algoritmos,
gracias a una gran cantidad de apps de flujo de trabajo [36].

Los datos obtenidos a partir de imágenes y demás archivos similares, pueden explorarse
de forma interactiva, generándose de forma automática el código en MATLAB, evitando
así partir desde cero en el código. Algunas de las apps más importantes que se ofrecen en
este campo son la segmentación de imágenes, la cual es capaz de segmentar una imagen
haciendo uso de gradiente, es decir, un algoritmo de contornos activos XYZ. Además de
esta app hay que destacar la calibración de cámaras, la cual se encarga de la estimación
de parámetros de distorsión del objetivo, tanto intrínsecos como extrínsecos de la cámara.
Y finalmente, no se puede olvidar la app encargada del etiquetado de imágenes y vídeos,
que permite, dentro de un conjunto de imágenes, etiquetar los datos de validación de
terreno, dando la opción de visualizar vídeos y secuencias de imágenes [36].

22
 Figura 2.21: Ejemplo app de imagen en MATLAB.

Gracias a los algoritmos de MATLAB, es posible extraer una gran cantidad de

información a partir de imágenes o vídeos, ya que existen apps que permiten visualizar
volúmenes en 3D, o incluso segmentos de plano. A esto hay que añadir el navegador
DICOM que posee, que permite la selección y posterior importación de archivos, los
cuales pueden ser visualizados, ya sean vídeos o secuencias de imágenes, dando la opción
de elegir un fotograma concreto o hasta modificando la velocidad de reproducción [36].

El procesamiento de imágenes permite utilizar flujos de trabajo para el procesamiento de

imágenes 3D, registrar y segmentar imágenes, realizar una visualización en estéreo,
procesar una nube de puntos o incluso detectar, seguir y reconocer objetos [36].

Figura 2.22: Ejemplo de procesamiento y corrección de imagen.

Como ya se había mencionado anteriormente, MATLAB es capaz de reutilizar código

que ha sido escrito en otros lenguajes de programación, crear sitios web con capacidad de
respuesta que estén basados en MATLAB, o utilizar código C para poder programar el

23
hardware, el cual es directamente generado desde MATALB. Además, permite la
conexión a estos soportes hardware, ya sean cámaras de vídeo, cámaras GgE Visio, y
DCAM entre otros. Los datos que admite son los “estándar”, permitiendo así el acceso a
ellos a través de apps y funciones preintegradas. Una vez más, su alto rendimiento hace
posible la ejecución de flujos paralelos, ya sea haciendo uso de GPU NVIDIA o CPU
multinúcleo, evitando así los algoritmos de reprogramación, además de poder ejecutase
en la nube. Todos los algoritmos pueden ser ejecutados en hardware de PC, FPGA y
ASIC, y pudiendo trabajar en código C/C++ y HDL [36].

2.4.5 Procesamiento de señales

MATLAB facilita en gran medido la tarea de trabajar con datos de series temporales,
proporcionando así un flujo de trabajo unificado que será de gran utilidad en el desarrollo
de sistemas integrados y aplicaciones de transmisión. Es capaz de proporcionar señales
de diferentes fuentes para su posterior medición y análisis. Y como siempre, los
algoritmos desarrollados pueden estar orientados a la transmisión de audio, sensores
inteligentes e instrumentación [37].

Las señales que proceden de diferentes fuentes no solo pueden medirse y analizarse, si no
que se pueden transformar, filtrar y visualizar sin ser apenas un experto en la materia. En
las señales además se pueden medir las características de tiempo y frecuencia. También
se ofrecen aplicaciones para el análisis y aprendizaje automático [37].

Figura 2.23: Esquema de procesamiento de señal en MATLAB.

El procesamiento de señales digitales puede hacerse en tiempo real, gracias a las

aplicaciones de diseño proporcionadas por MathWorks. MATLAB posee el DPS System
Toolbox, que gracias a su flujo de trabajo permite ayudar en el diseño y verificar las
aplicaciones de transmisión en un solo entorno, optimizando rápidamente los diseños, y
localizando así los errores. Permite integrar a nivel de sistema y de simulación algoritmos
y componentes electrónicos, hacer uso de una amplia cantidad de herramientas para el
diseño de filtros y como en la mayoría de los casos, genera de manera automática el
código de programación para acelerar la simulación y creación de prototipos en tiempo
real [37].

24
Gracias a su flujo de trabajo y a DPS System Toolbox, permite verificar los diseños de
punto fijo en la simulación de forma previa a la implementación y, por último, posee
algoritmos capaces de implementar, generando código C optimizado para procesadores
ARM y código HDL para FPGA y ASIC [37].

2.4.6 Robótica

Esta sección es la más importante, ya que la interfaz diseñada está orientada a ser usada
con el robot colaborativo KUKA. Gracias a MATLAB es posible la conexión con el robot
y poder controlarlo con los algoritmos desarrollados por el usuario, algunos de estos
algoritmos pueden ser independientes del hardware y existe la opción de conectar con
ROS, abreviatura de Robot Operating System. Como en todos los apartados, MATLAB
facilita a gran nivel la reducción del tiempo de creación de código, ya que es capaz de
generar código automático en lenguaje C/C++, VHDLy CUDA entre otros, para poder
implementarlos en dispositivos como FPGAs, PLCs y GPUs. Además de poder conectar
con este tipo de hardware, también es posible hacerlo con uno de bajo coste como Arduino
y Raspberry Pi, con la ayuda de paquetes de soporte hardware previamente diseñados [38].

Es de gran utilidad para poder analizar tanto la mecánica como dinámica de cuerpos
rígidos como brazos manipuladores o plataformas de vehículos. Es capaz de trabajar con
archivos de formato CAD, es decir, el formato que reciben los archivos obtenido del
diseño de cuerpos por ordenador. A la hora de analizar estos cuerpos, existe la posibilidad
de personalizar los ajustes del análisis añadiendo restricciones como por ejemplo la
fricción, entre otros [38].

Como se ha mencionado antes, el usuario puede conectarse a algunos hardware mediante

el uso de ROS, que pueden convertir los mensajes o datos de ROS a tipos de datos para
MATLAB. Algunas tareas como importación y procesamiento de datos, calibración de
sensores, registro y demás, se pueden realizar de manera automática, como muchas más
acciones ya mencionadas en los apartados anteriores [38].

Algunas tareas como la detección de objetos, cálculo de movimientos, fusión de sensores

y demás, pueden realizarse de manera interactiva gracias a las apps que MATLAB pone
a disposición del usuario. En robótica se pueden aplicar todas las prestaciones ya
mencionadas y explicadas en el apartado de Deep Learning haciendo uso de redes
neuronales convolucionales [38].

Es de gran interés, dentro de las conexiones con dispositivos hardware, la conexión con
el sensor LiDAR, que permite realizar mapas de entornos gracias a los datos que recibe a
través de la técnica de localización y mapeo simultáneo, también conocido como SLAM.
Con los datos obtenidos de la realización del mapeo, es posible crear algoritmos de
planificación de ruta y movimiento, pudiendo así navegar por escenarios o entornos que

25
se encuentran restringidos, además, puede hacer posible la creación de una ruta libre de
obstáculos [38].

Si, por el contrario, existen rutas con ciertos obstáculos, es posible capacitar al robot para
tomar decisiones a la hora de evitar el obstáculo en su camino gracias a los algoritmos
que diseñe el propio usuario. A parte de estos algoritmos, pueden implementarse
máquinas de estado, las cuales definirán las condiciones y acciones necesarias en la toma
de decisiones [38].

Figura 2.24: Ejemplo de mapa creado por sensor LiDAR.

Cualquier sistema complejo que se desee analizar, se podrá realizar con la ayuda de apps
y algoritmos, además de visualizar y diseñar el comportamiento del mismo en los
dominios de tiempo y frecuencia. Los sistemas lineales y de control, pueden ajustarse de
manera automática haciendo uso del lugar geométrico de las raíces haciendo uso de
técnicas interactivas, aunque también es posible ajustar algunos controladores de
ganancia especificando algunos objetivos de ajuste como por ejemplo el seguimiento de
referencias, márgenes de estabilidad o anulación de perturbaciones [38].

Finalmente destacar su comunicación y uso de tecnologías digitales, como por ejemplo

de RF entre otras, para la conexión con dispositivos hardware compatibles con
conexiones Bluetooth, TCP/IP, UDP, etc [38].

26
 3. MATLAB APP DESIGNER

Este capítulo va a abordar toda la información referente al software que se ha empleado

para la realización de este proyecto. Por un lado, se estudiará ligeramente el programa
empleado en la realización del proyecto, y, por último, se dedicará gran parte a las
herramientas empleadas en el proyecto, destacando las propiedades más importantes de
las mismas.

3.1 Software

MATLAB App Designer se caracteriza por ser un programa que permite crear apps con
un carácter profesional, con la ventaja de que el usuario de este software no debe ser un
profesional en el campo de diseños de software. La creación de las aplicaciones se divide
en dos partes, por un lado, se encuentra el código, la cual es la parte más importante, ya
que es la que se encargará de ejecutar todas las sentencias y hacer que funcione la
aplicación. Por otro lado, se encuentra la parte visual, que, aunque no posea la misma
importancia que el código cumple un papel importante y es encargarse del aspecto visual.
Aquí el creador puede trabajar con total libertad, explorando los recursos que se ponen a
su disposición y creando aplicaciones visuales de todo tipo haciendo uso de la
imaginación. Esta libertad se debe a la carencia de limitaciones a la hora de crear el
aspecto visual de la aplicación, ya que, cuando se crea la aplicación, el creador tiene a su
disposición un lienzo sobre el que colocar todos los elementos que desee, desplazarlos
donde quiera y cambiar sus tamaños sólo arrastrando el ratón. Además, muchos
componentes se pueden personalizar de una manera sencilla y rápida, gracias a un editor
integrado que se encarga de crear el código correspondiente a estos ajustes de manera
automática [39].
Una gran ventaja al hacer uso de este software es la comprobación automática de errores
en la ejecución del código, ya que hace uso de Code Analyzer, el cual mostrará tanto
mensajes de advertencia como de error mientras se está escribiendo el propio código, para
así optimizar el tiempo de escritura del código, identificando errores muy básicos para
evitar gastar tiempo en localizarlos y corregirlos [39].
Otra de las ventajas que ofrece este programa es la gran variedad de componentes que
puede utilizar el creador, ya sean botones, listas desplegables, editores de campo, tanto
numéricos como alfabéticos, áreas de texto, etc. Todo ello brinda al usuario del software
con un gran abanico de combinaciones entre todos los componentes, de los cuales la gran
mayoría poseen las llamadas funciones Callback. Estas funciones se ejecutan cuando se
interactúa con alguno de los componentes que se encuentren en el área de diseño, y se
encargan de recopilar la información que el usuario introduce en ellas, la cual se empleará
en ocasiones futuras en la ejecución de otras funciones [39].
También hay que mencionar la posibilidad de compartir apps creadas con otros usuarios
de MATLAB. Esto se debe a que es posible empaquetar las apps creadas con este

27
programa y compartirlas mediante MATLAB Desktop y MATLAB Online, estas apps
empaquetadas poseen un único archivo para su instalación, permitiendo así al resto de
usuarios de MATLAB instalar y poder acceder a la aplicación de una forma rápida y
sencilla. A parte de crear este tipo de aplicaciones, permite crear aplicaciones web gracias
a las aplicaciones independientes que se generan al hacer uso de MATLAB Compiler,
permitiendo así empaquetar las mismas como apps web, donde poseerán una dirección
URL exclusiva que será el medio para dar a conocer las aplicaciones, evitando la
instalación de softwares [39].

3.2 Componentes

Este apartado está dedicado a los componentes más empleados en la creación del
proyecto, donde se describirán brevemente cada uno de ellos y se explicarán sus
propiedades más importantes y utilizadas. Existen una gran variedad de componentes,
desde los más comunes, hasta algunos específicos de aeroespacial, pasando por
componentes contenedores y de instrumentación.

3.2.1 Ejes

Los ejes se utilizan para controlar la apariencia y el comportamiento de los datos que
representan, ya sea un conjunto de números como una imagen, que es para lo que se ha
empleado en la elaboración del proyecto. En la Figura 3.1 se muestra cómo se visualiza
este componente en el software.

Figura 3.1: Componente Ejes.

Los ejes son uno de los componentes que mayor número de propiedades posee, por lo que
sólo se destacarán las más utilizadas. En primer lugar, se encuentran las propiedades de
la configuración, las cuales se modifican si el usuario se encuentra en el lienzo del diseño.
Ahí, las propiedades que se pueden modificar son referidas a la parte más visual, como,
por ejemplo, el título del gráfico, el nombre de los ejes, el color de fondo, la fuente
empleada, su tamaño y estilo entre otros. Como en esta app los ejes se usan para mostrar
imágenes, los campos referidos al título o al nombre de los ejes debe estar vacío y el fondo
del mismo debe permanecer en blanco. Por otro lado, se encuentran las propiedades
referidas al inspector, que son las más numerosas y específicas en la personalización del
componente [40]. Las más empleadas han sido las siguientes:

28
• XColor: Es el color que se elige para la línea del eje, los valores de las marcas y las
etiquetas de dirección de x, aunque también puede afectar a las líneas de la cuadrícula.
Para seleccionar el color se puede hacer uso del triplete RGB, entre otros. El triplete
RGB es un vector en el que hay que indicar la intensidad de los colores rojo, verde y
azul, y deben ser valores que se encuentren en un rango entre 0 y 1 [40].

• YColor: Al igual que XColor es el color que se elige tanto para la línea de eje, valores
de marca y etiquetas, pero en este caso en la dirección y. De nuevo, el color se
selecciona con un triplete RGB y su funcionamiento es el mismo que el de XColor
[40].

• ZColor: Posee las mismas características, y realiza las mismas funciones que XColor
e YColor.

• XTickLabel: Esta propiedad es la encargada de etiquetar las marcas de las divisiones

del eje con un conjunto de enteros, caracteres o cadenas. En el proyecto, al querer
evitar que se muestren valores en los ejes, este campo permanece vacío para que no
afecte a la imagen que se muestra como resultado final [40].

• YTickLabel: Cumple las mismas funciones que XTickLabel, siendo su

comportamiento y funcionamiento iguales a este.

• BackgroundColor: Es el color que aparece en el margen que se encuentra alrededor

del área donde se representan los datos, que de nuevo se puede seleccionar mediante
un nombre corto, un código hexadecimal o un triplete RGB [40].

• Position: Se trata de un vector de cuatro posiciones que almacena la ubicación y el

tamaño de los ejes, incluyendo títulos y márgenes. Los dos primeros valores del vector
se refieren a la posición de este rectángulo, y los otros dos valores restantes definen
el tamaño del rectángulo, donde las unidades de los valores se encuentran en píxeles
[40].

3.2.2 Botón
Son componentes que muestran una respuesta cuando el usuario interactúa con ellos, es
decir, cuando el usuario los presiona y suelta posteriormente [41]. Al modificar las
propiedades se confieren diferentes aspectos a la imagen del botón. A continuación, en la
Figura 3.2 se muestra este componente.

Figura 3.2: Componente Botón.

29
Durante el proyecto, este componente se ha utilizado principalmente para finalizar las
acciones de una ventana, por ejemplo, cuando se realiza la búsqueda completa de un
paciente existente; o para continuar realizando acciones en una misma ventana, por
ejemplo, a la hora de registrar un nuevo paciente y se desea generar el código de este. Las
propiedades utilizadas en este componente son pocas, pero se explican a continuación:

• Text: Es lo que se denomina como la etiqueta del botón, es decir, el valor que aparece
en el botón, ya sea un carácter, conjunto de caracteres o números. Si los datos se
representan como una matriz de celdas, el botón poseerá varias líneas de texto [41].

• Enable: Esta propiedad se encarga de mostrar el estado operativo en el que se

encuentra el botón, es decir, está en on o en off. Cuando el estado está en on, significa
que el usuario puede interactuar con el botón, es decir, puede pulsarlo. Pero si, por el
contrario, el botón se encuentra en off, no se permite ninguna interacción, evitando
así que se ejecuten las funciones Callback [41].

• FontWeight: Se encarga de remarcar el texto del botón o no, es decir, la fuente con
la que se haya escrito el texto se podrá poner en “negrita”. Normalmente, el valor de
esta propiedad suele ser normal, es decir, sin remarcar el texto, pero, por el contrario,
si se activa esta opción, su valor pasará a ser bold, que es cuando el texto aparece en
negrita [41].

• Position: Al igual que en el componente anterior, esta propiedad está compuesta por
un vector de cuatro valores. El primero de ellos se denomina left, e indica la distancia
entre la esquina interior izquierda del lienzo y la esquina exterior izquierda del botón.
El siguiente se llama bottom, y se encarga de representar la distancia entre los bordes
inferiores tanto internos como externos del lienzo y del botón respectivamente. A
continuación de este se encuentra el valor width, que es la medida del largo del botón,
es decir, del extremo izquierdo y derecho. Y por último se encuentra el valor de
height, el cual representa la altura del botón, medido desde su borde inferior hasta su
borde superior [41].

3.2.3 Lista desplegable

Este componente, también llamado Drop-Down, cumple como función principal otorgar
un buen aspecto visual y controlar el comportamiento de los elementos de la llista
desplegable [42]. En la Figura 3.3 se muestra este componente.

30
 Figura 3.3: Componente Lista desplegable.

Este componente muestra diferentes opciones para un valor, donde el usuario debe señalar
el que desee. En el proyecto este componente se ha utilizado en la ventana encargada del
registro de un nuevo paciente, en la parte donde se tiene que marcar el lado del cerebro
que se encuentra afectado, dando como opciones Derecho e Izquierdo, como se muestra
en la Figura 3.4.

Figura 3.4: Ejemplo Lista desplegable.

Las propiedades que posee este componente son varias, pero se van a destacar las más
importantes:

• Label: Esta propiedad hace referencia al nombre de la lista desplegable, puede tratarse
de un solo carácter o un conjunto de ellos, o un vector de números [42]. En este caso
en concreto, label posee el nombre de Lado afectado.

• Items: Con este término se hace referencia a los elementos que forman la lista
desplegable, siendo los mismos un conjunto de celdas de vectores compuestos por
caracteres, o un conjunto de cadenas de caracteres [42]. En la lista aparecerán tantos
componentes como opciones se muestren disponibles como posibles respuestas.

• Value: Este elemento es el que primero se muestra en la lista de ítems de la lista

desplegable [42]. Para dar un mejor aspecto visual a esta parte del proyecto este campo
se ha dejado en blanco, para que por defecto aparezca en blanco sin ningún valor
aparente, para así después poder añadir el valor correspondiente al lado afectado,
como se muestra en la Figura 3.5.

31
 Figura 3.5: Value e Items de la Lista desplegable.

• BackgrounColor: Indica el color que se mostrará como fondo, el cual se puede definir
a través del triplete RGB, con un vector hexadecimal o, de la manera más sencilla,
que es seleccionando algunas de las opciones de color que se encuentran enumeradas
en la tabla [42]. Por defecto, el color que aparece es un gris claro, cuyo triplete RGB
es [0.96, 0.96, 0.96] como se muestra en la Figura 3.6.

Figura 3.6: Propiedad BackgroundColor de la

Lista desplegable.

• FontColor: Esta propiedad es la encargada de que la fuente empleada en el texto

posea un color u otro. Al igual que en el apartado anterior, este valor se puede fijar
mediante el triplete RGB, mediante un vector hexadecimal o seleccionando el color
que aparece en una tabla de opciones [42]. Para esta propiedad, el color seleccionado
es el negro, como se muestra en la Figura 3.7. desplegable.

Figura 3.7: Propiedad FontColor de la Lista

desplegable.

• Position: Esta propiedad es la misma que la descrita en apartados anteriores. Se trata

de un vector de cuatro valores, donde los dos primeros hacen referencia a la ubicación
de la lista respecto a los bordes izquierdos e inferiores respecto al lienzo de creación
de la app, y, los otros dos, hacen referencia a las dimensiones que posee esta lista,
tanto referido a su longitud como a su altura.

3.2.4 Editor de campo

Este componente se encarga de que el usuario pueda ingresar datos numéricos o texto
dentro de ellos, donde su aspecto visual está determinado por las propiedades que posee,
las cuales pueden ser modificadas como el usuario desee. En la Figura 3.8 se muestra
este componente, tanto el que permite ingresar datos numéricos como texto.

32
 Figura 3.8: Componente Editor de
campo.

Durante el desarrollo del proyecto se ha hecho uso de este componente varias veces, tanto
en la ventana encargada del registro de un nuevo paciente como en la ventana encargada
de realizar la búsqueda de uno existente, introduciendo datos como el nombre, los dos
apellidos y la edad, y mostrando el código y lado afectado. Por un lado, en la Figura 3.9
se muestran los campos rellenados con los datos necesarios para realizar la búsqueda del
paciente, y, por otro lado, en la Figura 3.10 se muestran los datos resultantes de la
búsqueda.

Figura 3.9: Uso de editores de campo para la

búsqueda del paciente.

Figura 3.10: Uso de editores de campo

para mostrar resultados de la búsqueda.

A continuación, se van a explicar las propiedades más comunes y utilizadas durante el

proyecto:

33
• Label: Es una propiedad que pertenece a la configuración de este componente, y hace
referencia al nombre o etiqueta que recibe el campo de edición. En el proyecto esta
propiedad posee valores como Nombre, Primer apellido, Segundo apellido, Edad,
Código y Lado afectado, como se muestra en la Figura 3.11.

Figura 3.11: Propiedad Label del componente

Editor de campo.

• BackgroundColor: Es la propiedad encargada de proporcionar color al fondo,

pudiendo fijarse mediante un triplete RGB, un vector hexadecimal o seleccionando el
color que se muestra dentro de una gama de selección. Para todos los campos de
edición, el color seleccionado ha sido el blanco [43].

• Value: Es el valor que se encuentra en el campo de edición, ya sea un vector de

caracteres, un carácter único y valores numéricos, y además se muestran en una única
línea [43]. Inicialmente esta propiedad no posee valor alguno, hasta el momento en el
que el usuario introduce los datos necesarios, o, el código asigna algún valor a este
campo, como en la Figura 3.9 y Figura 3.10.

• HorizontalAsignment: Es la propiedad encargada de la alineación del contenido que

aparece dentro del espacio reservado para ello. Existen tres posibilidades, la primera
es situado hacia la izquierda, la opción llamada left, la segunda es de manera centrada,
la opción center, y la última es situada hacia la derecha, la opción llamada rigth [43].
El tipo de alineación afecta a la visualización del contenido según se va introduciendo,
por lo que la opción más óptima es la denominada como left, como se muestra en la
Figura 3.12.

Figura 3.12: Propiedad Alineación horizontal del

componente Editor de campo.

• FontColor: Como se ha explicado en componentes anteriores, es la propiedad

encargada de asignar el color de la fuente empleada en la introducción o muestra de
datos en los campos. La asignación del color se realiza mediante el uso de un triplete
RGB, mediante un vector hexadecimal o seleccionando el color que se encuentra en
la paleta de colores que se muestra. Por defecto, y de manera estándar, el color
seleccionado es el negro.

• Position: Es la propiedad encargada de fijar la ubicación y el tamaño del componente,

igual que las anteriores veces que se ha mencionado. De nuevo posee cuatro valores
en su vector, los dos primeros encargados de almacenar la ubicación del componente
respecto al área de edición, y los otros dos guardan las dimensiones del componente.

34
3.2.5 Etiqueta
Este componente se caracteriza por mostrar en la ventana texto estático, es decir, texto
que no se puede modificar y sirve de guía al usuario durante la ejecución de las ventanas
[44]. En el proyecto se ha utilizado para guiar al usuario durante la introducción de los
datos que eran necesarios ser ingresados. A continuación, en la Figura 3.13 se muestra
este componente, y en la Figura 3.14 se muestra como aparece en una de las ventanas.

Figura 3.14: Componente

Etiqueta

Figura 3.13: Ejemplo del componente Etiqueta

Al igual que todos los componentes, su aspecto visual viene definido por las propiedades
que posee, como las que se indican a continuación.

• Text: Es el texto que se muestra en la etiqueta de manera estática. Está constituido

por un conjunto de caracteres, un único carácter o valores numéricos [44], como se
muestra en la Figura 3.15.

Figura 3.15: Propiedad Text del componente

Etiqueta.

• HorizontalAlignment: Esta propiedad representa la alineación que se desea que posea

el texto de la etiqueta. Como ya se ha mencionado en el componente anterior, posee
tres posibles valores, left, center y right, y, al igual que el componente anterior, se ha
seleccionado la opción de left, puesto que es la que otorga un mejor aspecto visual
[44].

• VerticalAlignment: Además de poder seleccionar la alineación horizontal, se puede

seleccionar la alineación vertical gracias a esta propiedad. También posee tres
opciones de alineación siendo estas: center, la cual proporciona una alineación
centrada, top, que se encarga de alinear el texto en la zona superior del espacio
reservado para la etiqueta, y por último bottom, que alinea el texto en la parte inferior
[44]. Por defecto se selecciona center, y, además, es la que se encuentra definida en el
proyecto, como se muestra en la Figura 3.16.

35
 Figura 3.16: Propiedad VerticalAlignment
del componente Etiqueta.

• FontColor: Esta propiedad ya se ha mencionado en componentes anteriores, por lo

que para evitar redundancia no se volverá a describir la misma, puesto que sus
características y funcionamiento es el mismo que el descrito en apartados anteriores.

• FontSize: Permite modificar el tamaño de la fuente empleada asignando a esta

propiedad un número entero positivo [44]. Además, las unidades de este parámetro son
píxeles y su valor por defecto suele ser 12. Pero a las etiquetas empleadas en el
proyecto se les ha asignado un tamaño de fuente igual a 16 píxeles, para una mejor
visualización, como se muestra en la Figura 3.17.

Figura 3.17: Propiedad FontSize del componente Etiqueta.

• FontWeight: Esta propiedad ya se ha mencionado anteriormente, y es la que se

encarga de otorgar un aspecto diferente a la fuente, remarcando el trazado de la misma
para que se vea una fuente más consistente y con volumen. Esta propiedad se activa
mediante un botón de selección, como se muestra en la Figura 3.18.

Figura 3.18: Propiedad FontWeight

del componente Etiqueta.

• BackgroundColor: En anteriores componentes se ha definido esta propiedad, la cual

es la encargada de proporcionar un color al fondo de la etiqueta mediante un triplete
RGB, un vector hexadecimal o mediante la selección de uno de los colores que se
muestran en una pequeña ventana de selección [44]. Por defecto, en este tipo de
componentes no hay ningún color seleccionado por defecto, es decir, se desea que el
fondo sea transparente, para ello el vector RGB se declara vacío como se muestra en
la Figura 3.19.

Figura 3.19: Propiedad BackgroundColor del componente

Etiqueta.

36
• Position: De nuevo aparece esta propiedad, que se ha mencionado en anteriores
apartados, por lo que para evitar redundancia se omitirá la repetición de este
contenido.

37
 4. DISEÑO DE INTERFAZ

En esta sección se aborda el tema relacionado con la creación de la interfaz, explicando

detalladamente cada una de las ventanas creadas, con sus respectivos códigos.

La interfaz se encarga de establecer la comunicación entre el usuario y el robot, en este

caso se hará uso del robot colaborativo KUKA, como previamente ha sido mencionado
en la introducción de esta memoria. Esta aplicación ha sido diseñada con el objetivo de
realizar de una manera diferente las terapias de rehabilitación realizadas por un
fisioterapeuta para tratar el trastorno motor conocido como espasticidad.

La aplicación posee una sencilla usabilidad, su funcionamiento se reduce a introducir

datos sobre el paciente o simplemente seleccionar diferentes opciones que se proponen.
Posee una ventana de comienzo o de inicio, para posteriormente pasar a la ventana de
selección del tipo de paciente que se va a tratar, es decir, se debe indicar si el paciente
que va a realizar la terapia es nuevo, o, por el contrario, existen datos del mismo.

Si se desea introducir un nuevo paciente, se pedirá al usuario introducir el nombre, los

dos apellidos del paciente, la edad del mismo, y el lateral cerebral que se encuentra
afectado. Una vez introducidos estos datos, se genera un código aleatorio para cada
paciente.

Por otro lado, si el paciente que desea realizar la terapia se encuentra ya registrado, se le
pedirá rellenar los campos correspondientes al nombre, apellidos y edad. Una vez
completados estos campos aparecerá su código personal y su lado afectado.

Una vez seleccionado el paciente a tratar, aparece el menú principal, donde se encuentran
las tres opciones que se pueden realizar, estas son: Evaluación, Rehabilitación y Generar
informe.

4.1. Ventana INICIO

Esta ventana es la más sencilla del programa, consta solo de tres imágenes, que se
encuentran dispuestos en tres ejes diferentes, y de un botón de comienzo. Las imágenes
que se muestran en la ventana son los logotipos de organizaciones implicadas en el
desarrollo de la aplicación.

En primer lugar, en el centro de la ventana se encuentra el logotipo de ROBOESPAS, el

cual es el encargado de desarrollar la actividad de rehabilitación con el robot KUKA. El
grupo está compuesto por varios integrantes, al que cada uno le corresponde una tarea
diferente, entre las que cabe destacar el reconocimiento de movimientos realizados por el

robot, aprendizaje de trayectorias, traducción de la fuerza empleada en los movimientos

a datos numéricos, entre otras actividades.

38
Por otro lado, en la esquina superior izquierda se encuentra el logo de Robotics Lab. Esta
asociación está formada por profesores, investigadores y alumnos pertenecientes a la
universidad Carlos III de Madrid. Allí realizan proyectos de investigación y desarrollo
relacionado con la robótica.

Figura 4.1: Ventana INICIO.

Y, en último lugar, se encuentra el logotipo de la Universidad Carlos III de Madrid, la

cual ha sido la que me ha dado la oportunidad de realizar mis estudios de Ingeniería
Industrial con una excelente formación.
Para poder visualizar las imágenes ha sido necesario colocarlas en ejes, llamados en App
Designer como UIAxes, en los que ha sido necesario ajustar unas determinadas
propiedades para poder visualizar las imágenes correctamente. A parte de ese
componente, en la ventana aparece un botón llamado Button para dar comienzo a la
siguiente pantalla. Para conseguir una fácil localización de cada componente, se ha
renombrado cada uno de ellos.
El eje encargado de mostrar la imagen de Roboespas se ha denominado como
app.Roboespas, el que muestra el logotipo de la universidad se denomina app.UC3M y
finalmente el eje que muestra la imagen de Robotics Lab se llama app.RL. Por último
lugar, el botón recibe el nombre de app.Inicio.

39
 Figura 4.2: Componentes ventana INICIO.

A continuación, se procederá a explicar el código que se ha generado para esta ventana

en concreto. Diferenciando entre propiedades, funciones startup, funciones callback y las
funciones creadas para el desarrollo de la app. Cabe destacar que existe una función que
se genera por defecto cuando se inserta al menos un componente, en ella se reflejan los
ajustes seleccionados para cada componente.

Figura 4.3: Función generada automáticamente con ajustes en eje

app.Roboespas.

Como se observa en la Figura 4.3, esas líneas de código se han generado

automáticamente según se modificaban los datos en los ejes. A continuación, en la Tabla
4.1 se explica brevemente en qué consiste cada línea de código.

40
 CÓDIGO
app.Robospas = uiaxes (app.InicioW)
app.Roboespas.XColor = [1 1 1]
App.Roboespas.XTick = []
App.Roboespas.YColor = [1 1 1]
App.Roboespas.YTickLabel = ‘’
App.Roboespas.BackgroundColor
[1 1 1]
App.Roboespas.Position
Tabla 4.1: Explicación código automático app.Roboespas
EXPLICACIÓN
Los ejes llamados Roboespas se
encuentran en la app llamada InicioW
El color de los ejes de X viene dado por
el vector RGB (red, green, blue), con
valores entre 0 y 1.
Vector con las marcas de graduación
en un orden creciente.
El color de los ejes de Y viene dado por
el vector RGB (red, green, blue), con
valores entre 0 y 1.
Marcación de etiquetas.
= Define el color del fondo de los ejes,
indicando el valor del vector triplete
RGB. En este caso se selecciona el
color blanco.
Vector en el que se encuentran las
coordenadas del eje respecto del
origen de la imagen de la app.

4.1.1 Propiedades
Cada vez que se genera una aplicación, con su respectivo código, ésta se define con una
clase, la cual posee sus propiedades y métodos. En esta app, sólo ha sido necesario crear
una propiedad, a la que se ha llamado PacienteApp, la cual hace referencia a la futura
ventana que se generará una vez pulsado el botón de Inicio, que es la ventana donde se
procederá a seleccionar el tipo de paciente, paciente nuevo o existente.

Figura 4.4: Propiedades ventana INICIO.

4.1.2 Función Startup

Esta función se ejecuta cada vez que se abre un nuevo código, y en ella el usuario decide
qué comandos deben ejecutarse. Por defecto, cada vez que se añade esta función, las
variables principales de la función son app y evento. La variable app hace referencia a la
aplicación que se está ejecutando en ese preciso momento, es decir, en este caso la app
que se ejecuta es INICIO.mlapp. En cuanto a la variable evento, hace referencia a todos

41
los avisos sobre objetos que se han transmitido como respuesta a algo que está
sucediendo.
Dentro de esta función se encuentran las sentencias que se desea que se ejecuten una vez
se realice la llamada a esta función. A continuación, en la Figura 4.5 se visualiza la
función startup de esta ventana con las sentencias correspondientes, y una breve
explicación en forma de comentario, de lo que está ocurriendo.

Figura 4.5: Función Startup de la ventana de INICIO.

Como se observa en la línea 21, se produce la definición de la función, con las variables
de app y evento por defecto, lo cual ha sido explicado en el párrafo anterior. Las líneas
23 y 24 están dedicadas a una breve explicación de lo que se está realizando en esa
función.

La parte importante se sitúa en las líneas siguientes, donde se hace uso de las funciones
imread e imshow. El primer paso consiste en asignar cada imagen a una variable, en este
caso a la variable a se le asigna la imagen ROBOESPAS.jpg, a la variable uni se le asigna
la imagen UC3M.jpg y, finalmente, a la variable rl se le asigna la imagen RL.png. La
elección del nombre de las variables hace referencia, en parte, a la imagen que seleccionan

A continuación, las líneas 27, 30 y 30 del código hacen uso de la función imshow con la
finalidad de mostrar las imágenes en los ejes que se han indicado. Por ejemplo, en la línea
30 para mostrar la imagen UC3M.jpg en los ejes app.UC3M, es necesario escribir el
nombre de la función, es decir, imshow, y colocar entre sus paréntesis el nombre de la
variable que almacena la imagen, siendo en este caso la variable uni, seguido de la
sentencia ‘Parent’ que se encuentra separada por una coma, y volverlo a separar del
nombre de los ejes donde se desea mostrar la imagen con otra coma.

42
Una vez especificados en qué ejes se debe mostrar cada imagen, se finaliza la función
añadiendo la palabra end, que se genera automáticamente al añadir una función strartup.
De esta manera queda finalizada la explicación de este fragmento de código.

4.1.3 Funciones Callback

Cuando se habla del término de función callback, se hace referencia a aquella funcón que
se ejecuta como respuesta ante la acción del usuario al interactuar con elementos que se
encuentran en la ventana de la aplicación. En este código en concreto sólo existe una
función Callback, la cual se ejecuta al pulsarse el botón de Inicio de la ventana. A
continuación, en la Figura 4.6 se muestra la función generada para el botón de Inicio.

Figura 4.6: Función Callback del botón de Inicio en la ventana de INICIO.

Como siempre, en la línea 37 y 43 se encuentran la creación de la función y el cierre de

la misma respectivamente. En todo momento el botón se encuentra activo, hasta el
momento que es pulsado, en el que se desactiva para evitar que vuelva a ser pulsado de
nuevo. Esta acción se encuentra en la línea 39 del código, cuya sentencia es
app.Inicio.Eneable = ‘off’ , donde se accede a la propiedad Eneable del botón Inicio,
consiguiendo así bloquear la realización de más acciones sobre el botón.

También, cuando se pulsa el botón de Inicio, se realiza con la finalidad de pasar a la

siguiente ventana de la aplicación. Para ello es necesario ejecutar el archivo encargado de
esa ventana, el cual es PACIENTE.mlapp y el código para realizar esta acción se
encuentra en la línea 40. En ella se asigna a la propiedad denominada PacienteApp, el
nombre del fichero que contiene el código correspondiente a la siguiente venatana.

Y finalmente, como se abrirá una nueva ventana, se ha de cerrar la existente, para ello se
debe eliminar la aplicación que se está ejecutando en ese momento, en este caso es el
archivo INICIO.mlapp. Al escribir la sentencia de la línea 41 se produce la eliminación
de la app que se está ejecutando en ese momento.

43
 Además de esa función, existe otra que se genera al cerrar la ventana de la aplicación. En
ella lo que se hace de nuevo es proceder a la eliminación de la aplicación, siendo esta
acción una forma de asegurar la completa eliminación de la aplicación que se está
ejecutando en ese momento. Este fragmento de código se visualiza en la Figura 4.7.

Figura 4.7: Función Callback al cerrar ventana INICIO.

4.2. Ventana PACIENTE

La ventana PACIENTE es la encargada de mostrar los dos tipos de pacientes que se

pueden seleccionar, es decir, da la opción de elegir entre un nuevo paciente o seleccionar
uno ya existente. Estas dos opciones son mostradas gracias a dos botones de selección,
que muestran las dos opciones. A parte de encontrar estos elementos, aparecen las mismas
imágenes que se muestran en la ventana de INICIO.

Figura 4.8: Ventana PACIENTES.

44
A continuación, en la Figura 4.8 se muestra una imagen de cómo es esta ventana de
selección. Las imágenes o logotipos que se visualizan en la ventana de opciones ya han
sido explicados en la sección 4.1, evitando así explicar de nuevo cada una de ellas. Al
igual que en la ventana de INICIO, cada imagen se encuentra ligada a un eje, a través del
cual podrá ser visualizada en la ventana. Por tanto, los componentes de esta ventana son
tres ejes, llamados igual que en la ventana de INICIO, es decir, app.Roboespas, app.RL
y app.UC3M, además de dos botones de selección llamados app.NuevopacienteButton y
app.SeleccionarpacienteButton. Estas propiedades se muestran a continuación en la
Figura 4.9.

Figura 4.9: Componentes ventana PACIENTE.

De nuevo, el código de los ajustes realizados sobre estos componentes es generado de

manera automática, y son muy similares a los ya mencionados en la sección 4.1, por lo
que para evitar la existencia de redundancia en el contenido del proyecto se procederá a
suprimir una explicación reiterativa. A continuación, se volverá a dividir el contenido del
código de esta ventana en secciones según el tipo de función empleada.

4.2.1. Propiedades

Al igual que en la sección anterior, esta ventana, al ser definida como una clase, posee
sus métodos y propiedades, ya sean públicos o privados. En este caso, las propiedades
creadas y definidas por el usuario poseen un acceso público, mientras que las que se han
generado automáticamente poseen un acceso privado. Si bien, en la Figura 4.10, se

45
visualiza el código correspondiente a la creación de esas propiedades públicas, las cuales
son InicioApp, NuevoApp y ExistenteApp.

Figura 4.10: Propiedades ventana PACIENTE.

Al igual que siempre, las líneas 14 y 21 delimitan el espacia dedicado a la declaración de

propiedades. Las propiedades declaradas sirven para hacer referencia a la ventana o
ventanas que se desean ejecutar, por ejemplo, en el caso de NuevoApp y ExistenteApp.
Por otro lado, se encuentra la propiedad llamada InicioApp, la cual sirve para indicar la
aplicación con la que se ha realizado la inicialización de la que se está ejecutando.

4.2.2. Función Startup

Cada vez que se ejecuta una ventana por primera vez es necesario que exista una función
Startup, sobre todos en los casos multiventana, como en este proyecto. La ventana que se
ejecuta proviene de otra que anteriormente se estaba ejecutando, y por ello es necesario
hacer referencia a esa app. Esto se va a explicar a continuación, con ayuda de la Figura
4.11, donde se muestra el código correspondiente a esta función de inicialización.

Figura 4.11: Código función Startup de la ventana PACIENTE.

46
Como se ha explicado anteriormente, los parámetros que recibe esta función son la propia
app que se está ejecutando, y la app que ha mandado la ejecución de la misma, en este
caso hace referencia al archivo INICIO.mlapp, donde está orden se visualiza en la línea
40 de la Figura 4.6. A parte, al igual que en la sección 4.1, se dedican unas líneas de
código a la asignación de imágenes a unas determinadas variables, para después proceder
a mostrarlas en los ejes correspondientes.

4.2.3. Funciones Callback

Al añadirse dos botones en la ventana para poder seleccionar el tipo de paciente con el
que se desea trabajar, se llamará a dos funciones callback. Al pulsar la opción de Nuevo
paciente, se ejecutará la función que aparece en la Figura 4.12, que se muestra a
continuación.

Figura 4.12: Función Callback botón Nuevo paciente en ventana PACIENTE.

Cuando se pulsa este botón, la función callback se encarga de asignar a la propiedad

app.NuevoApp el archivo encargado de ejecutar la ventana correspondiente al registro de
un nuevo paciente. Después de producirse la asignación se procede a la eliminación de la
aplicación que se está ejecutando, es decir, la app de PACIENTE.mlapp.
Como se ha mencionado anteriormente, existen dos botones en esta ventana, Nuevo
paciente y Paciente existente. En el párrafo anterior se ha explicado la función callback
perteneciente al botón de Nuevo paciente, a continuación, en la Figura 4.13 se explica la
función callback correspondiente al botón de Paciente existente.

Figura 4.13: Función Callback del botón Paciente existente en ventana PACIENTE.

En esta última imagen se aprecia el código que se ejecuta al pulsar el botón de Paciente
existente. En la línea 57 se produce la asignación a la propiedad app.ExistenteApp del

47
 archivo correspondiente a la ventana de búsqueda del paciente existente, es decir, el
archivo EXISTENTE.mlapp. Y en la línea siguiente, la número 58 se produce la
eliminación de la aplicación que se está ejecutando, que es la misma que en el caso
anterior, la ventana de selección del tipo de paciente, es decir, la app correspondiente al
archivo PACIENTE.mlapp.

4.3. Ventana NUEVO

Esta ventana es la encargada de recopilar los datos del paciente nuevo que se desea
registrar. Estos datos son el nombre, primer y segundo apellido, la edad del paciente y el
lado del cerebro que se encuentra afectado. A continuación, en la Figura 4.14 se visualiza
la ventana que se genera al ejecutarse el archivo correspondiente a NUEVO.mlapp.

Figura 4.14: Ventana NUEVO.

Esta ventana posee diferentes campos a rellenar con los datos pertenecientes al paciente.
Se debe introducir tanto el nombre, como los apellidos, la edad y el lado afectado del
paciente. Una vez ingresados estos datos, se habilita el botón correspondiente a Generar
código, el cual realiza la función de generar un código aleatorio para cada paciente. Este
código está compuesto por cuatro letras mayúsculas y un número perteneciente al rango

48
entre 0 y 9, en total el código está compuesto por 5 dígitos, se explicará más adelante en
la sección 4.3.4 En cuanto al apartado de Observaciones, es un campo voluntario a
rellenar. Por otro lado, se encuentran los componentes utilizados para la creación de esta
ventana, los cuales se pueden observar en la Figura 4.15, los cuales se encuentran
explicados en la Tabla 4.2.

Figura 4.15: Componentes ventana NUEVO.

COMPONENTE
app.NUEVOUIFigure
app.NombreEditField
app.PrimerapellidoEditField
app.SegundoapellidoEditField
app.Codigo
app.ComentariosTextArea
app.IntroduzcalossiguientesdatosLabel
app.GenerarcdigoButton
DESCRIPCIÓN
Ventana donde se mostrará el resto de
elementos.
Campo en blanco para introducir el
nombre del paciente.
Campo en blanco para introducir el
primer apellido del paciente.
Campo en blanco para introducir el
segundo apellido del paciente.
Campo donde aparece el código
generado para cada paciente.
Campo para introducir comentarios.
Etiqueta que contiene texto estático.
Botón para generar el código.

49
 Campo en blanco para introducir la
app.Edad
edad del paciente.
app.Ladoafectado Lista desplegable para seleccionar una
opción
app.TerminarButton Botón para finalizar la ventana.
app.RL Ejes para visualizar la imagen de
Robotics Lab
app.Roboespas Ejes para mostrar la imagen del
logotipo de Roboespas.
app.UC3M Ejes para mostrar la imagen del
logotipo de la universidad.
Tabla 4.2: Descripción componentes ventana NUEVO.

A continuación, se procede a la visualización y explicación del código encargado de la

ejecución de esta ventana.

4.3.1. Propiedades
Al tratarse de una clase, está compuesta por propiedades y métodos. Las propiedades se
visualizan en la Figura 4.16, y los métodos empleados en esta ventana se explicarán más
adelante en la sección 4.3.4.

Figura 4.16: Propiedades ventana NUEVO.

La ventana de NUEVO se ejecuta como consecuencia de la orden mandada por la ventana

anterior, es decir, la de PACIENTE. Es por ello que debe asignarse ese archivo como un
archivo de inicialización, por lo que la ventana debe de poseer una propiedad que se haga
cargo de esta tarea, dicha propiedad es la que se encuentra en la línea 31, llamada

50
 PacienteApp. De igual forma, cuando se pulsa el botón Terminar, se hace con la intención
de abrir una nueva ventana, y para ello es necesario indicar qué ventana se abrirá e indicar
qué propiedad se encargará de ello, por eso, se declara en la línea 33 la propiedad de
PrincipalApp. A parte de estas propiedades, cada valor que es introducido por el usuario,
o valores de los que se quiere guardar su valor, es necesario guardarlos en diferentes
propiedades públicas, para que así todas las funciones puedan hacer uso de sus valores.
Esto se visualiza en las líneas de la 37 a la 42, donde se declaran las propiedades que
hacen referencia a los valores introducidos, como el nombre, los apellidos, la edad y el
lado afectado; o también para almacenar valores como por ejemplo el código generado
para cada paciente.

4.3.2. Función Startup

Al igual que es todos los casos, es necesario una función Startup para poder mostrar las
imágenes de los logotipos en la ventana. Además, es necesario crear un archivo Excel
cada vez que se ejecuta por primera vez la aplicación, en el resto de títulos solo
sobrescribe el encabezado del Excel. A continuación, en la Figura 4.17 se encuentra el
código correspondiente a esta función Startup.

Figura 4.17: Función Startup de la ventana NUEVO.

En la línea 125, se produce la asignación de la app de inicialización, en este caso hace

referencia a PACIENTE.mlapp, a la propiedad de app.PacienteApp. Y después, como en
el resto de funciones Startup, se asignan las imágenes a una serie de variables, para su
posterior visualización en los ejes indicados.

51
Lo que cambia en esta función respecto a las otras se puede apreciar en las líneas desde
la 138 hasta la 142. En primer lugar, se crea la variable header, la cual será el encabezado
del fichero de Excel, con los nombres de Nombre, Apellido 1, Apellido 2, Edad, Código
y L. Afectado. Después se crea el archivo de Excel, con el nombre que se haya elegido,
que en este caso es el de Lista_De_Pacientes.xlsx, y después es necesario añadirle el
vector con el conjunto de nombres que corresponden al encabezado, y de manera opcional
se introduce la página en la que se quieren guardar los datos. Todo esto corresponde la
línea 139 del código. De esta manera se crea un Excel vacío en el caso de que se esté
ejecutando por primera vez la aplicación y no existan datos de ningún paciente. Pero si,
por el contrario, ya existe un fichero Excel, al ejecutarse estas líneas de código lo único
que harán será sobrescribir la primera línea del archivo, es decir, la que corresponde al
encabezado, manteniendo intactos el resto de datos. Y finalmente, en la línea 142, se
desactiva el botón de Generar código con la intención de obligar al usuario a introducir
todos los datos antes de la generación del código.

4.3.3. Funciones Callback

En esta ventana se encuentras numerosas fuciones Callback debido a todos los
componentes con los que puede interactuar el usuario, es decir, por ejemplo, los campos
destinados a la introducción de datos o los botones para realizar acciones. Si seguimos el
orden que hay que seguir para introducir los datos de un nuevo paciente, las funciones
que se ejecutan lo realizan en el orden siguiente.

Figura 4.18: Función Callback del componente NombreEditField.

Esta función se encarga de almacenar en la propiedad app.nombre el valor que ha

introducido el usuario en el campo correspondiente a Nombre para usarlo posteriormente
en el archivo Excel. A parte, se sigue inhabilitando la opción de pulsar el botón de
Generar código, esto se realiza con el fin de evitar errores en la ejecución de la ventana,
ya que es necesario poseer todos los datos del paciente antes de la generación del código.
A continuación, en las siguientes imágenes aparecen los códigos correspondientes al resto
de campos que debe rellenar el usuario con los datos pertenecientes al paciente que se
desea registrar.

52
Figura 4.20: Función Callback del componente PrimerapellidoEditField.

Figura 4.19: Función Callback del componente SegundoapellidoEditField.

Figura 4.22: Función Callback del componente Edad.

Figura 4.21: Función Callback del componente Ladoafectado.

En esta función de la Figura 4.22 se aprecia que en la línea 228 del código se habilita la
opción de poder pulsar el botón Generar código, esto se debe a que la aplicación ya ha
recogido todos los datos necesarios para realizar el registro del nuevo paciente, y estos
datos, como se ha mencionado anteriormente, se encuentran almacenados en las
propiedades de la aplicación, descritas en la sección 4.3.1.
Una de las funciones más importantes es la que se muestra en la Figura 4.23, esta es la
encargada de generar el código para cada paciente una vez que ha sido pulsado el botón
de Generar código. Dentro de esta función Callback, se ejecutan una serie de sentencias
que podrían haberse agrupado en una función y hacer la llamada de la misma al ejecutar

53
 la función Callback, además se hace llamada a la función Rellenar_Lista, la cual se
explica a continuación en la sección 4.3.4.

En primer lugar, la primera sentencia que aparece se encuentra en la línea 177 y es la

encarada de volver a inhabilitar el botón de Generar código, para así evitar que se creen
más de un código por paciente. Como se había mencionado anteriormente, cada código
está compuesto por cinco dígitos, cuatro de ellos son letras y el restante es un número
entre el 0 y el 9, para que sea posible esto se hace uso del código ASCII. Los dígitos que
corresponden a las letras mayúsculas se encuentran en el intervalo entre 65 y 90, ambos
incluidos, ya que el número 65 corresponde con la letra A y el 90 se corresponde con la
letra Z. Por otro lado, en cuanto al dígito numérico, siguiendo el código ASCII, el 0 se
corresponde con el 48, y el número 9 se corresponde con el 57. En la línea 180 se crea un
vector de 4 posiciones que contiene los números aleatorios generados entre 65 y 90, de
igual manera ocurre en la línea 181, se crea un vector de una única posición que posee
ese número aleatorio perteneciente al intervalo entre 48 y 57.

Figura 4.23: Función Callback de GenerarcdigoButton.

Estos valores se almacenarán posteriormente en un vector que será el código del paciente,
pero para ello es necesario antes declarar un vector vacío en el que almacenar estos
valores. Esta acción se observa en la línea 184 de la Figura 4.23 llamando a este vector
vacío con el nombre de code. Una vez creado el código vacío es necesario rellenarlo con
los valores correspondientes, para ello la manera más sencilla de realizarlo es haciendo
uso de un bucle for para recorrer todas las posiciones del vector code, asignando en las
54
cuatro primeras los valores del vector letras, y en la última posición el valor del vector
número. Como el vector de letras está compuesto por números es necesario convertir estos
números en letras haciendo uso del código ASCII, es por ello que se utiliza la función
char.

Una vez generado el código se desea mostrar en el cuadro de texto correspondiente a

Código, lo cual se aprecia en la línea 196 donde se modificar el valor de la propiedad
Value del cuadro de texto para que así muestre el código, y como se desea mostrar el
código como un conjunto en sí se vuelve a hacer uso de la función char. De igual manera,
en la línea 198, se almacena el valor del código en la propiedad correspondiente para ello.

Finalmente, una vez recopilada toda la información respecto al paciente, es hora de

ingresar sus datos en el archivo Excel creado. Para ello se pasan todos los valores a la
función Rellenar_Lista, la cual se encuentra en la línea 201, y que será explicada en la
sección 4.3.4. La última función Callback se ejecuta al pulsar el botón de Terminar, para
así eliminar la función que se ejecutando, y dar la orden de cuál es la nueva que se debe
abrir, esto se puede apreciar en la Figura 4.24.

Figura 4.24: Función Callback del botón Terminar.

Como se ha mencionado anteriormente, una vez que se han introducido todos los datos
correspondientes al registro del nuevo paciente, y se ha generado su código personalizado,
es hora de pasar a la siguiente ventana, lo cual se realiza pulsando el botón Terminar.
Después, es necesario indicar que archivo se debe ejecutar, que en este caso es la ventana
que contiene el menú principal, y se ha llamado PRINCIPAL.mlapp, lo cual se refleja en
la línea 226. Y como siempre, cada vez que se abre una nueva ventana, es necesario que
se elimine la que se está ejecutando, lo cual está escrito en la línea 227.

4.3.4. Otras funciones

En este apartado aparecen las funciones que han sido necesarias ser creadas para el
correcto funcionamiento de la aplicación, es decir, las funciones que no se han generado
de forma automática como las funciones Callback, si no que el autor de la aplicación ha
generado sus propios algoritmos contenidos en la función. El principal ejemplo que existe
en esta ventana es la función llamada Rellenar_Lista, la cual se muestra en la Figura 4.25

55
y Figura 4.26. Han sido necesarias dos imágenes debido a la extensión del código de las
mismas.

Figura 4.25: Primera parte de la función Rellenar_Lista.

Cuando se ejecuta esta función, lo primero que se ha de realizar es la lectura del fichero
Excel y almacenar sus datos en variables, por un lado, en Y se almacenarán todos aquellos
datos de carácter alfabético, ya sean datos de tipo string o tipo char. Y en la variable X se
almacenan todos los valores numéricos que se encuentran en el fichero Excel, como es el
caso de las edades. Todo esto se visualiza en la línea 52. Por otro lado, en la línea 54, se
almacenan las dimensiones de la tabla de Excel adjudicando a la variable f el número de
filas, y a la variable c el número de columnas. Una vez guardados los datos leídos en
Excel, y conocidos el número de filas y de columnas, se realizarán dos bucles for, como
se muestra en las líneas 57 y 58, para así poder guardar los diferentes valores en los
vectores característicos de cada campo. El valor de cada columna se corresponde con cada
campo de los datos característicos, y el número de filas indica el número de pacientes,
excepto la primera línea que contiene el encabezado del archivo Excel. Por tanto, el valor
de las columnas varía entre 1 y 6. El orden de las variables es Nombre, Apellido1,
Apellido2, Edad, Código y L. Afetado, por lo que la forma de recorrer la matriz es
seleccionar una columna y almacenar todos los vectores, seleccionar una nueva columna,
y almacenar los valores en un vector nuevo, y así hasta completar la matriz, que es lo que

56
 ocurre de la línea 57 a la 78. En especial hay que destacar las líneas de la 67 a la 70,
puesto que como se había mencionado antes, la variable X se encarga de almacenar los
datos numéricos, mientras que, Y almacena el resto, así que es necesario que el primer
valor del vector edades sea el título del encabezado, por eso se almacena como string, y
el resto de valores se corresponde con el listado de edades.

Una vez creados los vectores con los datos de los pacientes existentes es necesario añadir
los nuevos datos del paciente. Para ello se aumenta en una posición cada vector y se
almacena en esa última posición los parámetros que recibe la función, que es lo que ocurre
entre las líneas 81 y 86 como se muestra en la Figura 4.26.

Figura 4.26: Segunda parte de la función Rellenar_Lista.

Una vez definidos los vectores con los datos correspondientes es el momento de
sobrescribir los datos de la tabla de Excel, para ello es necesario transponer los vectores
para que se escriban en sentido vertical. Además, a cada vector le corresponde una
columna de la hoja Excel, es por ello que de las líneas 89 a 94 se le adjudica una letra
diferente a cada vector. Con estas últimas sentencias ya quedaría actualizada la hoja de
Excel.

4.4. Ventana EXISTENTE

Esta ventana es la encarga de buscar al paciente que coincide con los datos que está
ingresando el usuario, dentro del archivo Excel. Para ello es necesario ingresar el nombre
y los dos apellidos del paciente, a parte de su edad, y ya la aplicación se encarga de

57
 facilitar otros datos como el código y el lado afectado. En la Figura 4.27, se muestra la
ventana que se ejecuta a la hora de seleccionar un paciente existente.

Figura 4.27: Ventana EXISTENTE.

Como siempre, aparecen los logotipos más relevantes del proyecto, que son el de Robotics
Lab, Roboespas y el logotipo de la universidad. Para poder realizar una búsqueda correcta
se deben ingresar en el orden siguiente el nombre del paciente, seguido de sus apellidos
y por último su edad, de esta forma el botón de Buscar se desbloquea, permitiendo así
visualizar el código y lado afectado del paciente. Una vez mostrados todos los datos del
paciente se debe pulsar el botón Siguiente. A continuación, en la Figura 4.28 se muestra
el listado de los componentes empleados en la creación de la ventana.
Los componentes empleados son básicamente los mismos que en la sección 4.3, hay ejes
para poder mostrar las imágenes, campos de texto para introducir datos y para mostrarlos
y botones para así poder interactuar con la aplicación.

58
 Figura 4.28: Componentes ventana EXISTENTE.

4.4.1. Propiedades
Como en todas las ventanas, debe existir una propiedad a la que se le asigne la app de
inicialización y otra encargada de que le sea asignada la próxima aplicación que se desea
ejecutar. Además, todos los datos que son ingresados por el usuario deben almacenarse
en variables que puedan ser utilizadas por todas las funciones, para ello lo mejor es utilizar
propiedades de acceso público como se muestra en la Figura 4.29.

Figura 4.29: Propiedades de la ventana EXISTENTE.

4.4.2. Función Startup

Cada vez que se ejecuta un archivo de aplicación, se crea la app y, por consiguiente, existe
una función que se ejecuta debido a la creación de esta. A lo largo de todo el proyecto,
las funciones Startup no varían unas de otras, comparten las mismas características, las
cuales son la lectura de imágenes en diferentes variables, para su posterior visualización
en los ejes, como se muestra en la Figura 4.30.

59
 Figura 4.30: Función Startup de la ventana EXISTENTE.

Además de la visualización de imágenes, en la línea 167 se puede apreciar la asignación

de la aplicación de inicialización a la propiedad llamada PacienteApp, que hace posible
la ejecución del archivo. También se inhabilita el botón de Buscar, que se puede ver en
la línea 169, para que no ocurran errores durante la búsqueda, este botón no se
desbloqueará hasta que se hayan rellenado todos los campos necesarios.

4.4.3. Funciones Callback

Las principales funciones Callback de esta sección se centran en los campos que son
rellenados por el usuario como por ejemplo lo es el nombre, los apellidos y la edad del
mismo, a parte de la interacción con otros elementos como los botones para avanzar a
otros pasos. Pero para una correcta búsqueda es necesario rellenar los campos por orden,
y de esta misma manera se van a explicar las funciones de llamada. En primer lugar, se
encuentran los campos que son necesarios rellenar por el usuario, y el primero de todos
ellos es el nombre, como se muestra en la Figura 4.31.

60
Figura 4.31: Función Callback del componente NombreEditField.

Como se observa en la línea 186 se produce la asignación del valor introducido por el
usuario a la propiedad denominada como Nombre, con la finalidad de que posea un acceso
público para que pueda ser usado por diferentes funciones. A parte, otra sentencia que
aparece en el código se encuentra en la línea 189, la cual es la encargada de inhabilitar el
botón Buscar, para así evitar llamar a la función Callback del mismo. Al igual que en la
sección 4.3.3 se mostrarán las tres funciones Callback que son bastante similares a la
Figura 4.31.

Figura 4.32: Función Callback del componente Apellido1EditField.

Figura 4.33: Función Callback del componente Apellido2EditField.

Figura 4.34: Función Callback del componente EdadEditField.

61
 En la Figura 4.34, lo único que cambia con respecto el resto de sentencias es que en la
línea 237 se habilita el botón de Buscar, siempre y cuando antes se haya introducido el
valor de la edad. Una vez almacenados todos los datos necesarios para realizar la
búsqueda, es el momento de pulsar el botón Buscar, el cual posee una función Callback
en la que se hará llamada a otras funciones necesarias para realizar la búsqueda del
paciente. Por tanto, la siguiente función Callback se encuentra en la Figura 4.35.

Figura 4.35: Función Callback del botón Buscar.

Una vez pulsado el botón de Buscar se llama a las funciones encargadas de localizar la
posición del paciente en la tabla de Excel. En la línea 217, la función se encarga de
devolver un vector con todas las posiciones de los nombres que coinciden con el nombre
del paciente buscado. Lo mismo ocurre en las líneas 218, 219 y 220, siendo en esta última
línea donde el valor que se recibe es único, y no un vector de varios posibles pacientes,
todas estas funciones se encuentran explicadas más adelante en la sección 4.4.4.
A continuación, en la línea 223 se vuelve a inhabilitar el botón de Buscar, ya que solo es
necesario una búsqueda por paciente. El siguiente paso es obtener tanto el código como
el lado afectado del paciente, para ello se llama a las funciones Buscar_Codigo y
Buscar_Lado, y se les pasa el valor que corresponde a la posición que ocupa el paciente
en la lista de Excel para así identificar su código y lado afectado, pero como son funciones
definidas y desarrolladas por el creador de la interfaz se explicarán en la sección 4.4.4.
La última función Callback se encuentra en la Figura 4.36, la cual corresponde a la acción
de pulsar el botón de Siguiente. Esta función sólo se encarga de asignar a la propiedad
PrincipalApp el fichero que debe ejecutar, que es lo que se muestra en la línea 247, y
además se procede a la eliminación de la aplicación que se está ejecutando en ese
momento. Con estas últimas sentencias finalizan todas las funciones Callback de esta
sección.

62
 Figura 4.36: Función Callback del componente SiguienteButton.

4.4.4 Otras funciones

En este apartado se van a explicar todas las funciones que han sido desarrolladas por el
creador, haciendo especial hincapié sobre las que están destinadas a realizar la búsqueda
de los datos del paciente. Es de vital importancia aclarar que los parámetros necesarios
para realizar la búsqueda son el nombre, los dos apellidos y la edad, esto se debe a que
resulta más fácil introducir datos como la edad en vez del código del paciente, que puede
suponer cierta dificultad a la hora de recordar su composición. Así mismo, resulta un tanto
remota la posibilidad de que en el listado existan dos personas que se llamen exactamente
igual y posean la misma edad, aunque nunca se puede descartar la posibilidad de realizar
una interfaz mucho más detallada y minuciosa. En primer lugar, la función que da
comienzo a la búsqueda del paciente es la que se ha denominado Buscar_Nombre, la cual
se muestra en la Figura 4.37.

Figura 4.37: Función Buscar_Nombre.

En esta función lo primero que se hace es proceder a la lectura y almacenamiento de los

datos que se encuentran en el fichero Excel, como se observa en la línea 47. Además, en
la línea 49, se produce la asignación a las variables f y c de las dimensiones del Excel,
para así conocer el número de pacientes que se encuentran registrados. Una vez conocido
el número de celdas que componen el listado de pacientes se procede a la búsqueda del
nombre. Como la variable Y no sólo tiene almacenados los nombres de los pacientes, si
no que, en la primera posición se encuentra el título de la celda, el bucle for se empieza a
ejecutar desde la segunda posición, para así comenzar la búsqueda por el primer nombre.
Dentro del bucle se hace uso de la función strcmp, para comparar el parámetro que se
63
 pasa por referencia a la función, es decir, el nombre introducido por el usuario, y se
comparara con cada nombre de la lista. Hay creado un vector, ok_nombres, donde se
almacenan los resultados de la comparación, si los nombres coinciden se almacena un 1,
pero si por el contrario no coinciden, el valor almacenado es un 0. Al finalizarse del bucle
for, el resultado debe ser un vector cuya longitud sea equivalente al número de pacientes,
y debe estar compuesto por 1 y 0. Después, el paso siguiente es localizar las posiciones
del vector donde haya 1, para ello se hace uso de la función find, como se indica en la
línea 60, devolviendo como resultado un vector cuya longitud será igual al número de
pacientes cuyo nombre coincida con el introducido en la búsqueda, y el valor de sus
componentes corresponde a las posiciones que ocupan en la lista los nombres
coincidentes, es decir, el vector que devuelve esta función es el llamado como
Posicones_Nombre.
Una vez conocidas las posiciones de los nombres coincidentes con el de la búsqueda, el
siguiente paso es detectar cuáles de esos nombres contienen el primer apellido que se
desea buscar, modificando así el vector Posiciones_Nombre. En la Figura 4.38 se
muestra el código de la función encargada de localizar el primer apellido, la cual se llama
Buscar_Apellidos1.

Figura 4.38: Función Buscar_Apellidos1.

Al igual que en la función Buscar_Nombres, es necesario leer el fichero de Excel y

almacenar los valores en las variables X e Y, para así poder conocer sus dimensiones por
medio de las variables f y c, como se muestra en las líneas 70 y 72. En la línea 74 a aparece
la variable m, cuya función es hacer de contador incrementando en una unidad cada vez
que el nombre y apellido que coinciden con los de la búsqueda. La sentencia que se
encuentra en la línea 78 es un poco compleja por lo que se explicará poco a poco.

64
 En primer lugar, ok_apellidos1 es un vector de la misma longitud que el vector que recibe
por parámetro llamado lista_nombres, y además estará compuesto de 0 y 1 como
resultado de la función strcmp. Los valores que se compararán serán el primer apellido
introducido por el usuario y los valores que se encuentran en la segunda columna de la
matriz Y, los cuales corresponden a los primeros apellidos, y la variable i se utiliza para
recorrer la matriz fila por fila. En vez de usar la función find, se irá comparando cada
valor del vector ok_apellidos1, y si algún valor es igual a 1 se incrementará el valor de
m, la cual decidirá el tamaño del vector Posiciones_Apellidos1 y se le asignará el valor
de la posición del o de los pacientes cuyos nombres y apellidos coinciden con los
introducidos por el usuario. El funcionamiento de la función Buscar_Apellidos2, la cual
se muestra en la Figura 4.39, es prácticamente igual que la función descrita
anteriormente, la única variación es que la búsqueda se realiza en la tercera columna de
la matriz Y, la cual corresponde a la lista de los segundos apellidos de los pacientes
registrados.

Figura 4.39: Función Buscar_Apellidos2.

El último valor que hay que buscar es la edad, y como tal, el resultado que se debe obtener
tras su búsqueda debe ser único, puesto que los datos pertenecen a un solo paciente. A
continuación, en la Figura 4.40, se muestra la función encargada de buscar la edad. Como
todas las veces que se realiza una búsqueda, es necesario tener el conjunto de datos sobre
los que se desea realizar la búsqueda, para ello, como se muestra en la línea 114, se
procede a leer y almacenar los datos leídos en variables, en este caso, al tratarse de datos
numéricos la variable con la que se trabaja es la X. Además, los datos leídos se almacenan
como un vector vertical, y para trabajar con ellos deben encontrarse de manera horizontal,
por ello, en la línea 115 se hace uso de la función transpose.
Por otro lado, el valor que se pasa por referencia es la edad que ha introducido el usuario,
que, a pesar de tratarse de un número, el código lo recibe como un dato de tipo string, así
que, para poder buscar correctamente la edad es necesario cambiar el formato del dato,
que es lo que ocurre en la línea 116. Una vez se tenga la edad en el formato correcto, es
el momento de buscar al paciente. Lo primero es buscar, dentro del conjunto de pacientes
que son candidatos a ser el buscado, la edad deseada, para ello se recorre el vector que
65
contiene las posiciones de esos candidatos, que es lo que ocurre en la línea 120. Por otro
lado, durante la comparación, es necesario explicar la línea 122, donde al vector
lista_apellidos2 se le reduce su valor en una unidad, es decir, este vector contiene las
posiciones que ocupan los pacientes en la lista contando como primera posición el título
del encabezado. Pero el vector X cuenta como primer valor la edad del primer paciente,
sin tener en cuenta el título del encabezado, es por ello por lo que al vector
lista_apellidos2 se le reduce su valor en una unidad, con el fin de que coincidan las
posiciones del vector X y lista_apellidos2.
Cada vez que se produzca una coincidencia el valor de m aumentará en una unidad, pero
siempre alcanzará el valor de 1 y no más puesto que solo debe haber un resultado. Como
resultado de la búsqueda, en el vector Posición_Edad se almacena el lugar donde se
encuentra registrado el paciente, finalizando así la función encarada de buscar la edad.

Figura 4.40: Función Buscar_Edad.

Una vez localizado al paciente, se deben mostrar sus datos en la ventana, pero para ello
primero se deben conocer estos datos. Se tienen que localizar haciendo uso del valor
devuelto por la función anterior, como se muestra en la Figura 4.41. Lo primero es
almacenar los datos extraídos del Excel en una variable, que es lo que se muestra en la
línea 137. Y seguidamente se asigna a la variable Codigo el valor que se encuentra en la
columna 5, la cual corresponde a la lista de códigos, y la fila donde se encuentra el
paciente, que es el valor que se ha obtenido de la función Buscar_Edad.

66
 Figura 4.41: Función Buscar_Codigo.

Para obtener el valor del lado afectado, se hace uso de la función que se encuentra en
Figura 4.42, la cual es igual a la encargada de buscar el código, la única variación que
existe es la columna donde realiza la búsqueda, que en este caso es la número 6, la que
corresponde al listado de lados afectados.

Figura 4.42: Función Buscar_Lado.

4.5. Ventana PRINCIPAL

En esta ventana se encuentra el menú principal de selección de opciones, donde el

paciente podrá realizar sus terapias de rehabilitación, o se podrá evaluar su limitación de
movilidad y se podrá generar un informe con los datos sobre el estado del paciente. La
ventana correspondiente a este menú se visualiza en la Figura 4.43, donde aparecen los
tres logotipos esenciales del proyecto, junto con los botones de selección
correspondientes.
Cada elemento de la ventana corresponde a un componente empleado en la creación de
la misma. Los que aparecen en todas las ventanas son los ejes, llamados UIAxes, que son
los que se encargan de mostrar las imágenes, haciéndose cargo cada uno de ellos de una
imagen. Además, cada botón que aparece en la ventana para interactuar con ellos es un
componente de la aplicación, por lo que existen tres elementos Button. Todos estos
elementos se muestran en la Figura 4.44.

67
Figura 4.44: Ventana PRINCIPAL.

Figura 4.43: Componentes ventana PRINCIPAL.

4.5.1. Propiedades

En esta ventana, las propiedades que se han creado sólo se encargan de que se les sea
asignadas los archivos correspondientes a las ventanas que se desean ejecutar y que
corresponden con la opción seleccionada. Como esta ventana se ejecuta tanto si se ha
introducido un nuevo paciente, como si se ha seleccionado uno existente, poseerá dos

68
aplicaciones de inicialización, cada una correspondiente con la ventana de la que
provienen, es decir, si el menú principal se abre después de introducir un nuevo paciente,
la propiedad NuevoApp recibirá esta aplicación como la de inicialización. Estas
propiedades se muestran en la Figura 4.45.

Figura 4.45: Propiedades ventana PRINCIPAL.

Esta misma función la cumple la propiedad ExistenteApp, la cual recibirá el archivo

EXISTENTE.mlapp como aplicación de inicialización. Por otro lado, se encuentran las
propiedades definidas en las líneas 20, 21 y 22, cuya función es recibir los archivos que
se desean ejecutar, como se verá en la sección 4.5.3.

4.5.2. Función Startup

En el diseño de esta interfaz siempre habrá funciones Startup ya que en todas las ventanas
se muestran imágenes gracias a la ayuda del componente UIAxes. Esta ventana presenta
una gran sencillez, por lo que su función Startup no presenta una gran complejidad, como
se muestra en la Figura 4.46.

Figura 4.46: Función Startup de la ventana PRINCIAPAL.

69
En primer lugar, cuando se crea la función le llegan dos parámetros, uno referido a la
aplicación que se está ejecutando, es decir, el archivo PRINCIPAL.mlapp será lo que se
llama como app, y por otro lado aparece el parámetro inicioapp, el cual corresponde al
fichero que ha mandado la ejecución de la ventana. Tanto el archivo NUEVO.mlapp como
el archivo EXISTENTE.mlapp, serán esas aplicaciones de inicialización como se indica
en las líneas 31 y 32. Por otro lado, igual que en el resto de funciones Startup, a las
variables denominadas como a, uni y rl se les asigna y almacena en las líneas 34, 37 y 40
las imágenes que se desean mostrar, para posteriormente mostrarlas en los ejes
correspondientes, es decir, el eje app.Roboespas para la variable a, el eje app.UC3M para
la variable uni y el eje app.RL para la variable rl. De esta manera queda finalizada la
función Startup.

4.5.3 Funciones Callback

Esta ventana es el menú principal de selección de opciones de las acciones que se desean
realizar, cuenta para ello con tres botones de selección donde cada uno de ellos posee una
función Callback que se ejecuta al pulsarse el botón correspondiente. Si por ejemplo se
pulsa el botón de Evaluación, la función Callback que se ejecutará es la que se muestra
en la Figura 4.47.

Figura 4.47: Función Callback del botón Evaluación.

En estas funciones Callback, lo único que ocurre es la asignación a la propiedad

correspondiente del archivo que se debe ejecutar al haber seleccionado esa opción, es
decir, como se ha pulsado el botón correspondiente a la evaluación a la propiedad
EvaluacionApp se le asigna el archivo correspondiente a la evaluación del paciente, que
por simplicidad y sencillez se ha denominado EVALUACION.mlapp. De igual manera
ocurre al pulsar el botón de Rehabilitación, como se muestra en la Figura 4.48, y con el
botón de Generar informe en la Figura 4.49.

70
Figura 4.48: Función Callback del botón Rehabilitación.

Figura 4.49: Función Callback del botón Generar informe.

71
 5. CONCLUSIONES

Una vez finalizado el proyecto, y realizadas todas las pruebas necesarias, se llega a las
siguientes conclusiones. En primer lugar, y como se mencionó en el capítulo 2 y 3, el
hecho de haber utilizado MATLAB en este proyecto, y en concreto, haber usado
MATLAB App Designer, permite desarrollar el proyecto con una amplia variedad de
elementos y de ajustes y configuraciones que permiten crear un proyecto con un alto nivel
de personalización, dejando atrás resultados que posean un aspecto clásico y sencillo.
Dentro del entorno de MATLAB App Designer, cabe destacar que al comienzo de usar
este software, se encontraron numerosas dificultades, ya que se trataba de un software
totalmente desconocido y el periodo de habituación y comprensión del programa se alargó
mínimamente más de lo esperado, aunque gracias a diversos videos colgados en Internet
donde se explicaba detalladamente la ejecución de diferentes acciones para obtener
resultados como por ejemplo, la creación de ventanas múltiples, mostrar imágenes en
ejes, el funcionamiento de algunas de las propiedades de los componentes que ofrece este
software, etc.
Por otro lado, como se explicó en capítulos diferentes, la elaboración de la aplicación se
divide en dos partes. Primero se encuentra la parte encargada del diseño y aspecto visual
que poseerá la aplicación, donde se encuentran todos los componentes. Esta parte ha
resultado sencilla, puesto que la inserción de los componentes en el área de diseño era
muy sencilla, sólo había que arrastrar los componentes a la zona deseada y modificar su
diseño. Dentro del diseño, se podían modificar algunas propiedades, las cuales eran muy
sencillas y directas, no entraban en campos de difícil comprensión, es decir, se podían
modificar propiedades como el nombre, colores de fondo, tamaño de la letra, y demás.
En segundo lugar, se encuentra la parte encargada del código que se ejecutará durante la
aplicación. Esta parte no puede catalogarse como fácil ni difícil, ya que el lenguaje usado
durante la programación de las diferentes ventanas es lenguaje de MATLAB, del cual se
poseían conocimientos previos debido a haber cursado anteriores asignaturas donde se
hacía uso de este lenguaje, se conocían la mayoría de las funciones empleadas en el
proyecto y del resto de sentencias usadas. La parte más complicada fue el hecho de cómo
acceder a algunas de las propiedades que poseen los componentes, cómo son las
sentencias necesarias para ello, y qué significan algunas de las propiedades que aparecen
en cada componente. Además, como se ha mencionado anteriormente, ha sido necesario
consultar algunos video tutoriales sobre qué sentencias usar y cómo escribirlas para poder
modificar estas propiedades haciendo uso del código, así como visitar diversos algunos
blogs de usuarios para realizar breves consultas.
Finalmente, hay que hacer una mención especial a la finalización de la aplicación, la cual
podría haber sido más compleja y se hubiese completado hasta el final, indagando un
poco en el código de las ventanas responsables de la Evaluación, Rehabilitación y
Generación del informe. Esto se debe a la ausencia de unas funciones necesarias para
poder controlar al robot, las cuales no han podido ser incluidas debido a la falta del código,
el cual no era de mi responsabilidad, si no que era complementario.

72
 6. BIBLIOGRAFÍA

[1] “Tecnología Informática”, “es.wikipedia.org”

https://es.wikipedia.org/wiki/Tecnolog%C3%ADa_inform%C3%A1tica (Acceso:
22 de agosto de 2019)

[2] Real Academia Española, “www.rae.es”

https://dle.rae.es/?id=YErlG2H (Acceso: 24 de agosto de 2019)

[3] Real Academia Española, “www.rae.es”

https://dle.rae.es/?id=Lu1HQaO (Acceso: 24 de agosto de 2019)

[4] “¿Qué es la experiencia de usuario?”. 40 de Fiebre.

https://www.40defiebre.com/que-es/experiencia-usuario (Acceso: 25 de agosto de
2019)

[5] “User Experience Basics”.Usability.gov.

https://www.usability.gov/what-and-why/user-experience.html (Acceso: 25 de
agosto de 2019)

[6] “Experiencia de usuario”, “es.wkipedia.org”

https://es.wikipedia.org/wiki/Experiencia_de_usuario#Dise%C3%B1o_de_interfaz
(Acceso: 25 de agosto de 2019)

[7] “Espasticidad”, “es.wikipedia.org”

https://es.wikipedia.org/wiki/Espasticidad (Acceso: 27 de agosto de 2019)

[8] “Definición de deamulación”, Definición.de

https://definicion.de/deambulacion/ (Acceso: 27 de agosto de 2019)

[9] “Espasticidad”, Medline Plus

https://medlineplus.gov/spanish/ency/article/003297.htm (Acceso: 28 de agosto de
2019)

[10] “La espasticidad: un trastorno multidisciplinar”. Sunrise Medical

https://www.sunrisemedical.es/blog/espasticidad (Acceso: 28 de agosto de 2019)

[11] “LBR IIWA – El primer robot colaborativo y sensible con el Humano”. Autracen
http://www.autracen.com/lbr-iiwa/ (Acceso: 29 de agosto de 2019)

[12] “MATLAB”. EcuRed

https://www.ecured.cu/MATLAB (Acceso: 30 de agosto de 2019)

73
[13] “The Origins of MATLAB”. MathWorks
https://es.mathworks.com/company/newsletters/articles/the-origins-of-matlab.html
(Acceso: 30 de agosto de 2019)

[14] https://es.wikipedia.org/wiki/MATLAB#MATLAB (Acceso: 30 de agosto de 2019)

[15] https://www.ecured.cu/Lenguaje_interpretado (Acceso: 30 de agosto de 2019)

[16] https://es.wikipedia.org/wiki/MATLAB#Lenguaje (Acceso: 30 de agosto de 2019)

[17]
https://es.mathworks.com/help/matlab/ref/imread.html?searchHighlight=imread&s_t
id=doc_srchtitle (Acceso: 30 de agosto de 2019)

[18]
https://es.mathworks.com/help/matlab/ref/imshow.html?searchHighlight=imshow&s
_tid=doc_srchtitle (Acceso: 30 de agosto de 2019)

[19]
https://es.mathworks.com/help/matlab/ref/delete.html?searchHighlight=delete&s_tid
=doc_srchtitle (Acceso: 30 de agosto de 2019)

[20]
https://es.mathworks.com/help/matlab/ref/xlswrite.html?searchHighlight=xlswrite&s_ti
d=doc_srchtitle (Acceso: 30 de agosto de 2019)

[21] https://es.mathworks.com/help/matlab/ref/xlsread.html?s_tid=doc_ta
(Acceso: 30 de agosto de 2019)

[22]
https://es.mathworks.com/help/matlab/ref/randi.html?searchHighlight=RANDI&s_ti
d=doc_srchtitle (Acceso: 30 de agosto de 2019)

[23]
https://es.mathworks.com/help/matlab/ref/for.html?searchHighlight=for&s_tid=doc
_srchtitle (Acceso: 30 de agosto de 2019)

[24]
https://es.mathworks.com/help/matlab/ref/char.html?searchHighlight=char&s_tid=d
oc_srchtitle (Acceso: 30 de agosto de 2019)

[25]
https://es.mathworks.com/help/matlab/ref/readtable.html?searchHighlight=readtable
&s_tid=doc_srchtitle (Acceso: 30 de agosto de 2019)
[26]
https://es.mathworks.com/help/matlab/ref/switch.html?searchHighlight=switch&s_ti
d=doc_srchtitle (Acceso: 30 de agosto de 2019)

74
[27]
https://es.mathworks.com/help/matlab/ref/transpose.html?searchHighlight=transpos
e&s_tid=doc_srchtitle (Acceso: 30 de agosto de 2019)

[28] https://es.mathworks.com/help/matlab/ref/strcmp.html?s_tid=doc_ta (Acceso: 30 de

agosto de 2019)

[29]
https://es.mathworks.com/help/matlab/ref/find.html?searchHighlight=find&s_tid=do
c_srchtitle (Acceso: 30 de agosto de 2019)

[30]
https://es.mathworks.com/help/matlab/ref/length.html?searchHighlight=length&s_ti
d=doc_srchtitle (Acceso: 30 de agosto de 2019)

[31]
https://es.mathworks.com/help/matlab/ref/if.html?searchHighlight=if&s_tid=doc_sr
chtitle (Acceso: 30 de agosto de 2019)

[32]
https://es.mathworks.com/help/matlab/ref/string.html?searchHighlight=string&s_tid
=doc_srchtitle (Acceso: 30 de agosto de 2019)

[33] https://es.mathworks.com/solutions/data-science.html (Acceso: 3 de septiembre de

2019)
[34] https://es.mathworks.com/solutions/wireless-communications.html (Acceso: 3 de
septiembre de 2019)
[35] https://es.mathworks.com/solutions/deep-learning.html (Acceso: 3 de septiembre de
2019)
[36] https://es.mathworks.com/solutions/image-video-processing.html(Acceso: 5 de
septiembre de 2019)
[37] https://es.mathworks.com/solutions/dsp.html (Acceso: 8 de septiembre de 2019)
[38] https://es.mathworks.com/solutions/robotics.html (Acceso: 10 de septiembre de
2019)
[39] https://es.mathworks.com/products/matlab/app-designer.html (Acceso: 11 de
septiembre de 2019)
[40] https://es.mathworks.com/help/matlab/ref/matlab.ui.control.uiaxes-properties.html
(Acceso: 12 de septiembre de 2019)
[41] https://es.mathworks.com/help/matlab/ref/matlab.ui.control.button-properties.html
(Acceso: 12 de septiembre de 2019)
[42]https://es.mathworks.com/help/matlab/ref/matlab.ui.control.dropdown-
properties.html (Acceso: 13 de septiembre de 2019)

75
[43] https://es.mathworks.com/help/matlab/ref/matlab.ui.control.editfield-
properties.html (Acceso: 13 de septiembre de 2019)
[44] https://es.mathworks.com/help/matlab/ref/matlab.ui.control.label-properties.html
(Acceso: 13 de septiembre de 2019)

76