gestión de procesos de producción · 2014-12-02 · para la gestión de procesos de producción...
TRANSCRIPT
Ofelia Moral Echarri
Laureano Lambán Pardo
Facultad de Ciencias, Estudios Agroalimentarios e Informática
Grado en Ingeniería Informática
2013-2014
Título
Director/es
Facultad
Titulación
Departamento
TRABAJO FIN DE GRADO
Curso Académico
Gestión de procesos de producción
Autor/es
© El autor© Universidad de La Rioja, Servicio de Publicaciones, 2014
publicaciones.unirioja.esE-mail: [email protected]
Gestión de procesos de producción, trabajo fin de gradode Ofelia Moral Echarri, dirigido por Laureano Lambán Pardo (publicado por la
Universidad de La Rioja), se difunde bajo una LicenciaCreative Commons Reconocimiento-NoComercial-SinObraDerivada 3.0 Unported.
Permisos que vayan más allá de lo cubierto por esta licencia pueden solicitarse a los titulares del copyright.
1
Facultad
Facultad de Ciencias, Estudios Agroalimentarios e Informática
Titulación
Grado en Ingeniería Informática
Título Gestión de procesos de producción
Autor/es
Ofelia Moral Echarri
Tutor/es
Laureano Lambán Pardo
Departamento
Matemáticas y Computación
Curso académico
2013-2014
2
Agradecimientos____________________________
En primer lugar quisiera agradecer todo el empeño, el tiempo y la dedicación que han puesto
mis tutores, Asier Tarancón y Laureano Lambán, en ayudarme en este proyecto.
También, me gustaría dar las gracias por lo bien que me han tratado tanto a la empresa de
Masscomm como a la de WAF. Entre todos ellos, mencionar a mi tutor, Borja Reinares y a mis
compañeros de prácticas, que han estado ayudándome, aguantándome y de los que he
aprendido mucho.
Por último, agradecer estos años a mi familia, compañeros y amigos que han estado siempre
apoyándome.
3
Contenido Resumen/Abstract ................................................................................................... 5
Introducción ............................................................................................................. 7
Contexto y objetivos ................................................................................................................. 7
Metodología .............................................................................................................................. 8
Tecnologías a emplear ............................................................................................................ 10
Gestión del proyecto .............................................................................................. 12
Desarrollo .............................................................................................................. 14
SPRINT 1 .................................................................................................................................. 14
Planificación ........................................................................................................................ 14
Descripción .......................................................................................................................... 14
Seguimiento TFS…………………………………………………………………………………………………………14
Control de producción……………………………………………………………………………………………….15
Modo de funcionamiento……………….………………………………………………………………………….16
SPRINT 2 .................................................................................................................................. 17
Planificación ........................................................................................................................ 17
Descripción .......................................................................................................................... 17
Análisis……………………………………………………………………………………………………………………….18
Estudio Código de Barras……………………………………………………………………………………………19
Diseño Conceptual……………………………………………………………………………………………………..20
SPRINT 3 .................................................................................................................................. 22
Planificación ........................................................................................................................ 22
Descripción .......................................................................................................................... 22
Diseño lógico y de clases…………………………………………………………………………………………….22
Prototipo Inicial………………………………………………………………………………………………………….24
Implementación I……………………………………………………………………………………………………….25
SPRINT 4 .................................................................................................................................. 26
Planificación ........................................................................................................................ 26
Descripción .......................................................................................................................... 26
Conexión……………………………………………………………………………………………………………………26
WPF & Metro…………………………………………………………………………………………………………….27
4
SPRINT 5 .................................................................................................................................. 29
Planificación ........................................................................................................................ 29
Descripción .......................................................................................................................... 29
Pantalla Costes & Relaciones &Listados………………………………………………………..……………29
Base de datos SQL Server……………………………………………………………………………………………31
SPRINT 6 .................................................................................................................................. 32
Planificación ........................................................................................................................ 32
Descripción .......................................................................................................................... 32
Pantalla Login & Configuración…………………………………………………………………………………..32
Importar & Exportar en CSV……………………………………………………………………………………….33
Sprint 7 .................................................................................................................................... 36
Planificación ........................................................................................................................ 36
Descripción .......................................................................................................................... 36
Sincronización…………………………………………………………………………………………………………….37
Reportes…………………………………………………………………………………………………………………….38
Sprint 8 .................................................................................................................................... 41
Planificación ........................................................................................................................ 41
Descripción .......................................................................................................................... 41
Pantalla de configuración & Pantalla de carga……………………………………………………………41
Captura de huellas & tarjeta………………………………………………………………………………………43
Pruebas .................................................................................................................. 45
Gestión real del proyecto ....................................................................................... 47
Conclusiones .......................................................................................................... 47
Futuras mejoras ..................................................................................................... 48
Bibliografía ............................................................................................................. 49
Anexo .................................................................................................................... 50
A. Visual Studio Online / Team Foundation Service (TFS) ....................................................... 50
B. Prototipo inicial completo ................................................................................................... 51
C. Mahapps.Metro .................................................................................................................. 53
D. Metro Studio ....................................................................................................................... 54
E. Guía de Usuario ................................................................................................................... 55
5
Resumen_____________________________________ A la hora de tomar decisiones y emprender las acciones necesarias para corregir el desarrollo
de los procesos en un proyecto se debe definir un “control de producción”.
Hoy en día, la importancia del control de producción está aumentando ya que permite la
evaluación de los proyectos de una empresa.
Este proyecto consiste en el desarrollo de una aplicación de escritorio en la empresa WAF
Estructuras Digitales para la gestión de procesos de producción en empresas. En particular,
esta aplicación se basará en el control a través de un hardware específico, un terminal con un
firmware de producción. El terminal actúa como control de acceso y de costes de tiempo en
los procesos de producción. Viene junto a un SDK para la captura de datos y la integración con
otras aplicaciones.
Esta aplicación consistirá en gestionar las órdenes de trabajo y tareas de una empresa, y
mantener los tiempos que registran los empleados para cada una de las operaciones. Además,
el terminal tiene la posibilidad de controlar las unidades producidas.
Desde la perspectiva económica, facilitará el modo de gestionar las horas reales trabajadas por
cada uno de los empleados y de calcular costes reales asociados a la producción.
Para este proyecto será necesaria una toma de contacto completa con el terminal, y con
algunas tecnologías que han sido desconocidas hasta este momento y que serán probadas
para el desarrollo del proyecto.
6
Abstract_____________________________________ At the time to make decisions and learn actions to correct the development of the process in a project, it should be defined a “production control”.
Nowadays, the importance of control´s production is increasing as it allows companies to evaluate the projects.
This Project has been carried out in WAF Digital Structures Company. It consists on the
development of an application for processes’ management inside of a company. This
application will be based especially on the control through a specific hardware, a terminal with
a production´s firmware. In the production process, this terminal acts as an access’ control . It
comes together with a SDK in order to capture dates and the integration with other
applications.
This application will manage job orders and the tasks of a company. It will also maintain the
times that the employees record for each one of the operations. Besides, the terminal has the
ability to control the number of produced items.
From the economical persperctive, it will facilitate the way to manage the hours done by each
one of the employees and to guess the real costs according to the production.
For this project, it will be necessary keep a complete contact with the terminal and with some
unknown technologies. These will be tested for the project development.
7
Introducción________________________________
Contexto y objetivos WAF Estructuras Digitales es un importante desarrollador de soluciones que combina
seguridad “física”, video vigilancia inteligente, y una gran estructura empresarial para integrar
soluciones verticales y horizontales. Actualmente, sus soluciones ayudan a instituciones,
gobiernos y empresas de cualquier tamaño a proteger su gente e instalaciones, a prevenir las
pérdidas y daños, y a mejorar la eficacia de sus negocios al mismo tiempo.
La mejora del sistema de planificación y control de la producción de una empresa o de un
departamento ha llegado a ser un requisito necesario si se pretende ser más productivos.
¿Qué implicará esta mejora? Entre los objetivos que se conseguirán dentro de una empresa
podemos destacar:
Disminuirá el Lead Time (tiempo que transcurre desde que se inicia un proceso de
producción hasta que se completa) y por tanto, el plazo de entrega.
Optimizará la productividad al llevar un mejor control de la misma. Identificará los
problemas de producción que perjudiquen el funcionamiento.
Establecerá un sistema conocido por todos donde se sepa qué operación ha hecho
cada empleado.
Facilitará posteriormente la administración en cuanto a horarios, salarios, etc.
Con motivo de esto, WAF ofrece un proyecto con el objetivo de conseguir una aplicación que
permitirá gestionar la parte de costes de producción de una empresa a partir de la información
recogida a través de los terminales de control.
Por lo tanto, no será una aplicación para un tipo de empresa específica aunque habrá
funcionalidades que limiten su uso en alguna de ellas.
8
Metodología Una metodología es un marco de trabajo usado para estructurar, planificar y controlar un
proceso de desarrollo en sistemas de información.
La realidad muestra que cada proyecto requiere una metodología. Para el desarrollo de este
proyecto se va a seguir la metodología ágil SCRUM ya que presenta más ventajas frente a otras
metodologías tradicionales. Está basado en un proceso iterativo e incremental utilizado
comúnmente en entornos basados en el desarrollo ágil de software. Se basa en la idea de
sprint, que viene a representar una unidad de planificación.
SCRUM se puede llevar a la realidad de muchas maneras diferentes. En este proyecto, no se
podrá llevar al completo, ya que no somos un equipo como tal. SCRUM es un proceso en el
que se aplican de manera regular un conjunto de buenas prácticas para trabajar
colaborativamente, en equipo, y obtener el mejor resultado posible de un proyecto.
En SCRUM se realizan entregas parciales y regulares del producto final, priorizadas por el
beneficio que aportan al receptor del proyecto. Algo por lo que se va a utilizar una adaptación
de SCRUM es que los requisitos son cambiantes, es decir, que hay variables y objetivos que no
controlamos y que pueden cambiar desde el principio del proyecto.
Por lo tanto, vamos a realizar un documento que no es necesario que esté completo para
realizar la primera iteración (primer sprint). En cada una de estas iteraciones se definirán un
conjunto de funciones o requisitos nuevos a cumplir que hacen que vaya evolucionando el
proyecto. Además se incluirá una descripción y un coste estimado por cada una de ellas.
Ilustración 1. Metodología SCRUM
9
Para seguir esta metodología se usará Visual Studio Online, o como se denominaba
anteriormente, Team Foundation Service (TFS). Esta herramienta permite utilizar una plantilla
ideal para aplicar SCRUM. Como se va a usar posteriormente esta aplicación para explicar los
diferentes sprints planteados, describo brevemente algunos aspectos de la propia
herramienta. En la plantilla se pueden encontrar varias zonas:
El backlog (o product backlog de cada sprint). Contiene una serie de items por cada sprint. Es
una lista de requisitos respecto a los objetivos del proyecto.
Ilustración 2. Backlog Items del TFS
El board es un tablero kanban. Es una herramienta visual muy utilizada en la gestión ágil.
Consiste en varias columnas en las que se puede observar en qué situación se encuentra cada
tarea. De esa manera, consigue que toda la información relevante esté a la vista. Contaremos
con un tablero del TFG y otro por cada sprint.
Ilustración 3. Board del TFS
El Burndown es un gráfico de trabajo pendiente a
lo largo del tiempo que nos permite conocer la
velocidad a la que se está completando los
objetivos/requisitos.
Hay un gráfico a nivel global del TFG y otro por
cada uno de los sprints.
Ilustración 4. Burndown del TFS
10
Tecnologías a emplear
Visual Studio Online / Team Foundation Service (TFS) Visual Studio Online/Team Foundation Service es una solución ideal a la hora de alojar los
datos de un proyecto y de gestionarlo sin necesidad de configurar ni administrar un solo
servidor.
Ilustración 5. Funcionalidades Team Foundation Service
Partiendo de una cuenta gratuita, se usarán para el Trabajo Final de Grado ciertas
funcionalidades que permite el TFS:
Conectar con Visual Studio 2013 y poder contar con los repositorios del código de
la aplicación en todo momento en la nube.
Utilizar el control de versiones que nos proporciona registrando cada cambio que
se haga.
Planificar el proyecto a nivel de varios sprints consiguiendo así, un análisis de
tareas y de tiempos. Observar el avance del TFG.
Compartir el proyecto con el tutor de la empresa y el tutor de la universidad.
Estas funcionalidades se probarán a lo largo del proyecto y se mostrará cada vez que se utilice
alguna herramienta del TFS. Para más información sobre esta plataforma, ver anexo.
11
Windows Presentation Foundation (WPF)
Para el desarrollo de la aplicación se utilizará un modelo de programación que permite un
sistema de presentación, el cual sirve para crear aplicaciones cliente de Windows.
El núcleo de Windows Presentation Foundation (WPF) es un motor de representación basado
en vectores e independiente de la resolución que se crea para sacar partido del hardware de
gráficos moderno. WPF extiende el núcleo con un conjunto completo de características de
desarrollo de aplicaciones que incluye lenguaje XAML, controles, enlace de datos, diseño,
gráficos 2D y 3D, animación, estilos, plantillas, documentos, multimedia, texto y tipografía.
WPF se incluye en Microsoft .NET Framework, de modo que es posible compilar aplicaciones
que incorporen otros elementos de la biblioteca de clases de .NET Framework.
Programar con WPF
WPF constituye un subconjunto de tipos de .NET Framework en su mayoría ubicados en el
espacio de nombres System.Windows. Los conceptos fundamentales de programación en WPF
serán ya familiares en cuanto a crear instancias de clases, definir propiedades, llamar a
métodos y controlar eventos con el lenguaje de programación C#. El desarrollo de la aplicación
se realizará con este lenguaje.
En general, se utilizará el lenguaje marcado XAML para implementar la apariencia de la
aplicación, y los lenguajes de programación administrados (subyacentes) para implementar su
comportamiento. Esta separación entre la apariencia y el comportamiento aporta ciertas
ventajas importantes:
Se reducen costos de programación y mantenimiento.
La programación es más eficaz ya que los diseñadores pueden ir implementando la
apariencia al mismo tiempo que los programadores implementan el comportamiento.
Ilustración 6. Windows Presentation Foundation
XAML
Es un lenguaje de marcado basado en XML que se utiliza para implementar la apariencia de
una aplicación mediante declaración. Se suele emplear para crear ventanas, cuadros de
diálogo, páginas y controles de usuario, así como para rellenarlos con controles, formas y
gráficos.
A lo largo del proyecto iremos viendo más funciones sobre WPF y XAML.
12
Gestión del proyecto________________________ Planificación inicial
Las horas empleadas en el proyecto durante una semana u otra pueden variar en función de
las clases y el trabajo que haya. El proyecto debe abarcar 300 horas desde el 27/01/2014 hasta
el 12/06/2014, dos semanas antes del depósito del trabajo.
Al hacer la planificación se partirá de los horarios de clase y de que algunos fines de semana se
excluirán. Como se nombra anteriormente, se utilizará los sprint del TFS. La duración de cada
sprint durará dos semanas. Estos tendrán un coste entre 30 y 40 horas aproximadamente.
En cuanto a las reuniones, se dedicará un tiempo para hablar con la empresa WAF y con el
tutor de la universidad. Aun así, ambos podrán acceder al seguimiento del trabajo mediante el
TFS.
Tareas a realizar
El Trabajo de Fin de Grado se divide en diferentes tareas:
Reuniones. Horas dedicadas para reunirse con el tutor de la empresa y de la
universidad.
Estudio de tecnologías a emplear. Antes de profundizar en el desarrollo del proyecto
hay que conocer la metodología y tecnología que se va a utilizar. No solamente se
trata de buscar información sino de probarlas y en según qué tecnología, interactuar
con ellas.
Terminal de control de producción. Para recoger los requisitos de nuestra futura
aplicación de escritorio se tiene que saber qué funcionalidades vamos a poder cubrir
con el terminal.
Gestión del proyecto. Se trata de describir las tareas a realizar y de elaborar una
estimación a partir de las horas dadas para cada tarea.
Análisis. Captura de requisitos (funcionales y no funcionales) a partir del estudio sobre
el terminal.
Diseño. Diseño conceptual y lógico (se incluyen diagramas). Diseño de la interfaz
(prototipo).
Implementación. Desarrollo de la aplicación. Esta tarea incluye la documentación de
la memoria en cuánto a detalles importantes, implementación a destacar, problemas
surgidos, etc.
Pruebas. Verificar y contrastar que la aplicación cumple con los requisitos planteados
durante el proyecto.
Gestión real. Comparar la gestión inicial del proyecto con lo desarrollado realmente.
Observar las desviaciones que ocurran.
Cierre memoria. Conclusiones y posibles mejoras del Trabajo de Fin de Grado.
También se incluirá un anexo y la bibliografía.
13
Estimación de tiempos iniciales
Tarea Tiempo Comienzo Fin
Reuniones 20 horas - -
Estudio de tecnologías a emplear
7 horas 29/01/14 30/01/14
Terminal de control de producción
20 horas 31/02/14 6/02/14
Gestión del proyecto
8 horas 10/02/14 12/02/14
Análisis 20 horas 14/02/14 28/02/14
Diseño 20 horas 3/03/14 17/03/14
Implementación 160 horas 18/03/14 23/05/14
Pruebas 10 horas 26/05/14 29/05/14
Gestión real 8 horas 30/05/14 3/06/14
Cierre memoria 6 horas 4/06/14 6/06/14
Presentación 6 horas 25/06/14 27/06/14
Total de horas 279 horas - -
Estructura de descomposición del trabajo (EDP)
TFG
1.Reuniones
2.Estudio de
tecnologías a emplear
3.Terminal de control
4.Gestión del proyecto
5.Análisis
6.Diseño
7.Implementación
8.Pruebas
9.Gestión real
10.Cierre memoria
2.1. TFS / Visual
Studio Online
2.2. WPF
4.1. Planificación Inicial
4.2. Tareas a realizar
4.3. Estimación de tiempos
4.4. EDP
14
Desarrollo___________________________________ La forma en la que se va a plasmar el desarrollo del proyecto va a venir determinada por la
metodología empleada. Así, en lugar de establecer la definición por fases (análisis, diseño,
implementación,…), se considera oportuno describir lo realizado en cada una de las unidades
establecidas (sprints).
La estructura que se seguirá por cada sprint será dar una descripción breve sobre lo que se va
a realizar durante esa iteración (planificación) y, hacer una revisión de lo alcanzado
(descripción). En esta revisión se resumirán las tareas que se han realizado y se señalará,
además, si algunas tareas no se han llegado a conseguir. Se pasa a describir los sprint del
desarrollo del proyecto basándose en esta estructura descrita.
SPRINT 1
Planificación El primer sprint, durará dos semanas desde el 29/01/2014 al 12/02/2014. Se dedicará este
tiempo entre otras actividades a obtener información y testear la plataforma de TFS y además,
a conocer WPF.
Otro de los objetivos de este sprint es llevar a cabo una toma de contacto con el terminal para
poder conocer todas las funcionalidades del aparato. De esta manera, se conseguirá conocerlo
a fondo para saber los puntos fuertes y débiles.
Descripción
Seguimiento de un sprint (TFS)
Podemos comprobar el seguimiento del sprint desde el tablero kanban del TFS. Hay varias
columnas que caracterizan el estado (por hacer, en progreso y realizadas) en el que se
encuentra una tarea durante ese sprint.
Las tareas de Team Foundation Service y de WPF aparecen en la columna de realizadas. Cada
una de las tareas puede tener un usuario y unas horas asignadas. Además, se le puede
establecer el tipo de actividad que realiza (diseño, desarrollo, documentación, pruebas, etc).
Ilustración 7. Tablero Kanban Sprint 1
15
Control de producción
En esta etapa se toma contacto con el terminal FPiClock900 con firmware de control de
producción (fabricación) para el que se va a desarrollar la aplicación. El fichaje se realiza a
través de huella dactilar, PIN+PWD y opcionalmente RFID (tarjeta de proximidad).
Puede comunicarse directamente con el PC mediante el puerto Ethernet o el puerto USB.
También admite comunicación en modo “stand-alone” realizando la descarga de fichajes con
un Pen Drive. Permite diferentes funciones a través de su relé: apertura de puerta, integración
en torno, etc. Su carcasa es robusta; ideal para el trabajo en fábricas y talleres. Dispone de
display en color de 3.5’’ con menú intuitivo para todos los niveles de usuario.
Con este nuevo firmware de producción, se pueden manejar las órdenes de trabajo y las tareas
que realizan los empleados dentro de la empresa, controlar el tiempo y los costes asociados a
cada puesto de trabajo. A parte de contar con el control de producción, se puede controlar el
acceso con las operaciones de entrada/salida del terminal.
Como se nombra anteriormente, este firmware viene junto a un SDK que incluye todas las
funciones necesarias para la integración de software con el terminal. Este SDK lleva un manual
con todas ellas. Está orientado a programadores para la elaboración de aplicaciones destinadas
a usuarios.
Ilustración 8. Terminal de producción FPiClock900. Lector biométrico
16
Modo de funcionamiento
Un empleado que acceda al control de producción
contará con las siguientes opciones: Iniciar trabajo,
pausar trabajo, reiniciar trabajo, finalizar trabajo,
entrada (check-in), salida (check-out), inicio última
orden y unidades fabricadas.
Las opciones de entrada y salida corresponden a la
parte del terminal del control de accesos. Las otras son
de producción.
1. Un empleado elige iniciar un trabajo e
inmediatamente éste tendrá que identificarse con el
modo de verificación que tenga asignado. Un empleado
puede tener varios modos. Aquel modo con el que se
identifique quedará registrado en el log del terminal.
2. Se observa que el empleado que se ha
identificado corresponde al usuario 3 con su nombre
correspondiente. Éste introducirá una tarea
correspondiente a una orden de trabajo.
3. Al confirmar los datos introducidos
comprobaremos que el empleado se ha autentificado
con huella y que ha iniciado la tarea 1001 (desmontar
amortiguación) de la orden de trabajo 10 (cambio
amortiguadores).
4. Iniciado ya el trabajo, el empleado podrá pausar
ese trabajo, reanudarlo y finalizarlo. Si el empleado
marca la opción de finalizar el trabajo no quiere decir
que esa tarea haya acabado. La tarea puede volver a
iniciarse.
Iniciar la última orden de trabajo consiste en iniciar la última tarea que fue ejecutada. Las
unidades fabricadas que se introduzcan corresponden a cada orden de trabajo. Todas estas
operaciones quedarán registradas en los costes de producción asociados a su correspondiente
empleado.
Ilustración 9. Opciones del terminal
Ilustración 10. Identificación del empleado
Ilustración 11. Inicio de trabajo
Ilustración 12. Confirmación.
17
SPRINT 2
Planificación Este sprint durará dos semanas, desde el 14/02/2014 al 3/03/2014. Habrá una reunión antes
de empezar y otra en la mitad del sprint. El tiempo que se ocupe en esta iteración se dedicará
a la obtención de requisitos y a su análisis. Esto se conseguirá a partir de la toma de contacto
con el terminal y de la información recogida con los posibles clientes.
Además se realizará un estudio sobre la posibilidad de incorporar un lector de código de barras
y sobre otras aplicaciones existentes encontradas. A partir de este estudio, se realizará otra
recogida de datos ya que puede ser que nos proporcione ideas para nuestra aplicación que no
hayamos contado anteriormente con ellas. Finalmente se empezará con el diseño de la
aplicación.
Descripción
Obtención y análisis de requisitos
A partir de una reunión con el tutor de la empresa se obtienen los requisitos iniciales de la
aplicación. Puede que estos vayan cambiando o aumentando conforme se avance, ya que se
pretende algo abierto, a modificación.
Requisitos funcionales
La aplicación de escritorio gestionará el control de producción de una empresa. Con ésta se
podrán manejar órdenes de trabajo y tareas que realizan los empleados dentro de la empresa,
controlar el tiempo y los costes asociados. Un empleado podrá trabajar de dos modos:
Orden de Trabajo & Tarea
Orden de Trabajo
Si el empleado trabaja con órdenes de trabajo y tarea, el sistema funcionará de la siguiente
manera:
De cada orden de trabajo interesará guardar el código, el nombre (descripción), fecha de
inicio, fecha estimada de finalización, y de forma opcional, el número de unidades fabricadas.
No habrá códigos de órdenes iguales. Lo mismo ocurre con las tareas. Las órdenes de trabajo
estarán relacionadas directamente con las tareas que se vayan a realizar, es decir, que un
empleado no podrá realizar un trabajo del cual no exista una relación previa. Una tarea
contendrá un código, un nombre (descripción) y un tiempo estimado de duración.
En la aplicación se podrá gestionar los empleados de la empresa. Un empleado podrá ser tanto
administrador como empleado normal. Dado que no es imprescindible recoger el DNI o
cualquier otro documento identificativo del empleado, para ello, se le asigna un código único
en el sistema. También interesa recoger su nombre y su modo de identificación ya sea
mediante PIN+PWD (password), FP (huella dactilar) y RF (tarjeta de proximidad). Un empleado
puede tener varios modos de identificación.
18
Desde la aplicación, se podrá configurar qué modos se pueden utilizar para identificarse.
Además, aquellos usuarios que gestionen la aplicación podrán gestionar y ver qué órdenes de
trabajo, tareas y relaciones existen en ese momento.
Por otro lado, habrá una opción de creación de SMS. Se trata de mostrar mensajes de tipo
público (para todos los usuarios), personal (para determinados usuarios) o reservado (para el
administrador). Estos aparecerán cuando el usuario se identifique en el terminal. De cada SMS
interesará introducir la fecha de comienzo (incluyendo la hora), la duración de validez del SMS
y el tipo de mensaje.
Los datos de cada empleado, orden de trabajo, tareas, relaciones, y SMS tendrán la opción de
importarse a partir de un fichero .csv (fichero de texto plano).
Habrá una sección que contará con la posibilidad de recoger los costes asociados a cada
empleado. De esta manera, se podrá gestionar las horas trabajadas por los empleados y
observar sus desviaciones. Estos costes contarán con un filtro para combinar distintos campos
y además habrá la posibilidad de exportar esta información.
Esta sección contará con un identificador del inicio de operación, código del usuario que ha
iniciado la operación, modo de identificación utilizado, operación que ha realizado, fecha,
unidades fabricadas, orden de trabajo y tarea.
En caso de que se trabaje solamente con el modo de Orden de trabajo se trabajará con los
mismos datos que en la otra configuración pero trabajando con una tarea por defecto.
Desde la aplicación se podrá configurar con qué terminal conectar, el modo de inicio del
control de producción, el control de unidades, la verificación de órdenes, el método de
identificación, etc.
Requisitos no funcionales
La aplicación deberá cumplir al menos con estos requisitos:
Rendimiento: El tiempo de respuesta de la aplicación durante sus
operaciones deberá ser relativamente rápido.
Disponibilidad: La tasa de disponibilidad del sistema será realmente alta.
En caso de fallos, se deberá mostrar información sobre ellos.
La interfaz seguirá el mismo estilo. Será intuitiva y sencilla.
Seguridad: Se asegurará que los empleados ajenos a la aplicación no
puedan acceder a ella. Sólo podrán acceder aquellos que tengan el rol de
administrador.
19
Estudio código de barras
Esta tarea consiste en probar un lector de códigos de barras con el terminal. Esto
proporcionaría la posibilidad de identificación y de comenzar un trabajo desde un código de
barras impreso. El SDK incorpora la creación de códigos de barras. Desde el propio terminal se
podrá realizar un test de este código.
Ilustración 13. Generador de código de barras del SDK
Por otro lado, tanto desde el SDK como desde el terminal se pueden configurar estos códigos.
Se configuran varios campos: id del empleado, número de la tarjeta, código de la orden de
trabajo y de la tarea. Estos campos serán opcionales.
Impreso un código de barras con la estructura que se haya elegido, el empleado podrá
identificarse o iniciar un trabajo.
Se estudiará la posibilidad, como mejora futura, de incluir la opción del lector de códigos de
barras.
20
Diseño conceptual
En este sprint se obtiene el modelo Entidad-Relación correspondiente a la información a
gestionar:
(0,N) (1,1) (1,1) (0,N)
(1,N) (1,N)
(0,N)
(1,N)
(1,N)
(1,1)
Tarjeta EMPLEADO ORDEN DE TRABAJO
TAREA
TIENE
H.COSTE
Id
SMS
Nombre Tipo
Id
Descripción
F.Inicio
F.Final
Unidades
Id
Descripción
Duración Id
PERTENECE
Tipo
F.Inicio
Duración
Id
Modo de ident.
Unidades
Operación
Fecha
EMP_OT
Id
PWD
REALIZA HUELLA
Valor
TIENE
RT
21
Se observa cómo queda el tablero Kanban después de la segunda iteración. Se completan
todas las tareas, excepto la de diseño. Aunque necesariamente, se seguirá esta tarea en el
próximo sprint.
Ilustración 14. Tablero Kanban Sprint 2
Se irán bajando las horas en todas las tareas para que el Burndown de la iteración vaya
bajando. De esta manera quedará reflejado que el trabajo que queda por hacer. En ningún
momento podrá crecer porque estaríamos añadiendo más trabajo al sprint.
Ilustración 15. Burndown Sprint2
22
SPRINT 3
Planificación Antes de comenzar este tercer sprint se realiza una reunión con el tutor de la empresa para
cerrar el sprint 2. La nueva iteración durará dos semanas, desde el 5/03/14 hasta el 19/03/14.
En el sprint anterior se comenzó con el diseño conceptual. En este, se proseguirá el diseño
tanto el lógico como el de clases.
A partir de este diseño, se realizará un prototipo inicial de la aplicación. Se mostrarán varias
imágenes sobre este pero se incluirá al completo en el anexo.
Descripción Ya que el diseño y el prototipo se realizan pronto, se comienza con la implementación de las
clases que se van a necesitar en el desarrollo de la aplicación.
Ilustración 16. Tablero Kanban Sprint 3
Diseño Lógico
A partir del modelo conceptual se muestra el modelo relacional señalando las claves foráneas
y las primarias.
EMPLEADO
ID NOMBRE TIPO TARJETA HUELLA PWD ORDEN_DE_TRABAJO H_COSTE
CF: ORDEN_DE_TRABAJO CF: H_COSTE
ORDEN_DE_TRABAJO
ID DESCRIPCIÓN F.INICIO F.FINAL UNIDADES EMPLEADO TAREA
CF: EMPLEADO CF: TAREA
TAREA
ID DESCRIPCIÓN DURACIÓN ORDEN_DE_TRABAJO
CF: ORDEN_DE_TRABAJO
EMP_OT
EMPLEADO ORDEN_DE_TRABAJO
CF:EMPLEADO CF: ORDEN_DE_TRABAJO
23
RELACIÓN
ORDEN DE TRABAJO TAREA DESCRIPCIÓN DURACIÓN
CF:ORDEN_TRABAJO CF:TAREA
H_COSTE
ID MODO_IDENT OPERACIÓN FECHA UNIDADES EMPLEADO ORDEN_DE_TRABAJO TAREA
CF: EMPLEADO
CF:RELACIÓN
SMS
ID TIPO F.INICIO DURACIÓN EMPLEADO
CF: EMPLEADO
Diseño de clases
En este sprint se realiza un diagrama de clases para poder apoyarnos a la hora de la
implementación.
Ilustración 17. Diagrama de clases
24
Prototipo inicial
Como consecuencia del diseño, se realiza un prototipo inicial que podrá llegar a ser diferente
del final conforme pasen los sprint. Entre las diferentes alternativas estudiadas, se elige
realizar el prototipo con la herramienta Balsamiq Mockups. Este no permite ver la
navegabilidad de la aplicación pero si ver una idea de la aplicación que se desarrollará. Para ver
todo el prototipo ver al anexo.
Algunos de los ejemplos del prototipo son:
Ilustración 20. Pantalla Principal Ilustración 21. Pantalla Órdenes
Ilustración 18. Pantalla Empleados Ilustración 19. Pantalla Principal
25
Implementación I
Estructura de la aplicación
A la hora de desarrollar la aplicación se utilizará una única solución con la siguiente estructura:
Lógica: esta biblioteca de clases contiene las clases de la capa de lógica de negocio,
actúa a modo de intermediario entre la persistencia, el modelo y la presentación.
Persistencia: esta biblioteca de clases se encarga de interactuar con la base de datos.
Presentación: contiene las ventanas de la aplicación con las que interactuará el
usuario.
Como se observa, se produce un claro paralelismo entre las capas, salvo la clase conexión. Así,
por ejemplo, contamos con una clase para empleados en la lógica, otra en la persistencia y una
ventana, en la presentación. De todas formas, se decide continuar con el diseño por capas para
facilitar la estructura de la aplicación y favorecer posibles modificaciones futuras.
Paquete Lógica de Negocio
La lógica de negocio estará compuesta por cada una de las clases. El paquete de presentación
tendrá que añadir referencias a la lógica para poder acceder a ella.
Paquete Persistencia
La persistencia tendrá todas las clases que accedan a la base de datos, es decir, todas aquellas
que hagan consultas a la base de datos creada en SQL SERVER.
Paquete Presentación
Como toda aplicación segura debe tener un login inicial para administradores. También
contendrá una ventana/pantalla por cada uno de las clases, es decir: empleados, órdenes de
trabajo, tareas, sms, relaciones y costes. Por otro lado, tendremos una pantalla principal desde
la cual podremos acceder a cada una de estas pantallas anteriores y otra pantalla de
configuración del control de producción del terminal.
FEmpleados FOrdenesdeTrabajo
FRelaciones FCostes FSms FTareas
FPrincipal
FConfiguración
Empleado Orden de Trabajo Tarea
Relación
SMS
Costes Configuración Conexión
FLogin
EmpleadoPers OrdenTrabajoPers TareaPers SMSPers
CostesPers RelaciónPers ConfiguraciónPers HuellaPers
Huella
FHuellas PantallaEstado
26
Además se incluirá una pantalla por cada listado de cada una de las clases para poder acceder directamente.
SPRINT 4
Planificación El sprint 4 se dedicará exclusivamente a seguir con la implementación. Durará
aproximadamente dos semanas, desde el 19/03/14 hasta el 4/04/14, en las que se irá
comentando poco a poco los puntos clave de la implementación de la aplicación. Conforme se
vayan implementando las pantallas se verá que cada vez se parece menos a los prototipos
iniciales ya que van surgiendo nuevas ideas.
Se utilizará este sprint para la pantalla principal, la de órdenes, tareas, empleados y sms. En
todas estas pantallas se empleará la conexión con el terminal a la hora de cargar toda la
información. Se mostrará tanto la parte de WPF como de implementación en C#.
También se conseguirá la forma de darle un estilo de Windows 8 con la librería de
MahApps.Metro, dejando a un lado la vieja aplicación. Se observará el cambio más adelante.
Se dedicará también tiempo a este diseño y a ir retocando cada una de las pantallas para que
queden más intuitivas con iconos en vez de botones.
Descripción
Conexión con el terminal
Para poder conectar con el terminal de producción se utiliza una librería de ZK denominada
zkeuemkeeper.CZKEUEM. Esta librería permite utilizar métodos para poder acceder a los datos
del terminal. Gracias a esta, se sincronizará la aplicación con el terminal.
El terminal se puede conectar a cualquier red. Se asigna una IP al terminal de producción y
desde cualquier sistema conectamos al terminal. Deberán estar en la misma red.
ListadoEmpleados ListadoOrdenes ListadoTareas
ListadoSMS
ListadoCostes
ListadoRelaciones
27
Para realizar las pruebas, se realiza una conexión con la ip del terminal.
Más adelante se verá que se pueden añadir más de un terminal a sincronizar (configuración),
de manera que quede generalizada.
Diseño WPF y W8 con MahApps.Metro
Desde que salió Windows 8 se empezó a dar también importancia no solamente a la
funcionalidad de una aplicación sino al diseño de interfaces de usuario. Y por lo tanto, la
tecnología más adecuada para poder realizar una interfaz de usuario lo más rica visualmente
posible es WPF.
Con el diseño que nos ofrece la librería MahApps.Metro se consigue que las antiguas
aplicaciones de escritorio obtengan una mejor apariencia adaptadas a las interfaces actuales.
Se observa el paso de esta
ventana…
… a esta otra.
192.168.21.201
192.168.21.202
28
Metro Studio
Para dar un mejor aspecto a la aplicación de escritorio, se utiliza Metro Studio. De tal forma
que se modifica muchos botones por iconos intuitivos.
En el menú principal de la aplicación se tendrá acceso desde botones (iconos) a cualquiera de
las clases nombradas anteriormente. Cada uno de estos seguirá una estructura muy semejante
a esta:
Al finalizar las dos semanas se quedan pendientes estas tareas para el siguiente sprint ya que
se han producido desviaciones con el diseño de las pantallas y las nuevas ideas.
Ilustración 23. Tablero Kanban Sprint 4
Por el momento la aplicación queda sin dar todavía funcionalidad en cuanto a datos y sólo en
cuanto a diseño.
Ilustración 22. Iconos Metro Studio.
29
SPRINT 5
Planificación El quinto sprint durará también unas dos semanas más o menos ya que hay algunos días de
fiesta, desde 7/04/14 al 23/04/14. Se procederá a realizar las tareas pendientes que quedaron
del anterior sprint. Además, se realizarán los listados y las nuevas pantallas de costes y de
relaciones.
En el desarrollo de esta iteración se realizará la creación de la base de datos de la cual tirará la
aplicación y mediante la cual, cargará la información al terminal.
También se dejarán horas para la documentación del propio sprint.
Descripción
Tareas pendientes Sprint 4
Algunas de las pantallas no quedarán realmente terminadas al completo hasta el final del
último sprint ya que puede que queden algunos retoques de implementación y de diseño.
Para empezar este sprint, se avanzará en cada una de las pantallas que se quedaron a medias.
En la pantalla principal se dará funcionalidad al menú de ficheros y de listados. Esto se verá
más adelante.
En la pantalla de órdenes de trabajo se puede observar la siguiente funcionalidad:
Crear una orden de trabajo
Editar una orden de trabajo
Eliminar una orden de trabajo
Eliminar todas las órdenes de trabajo
Mostrar una orden de trabajo
Mostrar todas las ordenes de trabajo
Importar órdenes de trabajo desde un fichero .csv
Exportar órdenes de trabajo a un fichero .csv (Excel)
Ilustración 24. Tablero Kanban Sprint 5
30
Pantalla costes y relaciones
Con motivo de tener ya un esquema de las pantallas anteriores, resulta sencillo crear la
pantalla de relaciones. En esta se podrá:
Crear una nueva relación
Editar una relación
Eliminar una relación
Eliminar todas las relaciones
Mostrar una relación
Mostrar todas las relaciones
Importar relaciones desde un fichero .csv
Exportar relaciones a un fichero .csv (Excel)
Ilustración 25. Pantalla Órdenes
Ilustración 26. Pantalla Relaciones
31
Listados
Desde la pantalla principal se puede acceder directamente a los listados de información de
cada una de las clases. A continuación, se puede ver el estilo de estos:
Base de datos ZKProducción en SQL SERVER
Para poder manejar todos los datos de la aplicación, se decide usar SQL Server ya que se
recomienda utilizar para .NET e incluso, ofrece servicio de reportes. Se comunicarán estos
datos con el terminal al sincronizar la aplicación.
Creación de la base de datos ZKProduccion en
SQL Server. Esta base de datos nos permite poder
acceder a los datos mucho más rápido y a partir de
estos, ya cargarlos al terminal de una vez.
Se crea una tabla por cada una de las clases y
también una para la configuración en la que se
almacenará la configuración de cada aparato (la IP de
cada terminal será la clave primaria).
¿Cómo se conecta SQL Server con el proyecto de Visual Studio?
Se crea una clase Conexión la cual contendrá un método denominado ObtenerConexion().
En este método se abre una conexión a una base de datos.
Data Source=nombre del servidor de SQL SERVER
Ilustración 27. Listado Tareas
Ilustración 28. Estructura de la base de datos ZKProducción
32
Initial Catalog= nombre de la base de datos a utilizar
Integrated security= true hacer conexión segura usando las credenciales de Windows
A partir de este método en todas las funciones de la persistencia podremos acceder a
la base de datos, realizar consultas y operaciones.
SPRINT 6
Planificación Este sprint se desarrollará del 24/04/14 al 12/05/14. El tiempo que se dejará a este sprint será
para la realización de la pantalla de configuración (sólo diseño) y la de login (diseño e
implementación).
Ilustración 29. Tablero Kanban Sprint 6
Por otro lado, en este intervalo de tiempo se verá cómo leer un fichero .csv separado por
“punto y coma” desde el cual importar cualquier tipo de datos (de nuestras clases) que
necesitemos. También se podrá exportar los datos recogidos a un Excel.
Descripción
Pantallas login y configuración
Para la pantalla de ingreso en la aplicación se decide seguir con el mismo estilo. Solamente se permitirá el acceso a la aplicación a aquellos que sean administradores.
Ilustración 30. Pantalla Login
33
A la pantalla de configuración se podrá acceder en el botón derecho (icono ajustes) en todo
momento.
Ilustración 31. Pantalla principal. Referencia al icono de ajustes.
El primer diseño de la pantalla de configuración sigue también la línea de las demás. Incorpora
varios campos de configuración del control de producción que el terminal debe seguir. Y
además, se añade un campo para la IP del terminal. La implementación se deja para el
siguiente sprint.
Exportar en CSV
Una de las cosas principales que quiere una empresa es poder recoger los datos que almacena
el terminal. ¿Cómo se puede sacar la información? Exportando estas tablas a un fichero .csv de
Excel.
Se puede ver cómo se exporta la tabla de datos de los costes de producción:
Ilustración 32. Pantalla Configuración
34
Se llama a la función que rellena la tabla (datagrid) con los datos de los costes. Se
copia la tabla al portapapeles (DataGridClipboardCopyMode) incluyendo la cabecera.
Esta copia se realiza con un formato. En este caso, cada celda irá separado de una
coma. Este formato (CSV) es útil para poder pegar contenido a aplicaciones como son
el Bloc de notas, Excel o Word.
Mediante StreamWriter se puede escribir el resultado en un fichero denominado
“export.csv”.
Con el Process se ejecuta el fichero para que se abra desde el Excel y así el usuario o
empleado pueda cambiarle de nombre o guardarlo en otra ruta.
Importar desde un CSV
Otra opción principal que lleva la aplicación será la importación desde un fichero .csv que
cargará nuevos datos a la base de datos y a su vez al terminal. Para empezar a poder importar
hay que:
A partir de un fichero .csv sin la cabecera de aquello que se vaya a importar. En este
caso, tareas.
35
Mediante OpenFileDialog, se abre aquel fichero que seleccione el usuario. Si existe ese
fichero, se llama a una función a parte denominada ReadTareaCSV, la cual lee cada
una de las líneas del fichero y por cada una de estas, crea una tarea.
Se puede importar más de una tarea desde el csv. Se llama al método de creación de
tareas pasándole los datos recogidos al leer el fichero. Se muestra un ejemplo al
importar el fichero prueba.csv para ver el resultado:
36
Sprint 7
Planificación Comienza el sprint 7 con el cierre del sprint anterior y con su respectiva reunión. Durará desde
el 13/05/14 al 29/05/14. En esta reunión se decide maximizar ciertas pantallas y se quitan los
listados. Este cambio se producirá ya que por ejemplo, una empresa puede que tenga un
número pequeño de empleados, pero hay que pensar la posibilidad de que tenga un número
mayor. Debido a esto, se decide que el estado inicial de estas pantallas sea maximizado. Esto
se aplica a toda la aplicación.
También se dedicará tiempo a:
Mejorar el filtro de la pantalla de costes.
Sincronizar desde un solo botón y no desde cada pantalla.
Implementación pantalla de configuración.
Reporting (informes).
Descripción
Filtros
Se decide mejorar el filtro de la tabla de costes de la producción. De esta manera, no
solamente se podrá filtrar por un solo campo sino que se pueden combinar varios. Para ello, se
colocan varios checkbox de cada uno de los campos a filtrar.
Ilustración 33. Tablero Kanban Sprint 7
37
En función del número de campos activos aparecerán el mismo número de combobox, exceptuando la fecha. En este caso, se mostrarán dos DatePicker para marcar desde una fecha hasta otra.
Para la implementación de este filtro se utiliza un método genérico en función de los campos activados. Así, no hace falta una consulta por cada combinación.
Sincronización
Anteriormente, se actualizaban los datos del terminal desde la base de datos en cada una de
las pantallas de empleados, órdenes, tareas, etc. Después de la última reunión que se hizo se
plantea hacer un solo botón en la pantalla principal para que se carguen todos los datos de
una vez al terminal.
En cambio, los costes funcionan de distinta manera, ya que recogemos la información del
aparato. La pantalla principal quedará de la siguiente manera:
Ilustración 34. Pantalla Principal
Para que se observe mejor el proceso de sincronización, se realiza un diagrama de flujo.
Ilustración 35. Diagrama de flujo
sincronización
38
Pantalla Configuración
Se implementan los distintos valores del combobox para que sean recogidos desde la base de
datos. La implementación de la sincronización con más de un aparato se dejará para el
próximo sprint ya que se quiere dedicar más tiempo a otras tareas de esta iteración.
Reporting (informes)
Visual Studio proporciona una interfaz fácil de usar para crear informes sólidos que incluyen
datos procedentes de la base de datos. Los informes se guardan como archivos de definición
de informe del cliente (.rdlc). Gracias a los informes se tiene la posibilidad de crear orígenes de
datos a partir de tablas, vistas, clases, servicios Web, entre otros, pero en este ejemplo nos
centraremos en los costes (tabla Coste).
Se añade un nuevo Report al proyecto de PresentacionZK, InformeCostes.rdlc .
Se inserta una tabla en el informe creado con los campos que se quieran. Se puede
observar que en nuestro proyecto se nos añade un nuevo DataSet,
ZKProduccionDataSet.
Se puede diseñar un informe propio (se pueden incluir imágenes, tablas, gráficos,
textos, etc).
Ilustración 36. Creación reporte en Visual Studio 2013
Ilustración 37. Elección de tablas de la base de datos
39
Se crea una nueva ventana para poder incrustar nuestros informes. Para poder utilizar
ReportViewer en una aplicación WPF hay que añadir una librería en las referencias
Microsoft.Report.Viewer.WinForms. También, se añade una etiqueta de
WindowsFormHost para poder incluir el reportviewer.
Se rellena el ReportViewer con el dataset creado anteriormente, especificando cual es
el fichero .rdlc que se va a cargar.
Se muestra el resultado, el cual proporciona guardar estos informes como PDF, Word
o Excel.
Ilustración 38. Diseño del reporte
40
Ilustración 39. Informe de los costes
Nota: La librería utilizada para darle a la aplicación el estilo metro no permite incluir
ReportViewer así que de momento en este sprint se quedará con el estilo por defecto.
Antes de desarrollar la tarea de creación de informes, se creyó conveniente realizar un
diagrama de flujo que expresase claramente el proceso completo.
Ilustración 40. Digrama de flujo exportación de datos. Creación de informe.
41
Sprint 8
Planificación Para este sprint último, que abarcará desde el 29/05/2014 al 12/06/2014, se empleará tiempo
en finalizar la aplicación, realizar pruebas y ultimar detalles de la documentación. En cuanto a
la aplicación se terminará la implementación de la pantalla de configuración y de carga (estado
de sincronización).
Ilustración 41. Tablero Kanban inicio Sprint 8
Descripción Casi ya a la mitad de la iteración se decide hacer varios diagramas de flujo (de actividad) para
que se observe un desarrollo completo desde la recogida de datos, el proceso de
sincronización con el terminal hasta la exportación de los datos. También, se termina la
implementación de la captura de huellas y de la tarjeta. Se incluye estas tareas al tablero
Kanban del TFS.
Ilustración 42. Tablero Kanban Desarrollo Sprint 8
Pantalla Configuración
Con motivo de que la aplicación pueda sincronizarse con más de un aparato, se da la
posibilidad de haya una configuración para cada uno y ésta, se almacene en la base de datos
junto a los datos descritos en el anterior sprint. Por eso, se modifica totalmente la pantalla de
configuración creada anteriormente.
42
Ilustración 43. Pantalla Configuración
Pantalla de carga
Se realiza tanto el diseño como la implementación de la pantalla de espera que el usuario verá
cuando éste sincronice con los terminales. Por el momento se decide mostrar un texto en el
que se vea con qué terminales está sincronizando en cada momento y una barra de progreso.
Además se incorpora un gif de carga (se requiere la librería WpfAnimatedGif para poder
ejecutar este gif en WPF).
Ilustración 44. Pantalla de carga/ espera
Aunque parezca sencilla la pantalla de carga, tiene más complicaciones. Si el administrador
quiere seguir utilizando el resto de la aplicación cuando vaya a sincronizar y no tener que estar
esperando, se tendrán que utilizar hilos. Hay varias opciones para realizar esto:
Se crean diferentes hilos a través de un temporizador, y se utiliza un Dispatcher para
poder ejecutar un delegado en un subproceso. Si la barra de progreso no está
completa, sincronizará con los terminales. Cuando la barra termina, se anula el
temporizador y se llama de nuevo al mismo delegado. De esta manera, se pueden
modificar el estado de la barra y del gif de carga.
La otra opción, la cual se utiliza, es usar la clase BackgroundWorker. Esta clase permite
ejecutar una operación en un subproceso independiente.
43
Esta pantalla de espera también se utiliza en la pantalla de costes, a la hora de sincronizar el
terminal con la base de datos.
Captura de huella y tarjeta
Para capturar cada una de las huellas se ha optado por realizar una pantalla en la que
aparezcan los dedos de las manos como botones. Cada uno de estos dedos, será cada una de
las huellas que se van a registrar en la base de datos y en el terminal.
Ilustración 45. Pantalla de captura de huellas
Cuando la huella de un empleado ya esté registrada, el dedo correspondiente aparecerá de
otro color para diferenciarse de las que no lo están.
44
Ilustración 46. Pantalla de captura de huellas
Por lo tanto, en caso de que el empleado quiera usar más de una huella, podrán registrarse las
diez. Para ello, creamos una clase más y una tabla más en la base de datos. Cada uno de los
empleados contará con sus correspondientes huellas. El valor de estas huellas es una cadena
de caracteres (255, más o menos del estilo de la imagen).
Ilustración 47. Cadena única que se almacena de una huella.
Por otro lado, la captura de tarjeta se realiza mediante asociación de eventos con delegados.
Cuando el empleado pasa la tarjeta por el lector, la aplicación recoge el número de la tarjeta.
Se almacena y se modifica el empleado correspondiente.
45
Pruebas_____________________________________ Este apartado se realiza constantemente a lo largo del proyecto aunque se documente algo al
final de él. Se realizan una serie de pruebas ya sea para modificar aquella parte de diseño que
no termina de convencer o revisar la implementación de algunos métodos. Principalmente se
realizan pruebas de caja negra, es decir, a partir de unos datos de entrada, se obtiene una
salida (sin observar que sucede en el interior).
Se muestra algunas de las pruebas hechas en el transcurso del proyecto y que han cumplido
los requisitos pedidos:
Acceso a la aplicación por parte de un administrador.
En caso de que no sea administrador o que haya introducido mal la contraseña, aparecerá
un mensaje de error informando al usuario y en caso contrario, accederá directamente al
menú principal.
Gestión Empleados
Prueba Restricciones & Pasos Resultado
Nuevo Empleado -Introducir un código que no exista en la BD.
OK
Modificar Empleado -Introducir un código que exista en la BD.
OK
Eliminar Empleado -Introducir un código que exista en la BD.
OK
Eliminar Empleados - OK
Mostrar Empleado -Introducir un código que exista en la BD.
OK
Mostrar Empleados - OK
Exportar Empleados - OK
Importar Empleados -Importar SIN cabecera. OK
Generar Informe - OK
46
Gestión Costes
Prueba Restricciones & Pasos Resultado
Mostrar Costes - OK
Eliminar Costes - OK
Limpiar log del terminal -Exige que el terminal o terminales estén conectados.
OK
Exportar Costes - OK
Descargar log del terminal -Exige que el terminal o terminales estén conectados.
OK
Crear informe - OK
Filtros - OK
Sincronización
Se realizan varias pruebas con varias configuraciones pero solamente un terminal conectado.
De tal manera, que el primer terminal cargará toda la información pero el segundo, mostrará
un mensaje de que no ha finalizado su sincronización.
En caso de que la sincronización no haya sido
exitosa, aparecerá como en la imagen en
mensaje en rojo.
47
Gestión real del proyecto__________________ En la siguiente tabla se refleja las horas reales trabajadas por cada una de las tareas
planificadas desde el inicio del proyecto.
Como conclusión y comparación con los tiempos de la planificación inicial, observamos varias
desviaciones. Se ha dedicado menos tiempo a las reuniones y a documentar la gestión real del
proyecto.
Sin embargo, se han producido más variaciones en cuanto a la implementación y a las pruebas.
Se ha dedicado mayor tiempo a estas ya que se van añadiendo o cambiando los requisitos a lo
largo de los sprints.
Conclusiones ________________________________ El resultado de este trabajo ha sido grato ya que ha aportado mucho conocimiento del que se
desconocía en la carrera y del que se aprende de una empresa.
Además, he tenido la posibilidad de poder interactuar y saber cómo se trabaja con terminales
de acceso y en este caso, también de producción. No solamente a nivel de hacer pruebas
parciales con un hardware, sino a poder extraer información y utilizar ésta para fines, tanto de
control como de seguridad.
Esta aplicación ayudará a disminuir el Lead Time, a mejorar la productividad, a facilitar la
administración, es decir, a llevar un control de la empresa. Pero desde mi punto de vista, este
control hace que una empresa sea más segura, no únicamente pensando económicamente.
Tarea Tiempo Comienzo Fin
Reuniones 15 horas - -
Estudio de tecnologías a emplear
7 horas 29/01/14 30/01/14
Terminal de control de producción
20 horas 31/02/14 6/02/14
Gestión del proyecto
8 horas 10/02/14 12/02/14
Análisis 20 horas 14/02/14 28/02/14
Diseño 20 horas 2/03/14 14/03/14
Implementación 180 horas 15/03/14 03/06/14
Pruebas 12 horas 03/05/14 05/05/14
Gestión real 3 horas 06/06/14 06/06/14
Cierre memoria 5 horas 12/06/14 17/06/14
Presentación 5 horas 27/06/14 3/07/14
Total de horas 292 horas - -
48
Por supuesto que uno de los objetivos personales conseguidos ha sido aprender nuevas
tecnologías como WPF y que he podido mejorar mi nivel en c#. Sin embargo, gracias a la ayuda
que me han aportado también se consigue aprender de aquellos que tienen más experiencia y
eso resulta gratificante.
Algo que también hay que señalar, es la gran diferencia que se produce al realizar un proyecto
completo por parte de una sola persona. Hasta este momento solamente se habían realizado
partes por separado de un proyecto (BD, diseño de BD, programación, etc.) e incluso, también
en equipo. Por lo tanto, al realizar este trabajo, se experimenta esta diferencia. Aunque al
principio cuesta coger el ritmo, al final se aprende mucho.
Futuras mejoras____________________________ Los objetivos principales se han cumplido pero algunas de las mejoras que se podrían realizar a
esta aplicación serían:
Mejorar aspectos del diseño. Usar plantilla de la empresa.
Incorporar la funcionalidad del código de barras.
Perfeccionar la parte de la captura de huellas, recogiendo los eventos de cada huella.
Mejorar aspectos como la seguridad de la aplicación y la sincronización.
Con más conocimientos sobre esta tecnología se podría sacar más provecho a la
aplicación.
49
Bibliografía__________________________________
Información del terminal de producción
http://www.zksoftware.es/
Team Foundation Service / Visual Studio Online
http://www.visualstudio.com/en-us/products/visual-studio-online-overview-vs.aspx
WPF
http://msdn.microsoft.com/es-es/library/ms754130(v=vs.110).aspx
http://www.wpftutorial.net/
Código abierto del generador de códigos de barras
http://www.codeproject.com/
Creación de hilos en C#
http://msdn.microsoft.com/es-es/library/7a2f3ay4%28v=vs.90%29.aspx
http://msdn.microsoft.com/es-es/library/system.threading.thread.aspx
Sincronización de subprocesos
http://msdn.microsoft.com/es-es/library/ms173179.aspx
SQL SERVER
http://msdn.microsoft.com/en-us/library/s4yys16a%28v=vs.90%29.aspx
http://chancrovsky.blogspot.com.es/2013/06/filtrar-por-rango-de-fechas.html
http://support.microsoft.com/kb/956176/es
50
Anexo________________________________________
A. Visual Studio Online / Team Foundation Service (TFS) Es la forma más rápida para que los nuevos usuarios y los equipos pequeños empiecen a
desarrollar aplicaciones en la nube. Permite conectarte con algunos entornos de desarrollo
como Visual Studio, Eclipse, XCode.
Un equipo entero puede manejar el trabajo en un backlog que provee detalles sobre los
proyectos que están manejando varios equipos. Visual Studio Online ofrece proyectos de
equipo ilimitados y repositorios de código privado, herramientas de planeación de proyectos y
de seguimiento de errores, como paneles kanban y previsiones de progreso del equipo.
Para el progreso se pueden crear múltiples gráficos de tal manera que se visualice el avance de
cada sprint o del proyecto, o según el estado de las tareas.
Ilustración 48. Dashboard deL TFS
La cuenta ha sido vinculada a una dirección de Hotmail. Para este caso, simplemente hace falta
tener instalado el Visual Studio 2013 o alguna otra versión anterior. Todos los cambios que se
hagan en el Visual Studio 2013 se guardarán también en la nube, estando sincronizados.
Ilustración 49. Conexión TFS y Visual Studio 2013
51
Desde este menú se puede acceder a gran parte de información que teníamos en el portal web
del TFS ya que de esta manera, desde el propio Visual Studio se pueden realizar cambios.
Uno de los puntos más importantes en cualquier proyecto, es el control de versiones de
código. TFS permite volver a versiones anteriores, comparar distintas versiones y por cada
cambio realizado tener un registro.
B. Prototipo inicial completo A continuación, se muestra todo el prototipo inicial.
Ilustración 50. Prototipo. Pantalla Principal y Empleados
Ilustración 51. Prototipo. Tareas y SMS
Ilustración 52. Prototipo. Relaciones y OT
52
Ilustración 53. Prototipo. Pantallas de configuración
Ilustración 55. Prototipo. Listados
Ilustración 54. Prototipo. Pantalla Configuración
53
C. Mahapps.Metro MahApps.Metro es una librería muy sencilla de utilizar. Es necesario que la aplicación esté con
el framework 4.0 o superior.
Para añadir esta librería, hay que situarse en la “administración
de paquetes NuGet”. Esta es una extensión de Visual Studio que
permite la administración de referencias a otras librerías.
Se busca y se instala el paquete MahApps.Metro.
Después se modifica el código XAML de la ventana. Inicialmente se tiene este código en la
aplicación antigua. Procedemos a cambiar ciertas líneas de código.
Se cambia la etiqueta Window por controls:MetroWindow y agregamos la siguiente línea:
xmlns:controls="clr-namespace:MahApps.Metro.Controls;assembly=MahApps.Metro"
54
Se añade la librería de MahApps.Metro.Controls. También se modifica que la ventana herede
en vez de Window, de MetroWindow.
D. Metro Studio Metro Studio es una herramienta (gratuita dependiendo en qué casos) para la creación de
miles de iconos basados en vectores e imágenes ideales para Windows 8.
Cada uno de los iconos viene acompañado de su código XAML para poder utilizarlo en WPF
directamente. También se pueden descargar como imágenes para poder utilizarse en otro tipo
de aplicaciones.
Por ejemplo, para los empleados se escoge este icono. Lo que interesa de MetroStudio es el
código XAML que nos proporciona para incrustarlo en la aplicación directamente.
55
E. Guía de Usuario Esta guía trata de explicar el funcionamiento de la aplicación de una manera general, sin entrar
mucho en detalle. Se sitúa como contexto, el uso de la aplicación en un taller mecánico.
Inicio de la aplicación
Al iniciar la aplicación el usuario se encontrará con esta ventana en la que tendrá que
introducir sus credenciales. El usuario debe ser de tipo administrador. En caso de no serlo, no
podrá acceder al menú.
Ilustración 56. Pantalla Login. Guía Usuario
Pantalla principal
Después de iniciar la sesión, el administrador puede acceder a cualquier opción gestionable de
la aplicación. Se señalan las principales opciones a continuación:
1. Empleados
2.Órdenes de trabajo
3. Tareas
4. Relaciones
5. Costes
6. SMS (Mensajes)
7. Sincronizar
8. Configuración
1 2 3 4
5 6 7 8
Ilustración 57. Opciones de la pantalla principal.
56
Funciones de empleados
Crear, modificar, eliminar y mostrar empleados.
Exportación e importación de datos de empleados.
Además, se pueden crear informes.
Ilustración 58. Pantalla Empleados. Guía usuario
Funciones de órdenes de trabajo
Crear, modificar, eliminar y mostrar órdenes de trabajo.
Exportación e importación.
Ilustración 59. Pantalla Órdenes. Guía usuario.
Funciones de tareas
Crear, modificar, eliminar y mostrar tareas.
Exportación e importación.
57
Ilustración 60. Pantalla Tareas. Guía usuario.
Funciones de relaciones
Crear, modificar, eliminar y mostrar relaciones a partir de órdenes y
tareas ya creadas.
Exportación e importación.
Ilustración 61. Pantalla Relaciones. Guía usuario.
Funciones de costes
Mostrar y eliminar los costes.
Limpiar el log del terminal o terminales.
Exportar costes y creación de informes.
Filtrar costes por varios campos.
58
Ilustración 62. Pantalla Costes. Guía usuario.
Funciones de SMS (mensajes)
Crear, modificar, eliminar y mostrar los mensajes.
Exportación e importación.
Ilustración 63. Pantalla SMS. Guía usuario.
Funciones de configuración
Crear, modificar, eliminar y mostrar las configuraciones
los terminales a sincronizar.
Ilustración 64. Pantalla Configuración. Guía usuario.
59
Sincronización
Actualiza el terminal o los terminales a partir de los datos
de la base de datos de la aplicación.
A continuación, se observa el procedimiento de la aplicación junto al terminal
situado en un taller mecánico:
1. Ingresar un empleado en la aplicación y después, al sincronizar quedará
registrado en el terminal. Este empleado podrá acceder al terminal mediante
PIN+PWD (id de empleado y contraseña).
El empleado queda registrado en la aplicación.
2. Enrolar la huella digital del empleado. Éste podrá acceder al terminal mediante
PIN+PWD y huella. Seleccionamos el empleado al cual queremos añadir una
huella y pulsamos capturar huella.
60
El terminal solicitará que el empleado introduzca tres veces el dedo. Al terminar, se
deberá confirmar si se quiere registrar la huella recogida o rechazarla si ha surgido
algún problema.
La huella queda almacenada. Si se vuelve a dar a capturar huella sobre ese empleado
se puede ver las huellas que han sido registradas.
Se sincroniza con el terminal desde el menú principal.
3. El empleado ya está listo para poder fichar en el terminal. Como se nombra
anteriormente, al ser un taller, el mecánico empieza a trabajar y decide
cambiar los amortiguadores de un coche. Por lo tanto, comienza la orden de
trabajo, cambio de amortiguadores y como tarea, desmontar amortiguación.
Ficha mediante PIN+PWD. Antes ha podido realizar entrada/salida para acceder
al taller.
61
4. El mecánico ya ha iniciado el trabajo. Al cabo de un tiempo, ha terminado la
tarea y decide finalizar el trabajo. Las unidades son opcionales según la
configuración del terminal. En este caso, el mecánico decide finalizar el trabajo
mediante huella.
5. Después de esto, desde la aplicación, se sincroniza el terminal con ésta. Se
pasarán todos los fichajes.
Se muestran los costes al sincronizar y se ve que se ha añadido a la lista de costes
tanto el inicio de trabajo como la finalización del mecánico.
62
Se filtra por usuario (empleado con id 4). Además, en esta tabla queda reflejado el
modo de identificación de una operación. Al iniciar trabajo, el empleado utilizó
PIN+PWD y al finalizarlo, huella. Se pueden combinar varios filtros.
Por último, en caso en que se quiera crear un informe, la pantalla de costes
ofrece esta funcionalidad. Desde ahí, plasmaríamos todos los costes de
producción en un informe con el formato elegido (Word, Excel, PDF).