Formato Tesis Final
Transcript of Formato Tesis Final
SISTEMA PARA CONTROL Y MONITOREO EN LOGÍSTICA DE EVENTOS
BASADO EN RFID
EDISON ARLEY NIÑO TORRES
EDWIN JAVIER MARTINEZ MESA
UNIVERSIDAD NACIONAL DE COLOMBIA
FACULTAD DE INGENIERÍA
DEPARTAMENTO DE INGENIERÍA ELÉCTRICA Y ELECTRÓNICA
BOGOTÁ
2010
SISTEMA PARA CONTROL Y MONITOREO EN LOGÍSTICA DE EVENTOS
BASADO EN RFID
EDISON ARLEY NIÑO TORRES
EDWIN JAVIER MARTINEZ MESA
TRABAJO DE GRADO
DIRECTOR: JHON JAIRO RAMIREZ ECHEVERRY
UNIVERSIDAD NACIONAL DE COLOMBIA
FACULTAD DE INGENIERÍA
DEPARTAMENTO DE INGENIERÍA ELÉCTRICA Y ELECTRÓNICA
BOGOTÁ
2010
AGRADECIMIENTOS
Este proyecto no se hubiera podido llevar a cabo sin la participación de gran
cantidad de personas, entre las cuales debemos resaltar a nuestros familiares y
amigos como parte fundamental de nuestra formación, por lo que agradecemos su
apoyo incondicional.
A nuestro director de tesis, ingeniero John Jairo Ramírez por su orientación antes
y durante el desarrollo del proyecto.
Al grupo de investigación CMUN, dirigido por el ingeniero John Jairo Ramírez y el
ingeniero Julián Herrera, por brindarnos el espacio para desarrollar nuestra idea
de tesis y poderla llevar a cabo.
CONTENIDO
1. INTRODUCCION ............................................................................................ 10
2. OBJETIVOS .................................................................................................... 11
2.1. Objetivo General. ...................................................................................... 11
2.2. Objetivos específicos. ............................................................................... 11
3. Marco teórico .................................................................................................. 12
3.1. Marco Conceptual. .................................................................................... 12
3.1.1. Logística de Eventos ............................................................................. 12
3.1.2. Software Libre ....................................................................................... 13
3.1.3. RFID: Identificación por Radiofrecuencia. ............................................. 13
3.1.3.1. Tag Pasivo. ..................................................................................... 14
3.1.3.2. Tag Activo. ...................................................................................... 14
3.1.4. Sistema Embebido ................................................................................ 14
3.1.4.1. Compilación Cruzada ...................................................................... 15
3.1.4.2. Buildroot .......................................................................................... 16
3.1.5. Bases de datos................................................................................... 16
3.1.5.1. Modelo Standalone ......................................................................... 17
3.1.5.2. Modelo Cliente-Servidor.................................................................. 17
3.1.5.3. ¿Por qué MySQL? ...................................................................... 1817
3.2. Marco Contextual ...................................................................................... 18
3.2.1. Ventajas del Software libre ................................................................. 18
4. Descripción del proyecto................................................................................. 20
4.1. Descripción General ................................................................................. 20
4.1.1. Bloque 1: Inscripción al Evento .......................................................... 21
4.1.2. Bloque 2: Puntos remotos de monitoreo y control .............................. 24
4.1.3. Bloque3: Base de datos ..................................................................... 27
4.2. Campos de Información de la base de datos ....................................... 2928
5. Especificaciones ......................................................................................... 3130
5.1. ATNGW100 Network Gateway ............................................................. 3130
5.2. RFID ..................................................................................................... 3231
5.2.1. HF Mifare Easy Compact Plug&Play RS-232 ................................. 3231
5.2.2. TAG Mifare MF1ISC50 ................................................................... 3433
5.3. Otros ..................................................................................................... 3534
5.3.1. Modulo USART-RS232 .................................................................. 3534
5.3.2. Cable USB-Serial ........................................................................... 3736
6. DEsarollo .................................................................................................... 3938
6.1. Configuración del Sistema Embebido ................................................... 3938
6.1.1. Modificación del Kernel con Buildroot ............................................ 3938
6.1.2. Herramientas de Compilación Cruzada. ......................................... 4140
6.1.3. Comunicación Serial con Modulo RFID .......................................... 4140
6.1.4. Comunicación y Envió de Datos por Ethernet ................................ 4241
6.2. Programa en C para la aplicación ......................................................... 4342
6.3. Base de datos ....................................................................................... 4847
6.4. Interfaz Grafica ..................................................................................... 5047
7. resultados ................................................................................................... 5351
8. Conclusiones .............................................................................................. 5654
9. Recomendaciones ...................................................................................... 5755
10. Glosario .................................................................................................... 5856
11. BIBLIOGRAFÍA ........................................................................................ 6058
TABLA DE FIGURAS
Figura 1. Esquema general del Proyecto .......................................................... 2122
Figura 2. TAG Mifare MF1ISC50 ...................................................................... 2223
Figura 3. Diagrama general aclaratorio de la arquitectura de diseño de software
MVC empleado .................................................... Error! Bookmark not defined.23
Figura 4. Interfaz gráfica, donde se observan las opciones que le brinda al usuario
y la información de los asistentes inscritos al evento que guarda y consulta de la
base de datos. ................................................................................................... 2324
Figura 5. Vista del Historial generado por la interfaz gráfica. ........................... 2325
Figura 6. Utilidades de búsqueda de información en la base de datos. ........... 2425
Figura 7. (a) Comunicación servidor – Punto remoto. (b) Fotografía del modulo de
monitoreo y control remoto. (c) Visualización de ingreso aceptado. (d)
Visualización de ingreso Denegado. .................................................................. 2627
Figura 8.Diagrama de flujo del programa que se ejecuta en el embebido. ..... Error!
Bookmark not defined.29
Figura 9.Vista general de las tablas y campos de la base de datos relacional,
hecha en el software libre MySQL. ................................................................... 2831
Figura 3. Sistema Embebido NGW100 empleado. ........................................... 3133
Figura 3. Vista General del modulo HF Mifare Easy ......................................... 3335
Figura 4. Vista General del TAG Mifare. ........................................................... 3436
Figura 5. Conexión USART-RS232 extra. ........................................................ 3537
Figura 6. Vista del impreso diseñado. ............................................................... 3638
Figura 7. Fotografía de la PCB diseñada .......................................................... 3739
Figura 8, Fotografía del montaje ....................................................................... 3739
Figura 9. Cable USB-serial ............................................................................... 3840
Figura 10. Menu del Buildroot ........................................................................... 4042
Figura 11. Diagrama de flujo de la aplicación en C. .......................................... 4446
Figura 12. Diagrama general aclaratorio de la arquitectura de diseño de software
MVC (Model-View-Controller) empleado. ............................................................. 50
Figura 13. Pantalla de representación del interfaz grafico, donde se observa las
opciones que le brinda al usuario y la información de los asistentes inscritos al
evento que guarda y lee de la base de datos. ....................................................... 52
Figura 14. Vistas en tiempo real del movimiento de personas por las diferentes
actividades del evento, mostradas en gráficos, y listas informativas. ................ 5253
TABLA DE ANEXOS
ANEXO A. Programa hecho en C para el Sistema Embebido. ..................... 6159
ANEXO B. Programa Interfaz Gráfica en Netbeans (JAVA). ......................... 6563
1. INTRODUCCION
Cuando hablamos de eventos sociales nos estamos refiriendo a una reunión de
personas entorno a un suceso importante y programado, pertenecientes a
cualquier área social, artística o deportiva. Dicha reunión puede presentarse en
forma de seminario, taller, conferencia, inauguración, exposición, entre otros. El
desarrollo de un evento social conlleva gran cantidad de actividades para poderlo
llevar a cabo de manera exitosa. Por ejemplo, se requiere de técnicas de gestión
sobre públicos y de metodologías que permitan una rigurosa y adecuada
organización. Una buena parte de estas actividades están relacionadas con la
identificación de los asistentes al evento, el control de la entrada a los lugares
donde se realizarán diferentes tipos de actividades y el manejo de los permisos
que tienen los asistentes acorde con los derechos adquiridos dentro del evento.
En este trabajo de grado se utilizan como herramientas de ayuda en la logística
de eventos la identificación por radiofrecuencia, RFID 1 , junto con un sistema
embebido2 y una base de datos. El sistema permite la identificación del asistente
al evento, la verificación de sus datos mediante un sistema embebido que se
conecta vía Ethernet a una base de datos y la obtención de información para el
manejo de permisos en el evento. Así mismo, la base de datos almacena la
información necesaria para la elaboración de estadísticas que permitan analizar la
información durante y después del evento.
1RFID (Identificación por Radiofrecuencia) es una tecnología para identificar un objeto mediante
ondas de radio. 2 Un embebido es un computador destinado a desarrollar tareas específicas.
2. OBJETIVOS
2.1. Objetivo General.
Monitorear y controlar el ingreso de las personas asistentes a diferentes
actividades de un evento mediante RFID y un sistema embebido para conectarse
vía Ethernet.
2.2. Objetivos específicos.
Diseñar una aplicación de software para crear una interfaz grafica de
usuario que permita programar los campos de información (nombre,
documento, etc) en la Base de Datos.
Configurar una tarjeta embebida SBC (Single board Computer, con puerto
Ethernet) para que se conecte a una red Ethernet e intercambie información
con la base de datos ubicada en la misma red, la cual contiene la datos de
los asistentes al evento.
Configurar una tarjeta embebida SBC (Single board Computer) con
conexión Ethernet y con sistema operativo basado en Linux, que reciba y
envié información mediante IP para conexión con la base de datos.
Configurar la tarjeta embebida SBC (Single board Computer) para que se
comunique con el modulo lector de RFID mediante el puerto RS232.
Crear una aplicación en el sistema embebido SBC que genere la decisión
de habilitar o no el acceso del asistente al evento, esto mediante
indicadores visuales.
Crear una base de datos con la información de cada asistente al evento, la
cual se recibe mediante una red Ethernet.
3. MARCO TEÓRICO
3.1. Marco Conceptual.
3.1.1. Logística de Eventos
La realización de eventos tiene una gran cantidad de actividades que demandan
mucho trabajo. Se debe tener claro: Los objetivos, el presupuesto, cantidad de
personas a congregar, el lugar donde se va a realizar, el acceso al sitio y el
parqueadero, como cómose va a controlar la entrada de las personas y cómocomo
se va a llevar un registro del desarrollo del evento, etc.
La planificación de un evento se inicia 6 o 8 meses atrás (dependiendo de la
magnitud del evento). Se ha llegado a decir que la realización de un evento puede
llegar a tener 180 ítems o más, para que éste este se desarrolle de forma
adecuada.
La seguridad de los asistentes al evento es un ítem muy importante, sobre todo si
a este esté asisten personas del ámbito político como presidentes, senadores, o
personas con cargos importantes. Es importante conocer quienesquiénes van a
asistir al evento, llegando a ser necesario reconfirmar la asistencia de las
personas al evento y solicitar su identificación al ingresar.
El ingreso de las personas debe realizarse de forma organizada y debe ser
controlado de alguna forma. Es necesario asegurar suficientes sitios de parqueo,
personal que se encargue de la revisión de los vehículos y corroborar la
disponibilidad de cupo. Dentro del evento es necesario contar con la labor de
diversos profesionales para hacer la estadía de las personas lo mas más
placentera posible. Se debe contar con una persona que brinde información
precisa a cerca de cualquier inquietud. (AENIAP, 2006)
3.1.2. Software Libre
A continuación mostramos una definición de software libre encontrada en la
pagina página de GNU: “El software libre es una cuestión de la libertad de los
usuarios de ejecutar, copiar, distribuir, estudiar, cambiar y mejorar el software.
Más precisamente, significa que los usuarios de programas tienen las cuatro
libertades esenciales.
La libertad de ejecutar el programa, para cualquier propósito (libertad 0).
La libertad de estudiar cómo trabaja el programa, y cambiarlo para que
haga lo que usted quiera (libertad 1). El acceso al código fuente es una
condición necesaria para ello.
La libertad de redistribuir copias para que pueda ayudar al prójimo (libertad
2)
La libertad de distribuir copias de sus versiones modificadas a terceros (la
3ª libertad). Si lo hace, puede dar a toda la comunidad una oportunidad de
beneficiarse de sus cambios. El acceso al código fuente es una condición
necesaria para ello.” (GNU Operating Sistem,2010)
3.1.3. RFID: Identificación por Radiofrecuencia.
RFID utiliza la radiofrecuencia para el almacenamiento y recuperación de datos
remoto. El sistema en general se compone de un lector (el cual puede ser a su vez
programador), un TAG y un sistema de procesamiento de datos.
“El propósito fundamental de la tecnología RFID es transmitir la identidad de un
objeto (similar a un número de serie único) mediante ondas de radio. Las
tecnologías RFID se agrupan dentro de las denominadas Auto ID (automatic
identification, o identificación automática).” (wikipedia, 2008)
Los TAG RFID o etiquetas RFID pueden llegar a tener diferentes presentaciones
debido a su pequeño tamaño. Se puede hablar de 2 tipos de TAG: Activos y
Pasivos.
3.1.3.1. Tag Pasivo.
Son Etiquetas RFID que no poseen alimentación, se utiliza la energía del
interrogador (lector) tanto para recibir como para transmitir. Se utilizan técnicas de
construcción de circuitos integrados para su fabricación, alcanzando tamaños
pequeños y llegando a estar ubicados en diferentes superficies como vidrios de
automóviles. El método de fabricación hace que sean económicos y se puedan
fabricar en cadena. Al no contar con batería, están diseñados para tener poco
alcance (distancias de lectura de 10 cm a unos pocos metros), no se comportan
muy bien en ambientes ruidosos (paredes metálicas, ruido electromagnético y
todas las superficies que reflejen la señal de radiofrecuencia).
3.1.3.2. Tag Activo.
A diferencia de los Tag’s pasivos, poseen fuente de alimentación, por lo tanto
generan menos errores de lectura. Tiene alcances de cientos de metros y se
pueden utilizar para monitorean diversas variables (temperatura, posición). Debido
a su fuente de alimentación son mas más costosos, tienen menor vida útil y son
más mas grandes que los Tag’s pasivos.
3.1.4. Sistema Embebido
Un sistema embebido es un computador diseñado para un propósito específico, a
diferencia de un computador normal, no tiene todas las aplicaciones y periféricos
que estamos acostumbrados. Un gran número de sistemas embebidos no tiene
interfaz gráfica ni teclado, por lo que solo se puede acceder a ellos por medio del
puerto serial, USB o LAN. Debido a que las aplicaciones de los sistemas
embebidos son específicas, existen gran variedad de los mismos con funciones
distintas. El tamaño de un sistema embebido es mucho menor que el de un
computador de escritorio, por esta razón la capacidad de procesamiento y
almacenamiento es menor.
Cuando se destina un sistema embebido a una actividad determinada, éste este
trabajará trabajara exclusivamente en dicha actividad. Después de ser configurado
para trabajar de una forma determinada, un embebido no realizara realizará una
actividad diferente, lo que lo diferencia de un computador de escritorio, el cual
puede ser destinado a ejecutar diferentes trabajos, es decir, es de propósito
general.
Lo ideal de un sistema embebido es que sea robusto, consuma poca energía y
sea confiable, ya que estos se utilizan para manejar actividades que conllevan
riesgos como el control de operación de algunos dispositivos en aviones.
Los sistemas embebidos tienen componentes de hardware y software. Al igual que
un computador de escritorio, un embebido consta de un sistema operativo, a modo
de comparación, un computador de escritorio cuenta con Linux, mientras un
embebido utiliza u-Linux (micro Linux). Existe gran variedad de sistemas
operativos, debido a que generalmente, este es suministrado por el fabricante del
embebido, el cual desarrolla el sistema operativo o realiza algunas modificaciones
al Kernel de Linux.
3.1.4.1. Compilación Cruzada
Para realizar una aplicación que se va a ejecutar en el sistema embebido, es
conveniente poder utilizar la capacidad de procesamiento de un computador de
escritorio. Por esta razón, existen las herramientas de compilación cruzada, es
Comment [U1]: ES UNA EXPLICACIÓN MUY ESPECÍFICA QUE NO APLICA PARA NUESTRO TRABAJO
decir, se puede crear un ejecutable que sea compatible con las características de
hardware del sistema embebido, el cual no va a funcionar en el computador de
escritorio, pero si en el embebido. Estas herramientas de compilación las
proporciona el fabricante del embebido, o pueden ser creadas mediante el
Buildroot (también proporcionado por el fabricante).
3.1.4.2. Buildroot
El Buildroot es un software que nos permite construir las herramientas de
compilación cruzada, el Kernel de Linux para el embebido y otras herramientas
indispensables para trabajar con el embebido. Este programa tiene
configuraciones predefinidas para sistemas embebidos específicos, pero también
posee un menú para configurar manualmente nuestro Kernel.
3.1.5. Bases de datos
Cuando se trabaja con bases de datos, hay que tener en cuenta quée cantidad de
datos se van a almacenar, cuantas veces se va a acceder a ellos, cuanto se
modifican, cuantos usuarios los acceden simultáneamente, que pasa si se
corrompen o pierden.
Para que una base de datos sea eficiente, es necesario normalizar los datos para
que estos no se repitan en las tablas, de esta forma es mas fácil la actualización,
traspaso y lectura de datos. Las normas básicas de normalización son: Eliminar
datos redundantes, crear una tabla de entidades aparte para cada conjunto de
datos relacionados y por ultimo, especificar un único campo para que funcione
como clave primaria en cada tabla.
El software para crear bases de datos es variado, pero entre los mas conocidos
tenemos Oracle (privativo y costoso), MySQL que antes era libre y fue adquirido
por Oracle, por lo que las licencias son restringidas. Por ultimo último tenemos
PostgreSQL, que tiene desempeño similar a MySQL y es libre. En el momento se
todavía se trabaja bastante con MySQL pero dentro de poco, la licencia va a dejar
de ser publica.
Existen básicamente 2 arquitecturas de bases de datos: Modelo aislado o
Standalone y Modelo Cliente-Servidor.
3.1.5.1. Modelo Standalone
En este modelo, la base de datos y el servidor residen en la misma máaquina, por
lo que contienen el mismo sistema de archivos. Solo puede acceder un usuario
concurrentemente y no estáa en red.
3.1.5.2. Modelo Cliente-Servidor
El cliente y el servidor pueden estar en un computador diferente, pueden acceder
varios usuarios concurrentemente. Esta arquitectura es apropiada para colocarla
en la red, lo que permite el acceso instantáneo a la base de datos donde y cuando
se quiera. La seguridad de la base de datos esta representada por una clave de
administrador y un nombre de usuario.
3.1.5.3. ¿Por qué MySQL?
Elegimos MySQL como software para trabajar la base de datos por ser un
programa de código abierto con licencia GPL, soporte de SQL 3 , excelente
desempeño y confiabilidad, fácil uso de sus herramientas, como la creación de
tablas, posee soporte “gratis” en gran cantidad de foros a nivel mundial y puede
trabajar entre computadores que posean Linux y Windows, es decir, no excluye
entre sistema de archivos.
3.2. Marco Contextual
3.2.1. Ventajas del Software libre
El software libre tiene ciertas ventajas sobre el software privativo, pero esto no
quiere decir que este último no sea útil y obsoleto, ya que existen muchas
aplicaciones que tienen excelentes herramientas. A continuación enumeramos
algunas de estas ventajas:
El factor económico es muy importante, ya que las licencias de software
pueden llegar a ser muy costosas, impidiendo que pequeñas empresas y en
general las personas, puedan contar con el software necesario para
generar progreso. Por esta razón, el software libre se convierte en una
gran alternativa de desarrollo e inclusión de la sociedad.
Las licencias de software libre, permiten la instalación del mismo en la
cantidad de maquinas que el usuario desee, así como su redistribución.
3 Lenguage Query System: Sistema de Lenguaje de Preguntas utilizado generalmente en sistemas
administradores de bases de datos.
Comment [U2]: Revisar si es necesaria una sección sólo para esta parte (“Marco contextual”)
Comment [U3]: Ventajas del software libre o del software privativo?
Se tiene acceso al código fuente del software, por esta razón, se pueden
desarrollar nuevas aplicaciones en base a las existentes sin tener que partir
de cero.
Se centra en la atención al cliente y no en la venta de licencias. Esto es
debido a que las empresas que distribuyen el software compiten en
igualdad de condiciones.
Se logra un mayor soporte debido a la gran cantidad de desarrolladores de
software a nivel mundial. El software privativo esta renovando
continuamente sus productos, dejando de ofrecer el soporte adecuado a
sus productos obsoletos, obligando al usuario a adquirir una versión mas
reciente del software para corregir algún error del anterior o para tener
acceso a nuevas y mejores herramientas.
El software libre maneja formatos de archivos estándar, por esta razón no
tiene problemas de compatibilidad ni de versiones.
La corrección de errores en el software se hace por gran cantidad de
personas en la red, por esta razón, las aplicaciones tienden a ser mas
seguras y estables.
La gestión de software (instalación) es cada vez mas sencilla, contado
actualmente con programas que permiten adquirir gran cantidad de
aplicaciones de forma gratuita con solo marcar una casilla.
Las aplicaciones de software libre están mejorando día a día, debido al gran
trabajo de mucha gente a nivel mundial, llegando a superar al software
privativo. (Digital, 2006)
El software privativo también tiene ventajas, pero este trabajo esta enfocado en
desarrollar herramientas basándose únicamente en software libre.
4. DESCRIPCIÓN DEL PROYECTO
4.1. Poner nuevamente una pequeña justificación redactando el por qué
del proyecto de manera que sirva de contextualización para el lector
antes de comenzar a leer la descripción de la solución a la que
llegamos.
4.1.4.2. Descripción General
El proyecto consta de tres bloques funcionales tal como se muestra en la figura 1:
Lugar de inscripción al evento (bloque 1), puntos remotos de monitoreo y control
distribuidos en los diferentes lugares del evento (bloque 2) y servidor base de
datos (bloque 3).
Figura 1. Esquema general del Proyecto
4.1.1.4.2.1. Bloque 1: Inscripción al Evento
En este lugar, a cada persona se le entrega una tarjeta RFID (Etiqueta o TAG
RFID). En la figura 2 se observa que el TAG utilizado en este proyecto tiene forma
de tarjeta.
Figura 2. TAG Mifare MF1ISC50
El TAG posee una identificación (Identification, ID) propia e irrepetible, por lo cual
la relación “ID-usuario” también será única.
El proceso de inscripción se hace mediante una interfaz gráfica de usuario
desarrollada en Java (Eckel, 2006), sobre la plataforma Netbeans/Linux. Dicho
software utiliza un patrón de diseño MVC (Model-View-Controller) explicado en el
numeral 6.4.
Además de la inscripción, a través de la interfaz gráfica que se encuentra en este
bloque 1, los organizadores del evento pueden:
Registrar los usuarios y seleccionar las actividades a las cuales éstos tienen
permiso para ingresar.
Asignar tarjeta RFID a cada usuario mediante la captura de la ID por medio
un lector RFID (rfid-webshop, 2009), el cual envía la información en formato
RS232 (ver figura 1. Bloque 1).
Permitir búsqueda de registros realizados, por cédula, nombre o ID de la
tarjeta.
Consultar el historial de ingresos de cada usuario a las actividades del evento
detallando la hora y el lugar, tal como se muestra a manera de ejemplo en la
figura 5.
Realizar en tiempo real gráficas con estadísticas del evento (ver figura 5).
Dichas estadísticas pueden ser acerca de los diferentes servicios a los que
acceden los usuarios tales como restaurante, parqueadero, seminarios o
charlas paralelas, etc.
Comment [U4]: Citar en este párrafo, o donde corresponda, las figuras 3, 4 y 5
Figura 3. Interfaz gráfica, donde se observan las opciones que le brinda al usuario y la información de los asistentes inscritos al evento que guarda y consulta de la base de datos.
Figura 4. Vista del Historial generado por la interfaz gráfica.
Figura 5. Utilidades de búsqueda de información en la base de datos.
Indicar que todo los datos ingresados en este punto serán almacenados en la
base de datos, la cual se explicará más adelante. Esto con el fin de que el lector
sepa que todos estos datos son guardados en un servidor y no en el hardware que
implementamos en el proyecto.
4.1.2.4.2.2. Bloque 2: Puntos remotos de monitoreo y control
Un punto remoto de monitoreo y control, hace referencia a los módulos que se
ubican por ejemplo en la entrada, parqueadero, restaurante etc. En estos módulos,
el usuario pasa la tarjeta RFID al momento de ingresar a alguna actividad.
Sitios a ser monitoreados. Para efectos de este proyecto se han seleccionado 3
sitios para ser monitoreados, pero la cantidad de éstos está sujeta a las
necesidades del evento:
Entrada de personas: El objetivo de este sitio en el evento es tener un
punto de control de ingreso de las personas a una actividad o servicio. En
la entrada se puede diferenciar entre asistentes al evento, administrativos,
seguridad, aseo, etc. En este proyecto tomamos una sola categoría de
asistentes al evento, pero las opciones anteriores se pueden desarrollar a
nivel de software en la base de datos, por lo cual la cantidad de
categorías de las personas se puede expandir, permitiendo escalar
fácilmente esta característica acorde con el evento. Al momento del
ingreso las personas deberán presentar la tarjeta RFID que les fue
entregada en el momento de inscripción y que tiene la ID del usuario. El
objetivo es poder verificar si el usuario tiene o no privilegios de ingreso.
Esto se realiza por medio de un lector RFID, comunicado vía Ethernet de
manera remota con la base de datos.
Parqueadero: Este sitio es un punto clave que puede llegar a generar
congestiones e incomodidades si no se tiene información de la cantidad
de vehículos que llegaran al evento. Por esta razón, pretendemos
controlar esta actividad con la tarjeta RFID que se le entrega a cada
asistente para ingresar al evento.
Restaurante: Dependiendo del organizador del evento, éste puede incluir
el derecho a comidas, representado en almuerzo o algún refrigerio. Con
RFID podemos garantizar que esta actividad se desarrolle de forma
organizada y segura, además de brindar información de la cantidad real
de alimentos entregados, datos que son útiles para la contabilidad del
evento.
En los lugares mencionados anteriormente se ubica el módulo de sistema
embebido con lector RFID desarrollado en este trabajo de grado, mostrado en la
figura 7b, el cual se explicará a continuación.
Figura 6. (a) Comunicación servidor – Punto remoto. (b) Fotografía del modulo de monitoreo y control remoto. (c) Visualización de ingreso aceptado. (d) Visualización de ingreso Denegado.
Funcionamiento de los puntos remotos. Cada módulo se basa en un sistema
embebido (Camargo Iván, 2009) y un lector RFID (ver Bloque 2 en la figura 1). El
sistema embebido utilizado es la ATNGW100 (Atmel, 2009), tarjeta de desarrollo
basada en un microprocesador Atmel AT32AP7000 con arquitectura RISC, capaz
de ejecutar instrucciones a 150 MHz, tiene puertos Ethernet, USART y I/O de
propósito general requeridos por el proyecto. El embebido permite comunicar el
lector RFID con la base de datos mediante el puerto Ethernet sin tener que
disponer de un computador o PC en el punto de ingreso. Otras ventajas están
representadas en cuanto al procesamiento de datos, manejo de interfaz gráfica,
sonidos etc. Permitiendo de esta manera un mayor desarrollo del proyecto en una
siguiente etapa.
El lector RFID del módulo obtiene la ID del TAG cuando un usuario acerca la
tarjeta. El sistema embebido recibe la información del lector RFID vía serial, le
agrega la identificación del lugar donde la tarjeta fue leída (sitio donde está
ubicado el módulo: entrada, restaurante o parqueadero) y la envía al servidor de
base de datos, obteniendo la respuesta de si permite o no el acceso. En el
numeral 6.2 se muestra el diagrama de flujo de la rutina que se ejecuta dentro del
embebido.
En el diagrama de flujo mostrado en la figura 8, se describe el funcionamiento de
un punto remoto. Primero se definen los argumento necesarios para gestionar la
conexión con la base de datos: IP y puerto del servidor de base de datos, ID del
punto remoto (entrada, parqueadero y restaurante). En el siguiente bloque se
configuran los dispositivos: USART, leds y socket. A continuación, se realiza un
“bucle” esperando una lectura serial generada por el lector RFID cuando un
usuario acerca su tarjeta. Al realizarse la lectura de la ID del TAG, se concatena
con la ID que identifica la ubicación del punto remoto y se envía a la base de datos.
La base de datos responde con la orden de aceptar o denegar el acceso, para ser
visualizado mediante led’s (figura 7c y 7d).
4.1.3.4.2.3. Bloque3: Base de datos
Todos los datos que se reciben de los puntos remotos de monitoreo del evento y
la información que se adquiere en la interfaz de usurario se guarda y organiza en
una base de datos, conectada a la red Ethernet.
El diseño de la base de datos consiste en crear 5 tablas (ver figura 9) cuya
información se relaciona entre si. Estas tablas son:
Comment [U5]: Estas figuras NO existen.
Comment [U6]: NO CORRESPONDE
Usuario: Contiene los datos personales de las personas que se inscriben al
evento.
Tarjeta: Contiene el registro de los ID de todas las tarjetas con las que se
cuenta y se pueden asignar al usuario.
Lugar: Contiene las actividades donde hay puntos de control y monitoreo
(ejemplo: Parqueadero, Entrada, Restaurante)
Registro: Se carga a partir de las anteriores, ya que contiene la información
del usuario, el ID de la tarjeta que se le asignó y los servicios o privilegios
que adquirió al usuario.
Historial: Durante el evento esta tabla recibe información donde se registra
el uso de las tarjetas. Incluye nombre, cédula, sitio de acceso y fecha con
hora.
Figura 7.Vista general de las tablas y campos de la base de datos relacional, hecha en el software libre MySQL.
4.2.4.3. Campos de Información de la base de datos
Para el manejo de la información de la persona que ingresa al evento (ya sea
empleado o asistente), contamos con una base de datos donde se obtiene la
información al momento de la entrega de la tarjeta RFID. Esta opción nos permite
decidir entre programar toda la información referente a la persona en la tarjeta RFID
o simplemente identificarla mediante la ID única de la tarjeta RFID.
Opción 1: Guardar cada dato de la persona tal y como aparece en el numeral anterior
Opción 2: Identificar a la persona mediante la ID única de la tarjeta RFID asociando
dicho numero a su información personal en la base de datos.
Debido a que nuestro proyecto contempla la idea de que cada modulo lector RFID
esté conectado a una red Ethernet por medio de un sistema embebido, la opción 2 es
la más adecuada debido a que en la base de datos podemos almacenar mucha más
información que la que soporta una tarjeta RFID pasiva (en nuestro caso la
MF1ISC50 contiene l6 sectores con 4 bloques de 16 Bytes cada uno, 17 de los 64
bloques son para tareas especificas). La base de datos además de espacio de
almacenamiento, nos permite tener una estadística exacta en tiempo real del
comportamiento del evento.
De acuerdo a las actividades mencionadas en el numeral anterior, podemos definir
los campos de información que se van a almacenar en la base de datos al momento
en el que el cliente adquiere su entrada al evento.
Numero ID único de la tarjeta RFID.
Nombre del asistente.
Documento de identidad.
Sexo
Actividad que desempeña en el evento (asistente, seguridad, administrativo)
5. ESPECIFICACIONES
5.1. ATNGW100 Network Gateway
El primer hardware, que se requiere para llevar a cabo el funcionamiento del
proyecto, visto anteriormente, es un sistema base que tome la información del
modulo lector RFID, le adicione la información del punto del evento en el que se
encuentra, monte dicha información sobre la red y finalmente reciba la respuesta
que le envía el servidor remoto sobre el que esta la base de datos. Para esta tarea
se recurrió al SBC ATNGW100, o mas conocido como NGW100, el cual es una
tarjeta de desarrollo basada en un microprocesador Atmel AT32AP7000. Con
arquitectura RISC, capaz de ejecutar instrucciones a 150 MHz, diseñado para
aplicaciones en sistemas embebidos de bajo costo y bajo consumo de energía.
Figura 8. Sistema Embebido NGW100 empleado.
Como se observa en la figura, cuenta con diversos interfaces implementados,
tales como:
Comment [U7]: 1.CONSIDERO QUE ESTA SECCIÓN DEBE SER PUESTA DENTRO DE LA “DESCRIPCIÓN DEL PROYECTO” (CAPÍTULO 4) EN CADA BLOQUE DONDE CORRESPONDAN LAS ESPECIFICACIONES QUE ESTÉN PRESENTANDO. AL PONER ESTA SECCIÓN DE “ESPECIFICACIONES” APARTE, QUEDA MUY FRACCIONADA LA INFORMACIÓN, A TAL PUNTO QUE LE TOCA AL LECTOR REGRESARSE EN EL DOCUMENTO O RECORDAR DE QUÉ BLOQUE O SECCIÓN DEL PROYECTO LE ESTÁN HABLANDO.
16/32-bit SDRAM.
Dos 10/100 Ethernet MAC.
Controlador LCD de 2048×2048 pixel TFT/STN
Cuatro USART
Controlador de PS/2
Controlador SPI
Dispositivo USB 2.0 High Speed (480 Mbps)
MultiMedia Card Interface (MCI)
6 Multifunction timer/counters
Watchdog timer
Para la aplicación del proyecto, se requería un modulo USART, para la lectura
serial del modulo lector RFID, y un modulo Ethernet para la comunicación con la
base de datos remota, igualmente la presencia de un lector de tarjetas SDRAM,
facilita la tarea de cargar el programa de la aplicación que ejecuta el
microprocesador.
Aunque este Sistema Embebido está sobredimensionado para las necesidades del
proyecto, permite avanzar en ejecución del mismo a fin de darle culminación en el
tiempo presupuestado, La placa ATNGW100 es capaz de correr el sistema
operativo Linux, versión de núcleo o kernel 2.6., otro aspecto que conllevo a su
adquisición.
5.2. RFID
5.2.1. HF Mifare Easy Compact Plug&Play RS-232
La Universidad Nacional de Colombia sede Bogotá cuenta con los módulos
necesarios para la identificación por radiofrecuencia. Para la lectura-escritura de la
Etiqueta RFID contamos con el modulo HF Mifare Easy compact Plug&Play RS-
232.
Figura 9. Vista General del modulo HF Mifare Easy
A continuación se presentan algunos datos generales del modulo:
• Frecuencia de Operación: 13.56 MHz
• Baud Rate 9600/56700 (Opcional)
• Interfaz RS232/422
• Voltaje de alimentación 5 VDC
• Corriente 80 mA
• Temperatura de operación de -40°C a +85°C
• Distancia de Operación Máx. 50mm hasta 90mm
En cuanto a las etiquetas pasivas RFID, la Universidad cuenta con el TAG Mifare
MF1ISC50. Esta tecnología de tarjetas inteligentes sin contacto, es una de las más
utilizadas a nivel mundial, es de bajo costo y tiene un alcance de lectura de 10 cm.
Esta tarjeta opera de acuerdo la ISO 14443 Tipo A y es desarrollada por NPX
semiconductors.
5.2.2. TAG Mifare MF1ISC50
En cuanto a las etiquetas pasivas RFID, la Universidad cuenta con el TAG Mifare
MF1ISC50. Esta tecnología de tarjetas inteligentes sin contacto, es una de las más
utilizadas a nivel mundial, es de bajo costo y tiene un alcance de lectura de 10 cm.
Esta tarjeta opera de acuerdo la ISO 14443 Tipo A y es desarrollada por NPX
semiconductors.
Figura 10. Vista General del TAG Mifare.
La memoria de las tarjetas MIFARE está compuesta por sectores y bloques, los
cuales tienen mecanismos de seguridad para controlar el ingreso a la información.
Tienen poca capacidad de procesamiento, por esta razón están destinadas a ser
utilizadas en tarjetas de identificación.
Distribución de la memoria: la memoria está dividida en l6 sectores cada uno
con 4 bloques de 16 Bytes. En cada sector están disponibles 3 bloques para
guardar información en formato libre, en resumen 17 de los 64 bloques son para
tareas especificas (incluyendo 1 bloque utilizado por el fabricante). Algunos de los
bloques poseen un formato llamado “formato valor”, estos bloques se comportan
de manera diferente permitiendo operaciones de incremento y descuento (estos
bloques se utilizan por ejemplo en los pasajes de bus).
5.3. Otros
5.3.1. Modulo USART-RS232
Aunque el sistema embebido cuenta con una entrada serial, esta es usada para el
manejo de la consola del sistema operativo, de modo que para comunicar el
puerto USART extra requerido, se implemento un hardware adicional que permite
la correcta conexión serial entre este y el modulo lector RFID. A continuación se
muestra un diagrama del circuito implementado:
Figura 11. Conexión USART-RS232 extra.
Como se observa, está basado en un IC Max3232, el cual tiene la cualidad de ser
un cambiador de niveles de voltaje para el acople de las señales RS232 del lector
RFID, a las señales CMOS del procesador Atmel del sistema embebido.
o LAYOUT
Para la elaboración de las pistas, y en general del impreso se recurrió a la
herramienta de software libre KiCad, la cual se instala de manera práctica
ejecutando en la consola de Linux:
$ sudo apt-get install kicad
La imagen de las pistas se muestra a continuación:
Figura 12. Vista del impreso diseñado.
o CONEXION
Luego de implementar el modulo y ajustarlo físicamente al sistema embebido, se
procedió a realizarle pruebas.
Es de aclarar que la forma del impreso fue establecida de tal manera que tenga
múltiple funcionalidad en el montaje final, así:
Circuito de acople basado en el IC MAX3232
Regulación para la alimentación del embebido (+9v), modulo lector (+5v) y
del IC MAX3232 (+3.3v).
Soporte físico del lector RFID, en la estructura del lector remoto
(parqueadero, entrada,…)
Para una mayor ilustración del resultado obtenido a continuación se muestran
imágenes de la tarjeta.
Figura 13. Fotografía de la PCB diseñada
Figura 14. Fotografía del montaje
5.3.2. Cable USB-Serial
Un último hardware necesario fue un cable USB-serial, el cual no se implemento
debido q que era mas económico adquirirlo en el mercado, y se requiere
inicialmente para el modulo de lectura RFID en el lugar de inscripción de datos,
pero también se usa para el acceso a la consola del sistema embebido, por ello y
la facilidad de manejo, se compro el siguiente cable:
Figura 15. Cable USB-serial
Las únicas características necesarias que se tienen para este cable/adaptador son
que trabaje a la velocidad de la consola del embebido (115200Bps), además que
para practicidad en la alimentación (+5v) del lector RFID del modulo de registro de
tarjetas se modifico dicho hardware para que en uno de sus pines del DB9, que no
se utilizan, enviara dicho voltaje al modulo, solucionando así el inconveniente de
alimentación, eliminando una hardware adicional. Además, se tuvo en cuenta q el
consumo del HF Mifare Easy es de tan solo 80mA, que se encuentra muy por
debajo del máximo permitido para un puerto USB estándar de cualquier
computador comercial.
6. DESAROLLO
6.1. Configuración del Sistema Embebido
El embebido utilizado trabaja con el sistema operativo Linux, antes de montarlo en
la NGW100 es necesario configurarlo de tal forma que nos habilite los periféricos
necesarios para el proyecto. Necesitamos una USART para comunicarnos con el
lector RFID, el puerto WAN para conectarnos con la red Ethernet, el puerto LAN
para tener acceso remoto al sistema embebido en caso de no conocer la IP en el
puerto WAN (suministrada por el Router de la red Ethernet), por esta razón en el
puerto LAN colocamos una IP fija, en este caso 10.0.0.1.
6.1.1. Modificación del Kernel con Buildroot
La imagen del Kernel de Linux para la NGW100, la creamos mediante el Buildroot.
Después de obtener el Buildroot de la página de Atmel, procedemos a configurarlo
para ajustarlo a nuestro hardware. Existen comandos que crean una configuración
predeterminada para cada embebido, estas están definidas por Atmel. Para poder
ejecutar este y posteriores comandos, es necesario ubicarnos en el directorio del
Buildroot (para poder compilar el Buildroot es necesario trabajar en un computador
con sistema operativo Linux).
Abrimos un terminal y nos ubicamos en el directorio del Buildroot Luego
ejecutamos (como súper usuario):
make atngw100_defconfig
Con este paso creamos el archivo .conf, el cual contiene la configuración del
Buildroot para nuestra board NGW100. Es decir, el Buildroot creara el kernel,
toolchain y otras herramientas para nuestro procesador especifico APT7000. Si
Comment [U8]: Cambiar por algo así como: “Configuración del software”. La parte anterior de Hardware también era DESARROLLO del proyecto.
deseamos realizar alguna modificación especifica al Buildroot, podemos hacerlo
manualmente mediante el comando:
make menuconfig
Este comando abre una interfaz gráfica que nos permite navegar en el menú del
Buildroot y seleccionar las opciones que deseemos.
Figura 16. Menu del Buildroot
Se selecciona la versión del kernel 2.XXXXX junto con la orden de crear los
archivos binarios que después serán escritos en la memoria flash para actualizar
la versión del kernel. A continuación ejecutamos el comando:
make source
Con esto hacemos las descargas necesarias de las fuentes descritas en el
Buildroot. Por ultimo damos la orden de compilar el Buildroot.
make
Comment [U9]: ¿????? Qué significan las XXXXX?
El Buildroot se demora aproximadamente 45 minutos compilándose. Cuando
deseamos modificar los archivos binarios creados para la NGW100, no tenemos
que esperar otros 45 minutos de compilación. En este caso realizamos los
siguientes pasos:
make rootclean make Estos comandos borran los archivos binarios anteriores y crean los nuevos con la
modificación respectiva.
6.1.2. Herramientas de Compilación Cruzada.
El toolchain necesario para compilar nuestros programas y después ejecutarlos en
la NGW100 es creado en:
~/buildroot-avr32-v2.3.0/build_avr32/staging_dir/usr/bin/
A continuación se presenta un ejemplo para mostrar como se utilizan estas
herramientas para crear un archivo ejecutable .elf y poder ejecutarlo en la
NGW100.
~/buildroot-avr32-v2.3.0/build_avr32/staging_dir/usr/bin/avr32-linux-gcc -pipe -O3 -g -Wall -mcpu=ap7000 -D_GNU_SOURCE -c -o Hello_World.o Hello_World.c
~/buildroot-avr32-v2.3.0/build_avr32/staging_dir/usr/bin/avr32-linux-gcc -pipe -O3 -g -Wall -mcpu=ap7000 -o Hello_World Hello_World.o
6.1.3. Comunicación Serial con Modulo RFID
Para poder utilizar alguna de las 4 USART del embebido, es necesario configurar
el Buildroot para que nos cree una imagen del Kernel con las USART habilitadas.
Esto se hace modificando el archivo setup.c en $BUILDROOT_DIR/
project_build_avr32/atngw100/linux-2.6.27.6/arch/avr32/ boards/atngw100/setup.c.
Es necesario modificar este documento en 2 partes, de tal forma que quede asi:
void __init setup_board(void) { at32_map_usart(1, 0); /* USART 1: /dev/ttyS0, DB9 */ at32_map_usart(2, 0); /* USART 2: /dev/ttyS0 */ at32_map_usart(3, 2); /* USART 3: /dev/ttyS2 */ at32_map_usart(0, 1); /* USART 0: /dev/ttyS1 */ at32_setup_serial_console(0); } En esta primera partes estamos asignando a cada USART un ttyS, los cuales
aparecerán dentro de la carpeta /dev en Linux. Además podemos ver que a la
USART 1 le estamos asignando el puerto DB9 que trae el embebido.
static int __init atngw100_init(void) { unsigned i; /* * ATNGW100 uses 16-bit SDRAM interface, so we don't need to * reserve any pins for it. */ at32_add_system_devices(); at32_add_device_usart(0); at32_add_device_usart(1); at32_add_device_usart(2); at32_add_device_usart(3);
De esta forma, al compilar el Buildroot, estos módulos USART estarán disponibles
en /dev para ser utilizados por el programa en C.
6.1.4. Comunicación y Envió de Datos por Ethernet
En el menú del buildroot están las opciones de “network” en las cuales se crea la
posibilidad de cargar aplicaciones de red, dado esto se le activaron al Kernel
varias de estas, las cuales son:
DHCP: (Dynamic Host Configuration Protocol - Protocolo Configuración
Dinámica de Servidor) que permite al host obtener sus parámetros de
configuración automáticamente (para gestionar una IP) poder acceder a la red
sobre el protocolo TCP/IP, es la primera y principal tarea que se debe ejecutar
para poder pensar en conectar en red el sistema embebido. Su sintaxis de
ejecución es:
~$udhcp eth0 // donde eth0 es el puerto Ethernet asignado
SSH: (Secure SHell) el cual permite acceder a es la consola del sistema de
manera remota, que fue útil para acceder al sistema embebido sin la
necesidad del cable USB-serial, y convirtiéndose en la principal manera de
manejar los archivos del sistema operativo montado sobre la NGW100. Luego
de cargada la aplicación al arrancar la tarjeta, era posible acceder al sistema
desde cualquier equipo conectado en red, con la observación que si no era
una red LAN, se debía hacer un paso adicional para conocer su IP. La sintaxis
es:
~$ ssh user_name@host_name
Para la NGW100, definiendo root y roota como ususario y contraseña, además
de una IP fija en su puerto Ethernet eth1, seria:
~$ ssh [email protected]
~$ password: roota
6.2. Programa en C para la aplicación
Luego de instalado el sistema operativo LINUX-AVR sobre la tarjeta NGW100, con
las aplicaciones de red e interfaces necesarias activadas y recurriendo a las
herramientas de compilación cruzada vistas a lo largo del documento, se procedió
construir en lenguaje C la aplicación que se ejecutara en cada punto remoto. Esta
se encarga de tomar los datos del RFID por el USART microprocesador,
establecer el socket de comunicación con la base de datos en el servidor remoto y
dependiendo de la información recibida da una respuesta al usuario del sistema
que asiste al evento.
Con el fin de contextualizarse con el código, a continuación se muestra con
lenguaje de usuario, el diagrama de flujo general de dicha aplicación:
Figura 17. Diagrama de flujo de la aplicación en C.
Como se observa, la aplicación tiene esencialmente dos argumentos de entrada,
IP del servidor, y el puerto, información que se usa para el momento de la
conexión por Ethernet. El ID remoto, se refiere al número que se le asigna a cada
punto en el evento, así pues se predeterminó:
Tabla 1. Identificación de Puntos Remotos
LUGAR ID del punto remoto
Entrada Principal 1
Entrada Restaurante 2
Parqueadero 3
Actividad … n n
El código completo de programa se encuentra en el anexo A. De modo que la
línea de comando que inicia el programa sobre el sistema embebido será de la
forma:
~$ ./Nombre_remoto IP_servidor Nº puerto
A modo de de ejemplo, para los lugares implementados se ejecuta así:
~$ ./Entrada 10.203.10.110 5000
~$ ./Restaurante 10.203.10.110 5000
El siguiente paso es iniciar los interfaces, para ellos se cargan las librerías
necesarias para el manejo de los DEVICES:
//librerias socket
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
//librerias serial
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/signal.h>
Para el caso de la entrada serial proveniente del RFID, se establece la velocidad
de transmisión, correspondiente a la del modulo Mifare RFID, y el USART
programado anteriormente, así:
#define BAUDRATE B9600 #define MODEMDEVICE "/dev/ttyS1" fd = open(MODEMDEVICE, O_RDONLY | O_NOCTTY);
Luego se las propiedades para obtener una entrada asincrónica, no canoníca, ya
que solo se requiere la entrada de una cadena de caracteres serial, sin que exista
una periodicidad, ni algún tipo de sincronía con el reloj del sistema embebido, así:
fcntl(fd, F_SETOWN, getpid());
fcntl(fd, F_SETFL, FASYNC);
tcgetattr(fd,&oldtio);
tcflush(fd, TCIFLUSH)
tcsetattr(fd,TCSANOW,&newtio);
De igual manera, para abri el puerto Ethernet, se inicializa el socket:
sockfd= socket(AF_INET, SOCK_DGRAM, 0);
serv_addr.sin_family = AF_INET;
server = gethostbyname(argv[1]);
serv_addr.sin_port = htons(atoi(argv[2]));
Donde se tiene que:
AF_INET: Se refiere a que se maneja IP versión 6.
SOCK_DGRAM: Es un socket UDP.
Server: Contiene el hostmane del servidor suministrado.
Serv_addr.sin_port: lugar de la estructura donde se carga el valor del puerto
a usar.
Con esto ya se esta listo para leer datos y enviarlos. Para obtener el dato serial se
utiliza:
res = read(fd,buf,8)
Siendo buf l registro de 8 bytes donde se almacena el dato leído (el ID del TAG), y
fd el controlador del puerto abierto anteriormente. Se ajusta este dato con el del ID
del punto remoto que se ingreso como argumento y se envía por el socket
establecido:
n=sendto(sockfd,buffer,strlen(buffer),0,&serv_addr,length);
El último paso del programa es leer la información (1 o 0) que le devuelve el
servidor, y mostrarla en los LEDs para denegar o aceptar el ingreso:
recvfrom(sockfd,buffer,256,0,&from, &length);
write(pio,&on_led1,4);
Finalmente el ejecutable que se exporta a la a memoria del la tarjeta NGW100,
para ser ejecutada se obtiene usando el comando de compilación cruzada en el
equipo donde están el ToolChain :
~$ avr32-linux-gcc -pipe -O3 -g -Wall -mcpu=ap7000 -D_GNU_SOURCE -c -o Entrada.o
Entrada.c
~$ /avr32-linux-gcc -pipe -O3 -g -Wall -mcpu=ap7000 -o Entrada Entrada.o
6.3. Base de datos
Para el manejo de la información que se obtiene tanto en la inscripción como la
enviada por los puntos remotos, se diseño una base de datos relacional, en modo
cliente –servidor, como se ha dicho se baso en software libre, con MYSQL server
como la plataforma utilizada. Previstas las necesidades del proyecto se diseño la
adecuada organización de los datos, en 5 tablas como se muestra en la figura 18.
Inicialmente se observa tres tablas principales de las que se desprende la
información que se registra en las otras dos: la tabla llamada usuario, donde se
almacena los datos personales del usuario en el momento de la inscripción. De
igual manera, otra tabla para llevar la relación de tarjetas RFID con las que se
cuentan denominada tarjeta, y tercera llamada lugar donde se los posibles puntos
de control o actividades del evento a monitorear o controlar, para nuestro caso en
específico seria: la entrada, el parqueadero y el restaurante.
La tabla registro, es el espacio en el que se relaciona la información de el usuario
que se inscribió, la tarjeta RFID que le correspondió y los lugares por los cuales
pago. Información que se utiliza en el el programa que tiene el administrador, para
hacer búsquedas y verificaciones de identidad del cliente y asistente al evento.
Una última tabla que se observa en la figura 19, del modelo de datos, corresponde
a la encargada de recoger la información mientras el evento está teniendo lugar y
los módulos remotos ubicados en el establecimiento, comienzan a enviar la
información. Esta tabla denominada Historial es el resumen cronológico de los
accesos a cada actividad, ya que su contenido corresponde a la secuencia de
consultas hechas a la base de datos por parte del los puntos remotos, esto para
verificar el derecho de acceso que tiene el asistente que presenta su tarjeta RFID.
Figura 18. Modelo de datos diseñado para la elaboración de la base de datos.
Con dicha información es con la cual el software diseñado puede crear gráficos de
afluencia a las actividades. Adicionalmente como también se guarda el tiempo y
fecha en el cual el usuario o asistente accede a los puntos remotos o lo que es lo
mismo a las actividades, se puede generar diagramas movimiento de la gente con
respecto al transcurso del tiempo, convirtiéndose esa información en útil y de gran
ayuda para los organizadores del evento.
6.4. Interfaz Gráafica
Basados en el lenguaje de programación JAVA, y sobre la plataforma
NetBean/Linux se desarrolló una aplicación, el cual tiene un patrón de diseño
MVC:
Figura 19. Diagrama general aclaratorio de la arquitectura de diseño de software
MVC (Model-View-Controller) empleado.
Además, se utilizó JPA (Java Persistence API ), como forma de comunicarse con
la base de datos. Esta herramienta permio te cambiar la configuración de la base
de datos sin modificar el código del proyecto.
Los paquetes (packages), que se implementaron en el desarrollo del proyecto, se
observan en la figura 20:
Figura 20. Vista del los paquetes implementados en el código en Netbean
Tabla 1. Descripción los paquetes creados en el código del interfaz grafico.
NOMBRE DESCRIPCION
Meta-inf
Es el archivo XML, donde guarda la configuración para conectarse con la
base de datos. Como es: nombre de la base de datos, puerto, usuario y
contraseña,
Recursos En esta carpeta se encuentran los archivos tales como imágenes,
archivos de sonido, etc.
Accdatos Son los métodos para trabajar en la base de datos (escribir, leer, guardar,
eliminar, consultar y actualizar).
Controladora Contiene la lógica del programa, comunicación entre los métodos que
acceden a la base de datos y la interfaz gráfica.
Entidades Son las tablas que se crean para recibir los datos. Corresponden a las
tablas que se generan y manejan en la base de datos.
Ungestion
Paquete que contiene las clases .class, en el que se diseñan los GUI,
usados para la comunicación con el usuario, a continuación aparecen dos
imágenes, de los interfaces creados para el proyecto:
Figura 21. Pantalla de representación del interfaz grafico, donde se observa las opciones que le brinda al usuario y la información de los asistentes inscritos al evento que guarda y lee de la base de datos.
Figura 22. Vistas en tiempo real del movimiento de personas por las diferentes actividades del evento, mostradas en gráficos, y listas informativas.
7.6. RESULTADOS
En las tablas 3,4 y5 se presentan los resultados obtenidos, detallando cada bloque
mostrado en la figura 1.
Tabla 3. Descripción de Logros Alcanzados en Inscripción al Evento
BLOQUE LOGROS
1. Inscripción al evento
Recepción de la información de los asistentes al evento,
incluyendo la comunicación serial con el lector RFID para
asignación de TAG.(ver figura 4)
Búsqueda de información mediante el uso de las llaves
nombre, documento de identidad e ID del TAG. (figura 6)
Comunicación mediante la red Ethernet con el módulo
ubicado en la entrada, parqueadero y restaurante (figura 7a).
Tabla 4. Descripción de Logros Alcanzados en Punto Remoto
BLOQUE LOGROS
2.Punto Remoto
Instalación de Linux en el sistema embebido y configuración
de interfaces de comunicación.
Comunicación serial entre el lector RFID y el sistema
embebido. Esto incluye la adecuación del hardware.
Comunicación con la base de datos mediante el puerto
WAN.
Compilación del kernel de Linux con las interfaces
necesarias para el proyecto.
Formatted Table
Formatted Table
Conexión con el sistema embebido vía serial y SSH4.
Visualizar con led’s la respuesta obtenida de la base de
datos (figura 7c y 7d)
Tabla 5. Descripción de Logros Alcanzados en Servidor de Base de Datos
BLOQUE LOGROS
3.Servidor de Base de
Datos
Relación de tablas de información mediante llaves primarias
en la base de datos (figura 9).
Consulta de información en la base de datos teniendo en
cuenta la solicitud del sistema embebido ubicado en
parqueadero, restaurante y entrada. Este ítem incluye la
respuesta que debe dar la base de datos para permitir o no el
ingreso de la persona a determinada actividad.
A continuación presentamos el costo aproximado que tendríatuvo el proyecto en
cuanto a materiales. En la tabla 6 se especifica el valor de cada componente, en
este caso solo se calculo el precio de un punto remoto. Se puede observar que
debido a que todo el proyecto se trabajo con Software Libre, las licencias no
generan ningún costo al proyecto.
4 Secure Shell. Protocolo que sirve para acceder a maquinas de forma remota a través de una red.
Formatted Table
Tabla 6. Precio Componentes del Proyecto con un Punto Remoto.
Cantidad Componente Precio Unitario Precio Total
1 Computador/Servidor $2’000.000 $2’000.000
1 Embebido NGW100 $180.000 $180.000
2 Lector RFID $170.000 $340.000
2 Cajas acrílicas $15.000 $30.000
1 Cable USB-Serial $30.000 $30.000
1 Tarjeta max3232 $20.000 $20.000
$2’600.000
8.7. CONCLUSIONES
RFID tiene la ventaja de ser un soporte de fácil manipulación en la implementación
de proyectos de monitoreo y control de eventos. Esta herramienta debe estar
soportada por un sistema que permita el manejo de la información, como una
Base de datos.
Los sistemas embebidos llevan a la tecnología RFID a un nivel de interconexión
alto, permitiéndole procesamiento de datos, acceso a iInternet u otras redes,
manejo de interfaz gráfica, sonidos etc.
Este proyecto constituye una herramienta base del uso de la tecnología RFID. El
soporte que le da la base de datos y la conexión a la red Ethernet, nos permite
llegar a utilizar esta herramienta en numerosas áreas, surgiendo ideas de
desarrollo para diversas aplicaciones.
El uso de RFID nos garantiza una mayor seguridad y confiabilidad de la
información. Métodos como el código de barras tienen problemas de seguridad,
los lectores no son fáciles de utilizar y necesitan contacto visual directo con el
objeto que se quiere identificar.
9.8. RECOMENDACIONES
En el desarrollo del proyecto, surgieron varias ideas para mejorar el proyecto y
continuarlo desarrollando. A continuación presentamos algunas recomendaciones
a tener en cuenta:
En este proyecto de tesis de grado, se desarrollo una herramienta base, la cual
puede mejorarse bastante a diferentes niveles. En cuanto a software, la interfaz
grafica podría tener más opciones para el organizador del evento y entregar los
datos estadísticos de diferentes formas y más detallados. En cuanto a hardware,
se observo que el sistema embebido utilizado tiene gran cantidad de periféricos y
funciones que no son utilizadas en el proyecto, por esta razón, consideramos que
se debe implementar un sistema embebido propio para esta aplicación o conseguir
uno en el mercado que se ajuste al proyecto.
La base de datos puede entregar una mayor cantidad de información útil para el
organizador del evento, para esto, se debería llevar a cabo un estudio a cerca de
cómo seleccionar esta información.
10.9. GLOSARIO
Base de Datos. Es una colección estructurada de tablas que contienen datos.
Base de Datos Relacional. Permite establecer interconexiones (relaciones) entre
los datos que están guardados en tablas de la base de datos.
Embebido. Un embebido es un computador destinado a desarrollar tareas
específicas.
MYSQL. Es un sistema de administración relacional de bases de datos. Es un
software de fuente abierta, licencia GPL.
Licencia GPL. Licencia Publica General de GNU, es una licencia creada por la
Free Software Foundation en 1989 (la primera versión), y está orientada
principalmente a proteger la libre distribución, modificación y uso de software
(Wikipedia La Enciclopedia Libre)
RFID (Identificación por Radiofrecuencia) es una tecnología para identificar un
objeto mediante ondas de radio.
SQL. Lenguage Query System: Sistema de Lenguaje de Preguntas utilizado
generalmente en sistemas administradores de bases de datos.
SSH. Secure Shell. Protocolo que sirve para acceder a maquinas de forma remota
a través de una red.
60
11.10. BIBLIOGRAFÍA
AENIAP. 2006. AENIAP. [En línea] 2006.
http://www.utp.edu.co/~aneiap/logistica.htm..
Atmel. 2009. Atmel. [En línea] 2009.
http://www.atmel.com/dyn/products/tools_card.asp?tool_id=4102.
Bareño, Carlos Iván Camargo. GMUN. [En línea]
ww.gmun.unal.edu.co/~cicamargoba/embebidos/book.pdf.
Digital, Abadía. 2006. Abadía Digital. [En línea] 30 de octubre de 2006.
http://www.abadiadigital.com/articulo/diez-ventajas-del-software-libre-y-propietario/.
Eckel, Bruce. !Thinking in Java”, Upper Saddle River. s.l. : NJ Prentice Hall 2006.
Ph.D., Craig Hollabaugh. 2002. Embedded Linux®: Hardware, Software, and
Interfacing. s.l. : Addison Wesley, 2002.
rfid-webshop. 2009. rfid-webshop. [En línea] 2009. http://www.rfid-
webshop.com/shop/download/Reader/HF%2013.56%20MHz/ACG/ISO%2014443/
TAGnology_ MifareEasy_Manual.pdf.
Sistem, GNU Operating. GNU Operating Sistem. [En línea]
http://www.gnu.org/philosophy/free-sw.es.html.
wikipedia. 2008. Wikipedia La Enciclopedia Libre. [En línea] 2008.
http://es.wikipedia.org/wiki/RFID. 1.
61
ANEXOS
ANEXO A. Programa hecho en C para el Sistema Embebido.
#include <stdio.h>
#include <sys/types.h>
//librerias socket
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
//librerias serial
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/signal.h>
//librerias gpio
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
/////////
#define BAUDRATE B9600
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* POSIX compliant source */
#define FALSE 0
#define TRUE 1
//variables globales serial
int contador=0;
void signal_handler_IO (int status); /* definition of signal handler */
int wait_flag=TRUE; /* TRUE while no signal received */
volatile int STOP=FALSE;
//char TAG_ID[11]; //variable para manejar # leido hacia el
transmitido
// Main (con el de socket)
int main(int argc, char *argv[])
{
//variables internas socket
int sockfd, n,length;
struct sockaddr_in serv_addr, from;
struct hostent *server;
char buffer[10];
//variables internas serial
int fd,res;
struct termios oldtio,newtio;
62
struct sigaction saio; /* definition of signal action */
char buf[9];
//variables gpio-leds
const char *dev_name = "/dev/gpio0";
unsigned int on_led1 = 1;
unsigned int on_led2 = 4;
unsigned int err_led = 5;
unsigned int off_led = 0;
int pio = 0;
//CICLO WHILE
while(1)
{
//Inicializar serial
/* open the device to be non-blocking (read will return immediatly) */
fd = open(MODEMDEVICE, O_RDONLY | O_NOCTTY);
if (fd <0) {perror(MODEMDEVICE); exit(-1); }
/* install the signal handler before making the device asynchronous */
saio.sa_handler = signal_handler_IO;
saio.sa_flags = 0;
saio.sa_restorer = NULL;
sigaction(SIGIO,&saio,NULL);
/* allow the process to receive SIGIO */
fcntl(fd, F_SETOWN, getpid());
/* Make the file descriptor asynchronous (the manual page says only
O_APPEND and O_NONBLOCK, will work with F_SETFL...) */
fcntl(fd, F_SETFL, FASYNC);
tcgetattr(fd,&oldtio); /* save current port settings */
/* set new port settings for canonical input processing */
newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD;
newtio.c_iflag = IGNPAR | ICRNL;
newtio.c_oflag = 0;
newtio.c_lflag = ICANON;
newtio.c_cc[VMIN]=1;
newtio.c_cc[VTIME]=0;
tcflush(fd, TCIFLUSH);
tcsetattr(fd,TCSANOW,&newtio);
//Inicializar Socket
if (argc < 3) {
fprintf(stderr,"usage %s hostname port\n", argv[0]);
exit(0);
}
sockfd= socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) error("socket");
serv_addr.sin_family = AF_INET;
server = gethostbyname(argv[1]);
if (server==0) error("Unknown host");
bcopy((char *)server->h_addr,
(char *)&serv_addr.sin_addr,
63
server->h_length);
serv_addr.sin_port = htons(atoi(argv[2]));
length=sizeof(struct sockaddr_in);
printf("\n>>>>>>>>>>leyendo RFID>>>>>>>>>>\n\n");
while (STOP==FALSE) {
if (wait_flag==FALSE) {
printf("\n>>>>>>>>>>entro if RFID>>>>>>>>>>\n");
res = read(fd,buf,8);
buf[res]=0;
wait_flag = TRUE; /* wait for new input */
STOP=TRUE;
}
}
/* restore old port settings */
tcsetattr(fd,TCSANOW,&oldtio);
wait_flag = TRUE; /* wait for new input */
STOP=FALSE;
close(fd);
printf("Dato leido: \t%s\n",buf);
int i;
for(i=0;i<8;i++)
{
buffer[i]=buf[i];
}
//concatenar el ID del punto remoto
//strcat(buffer,argv[3]);
//buffer[8]=c_str(argv[3]);
buffer[8]='1';
//buffer[8]=(argv[3]);
printf("\n>>>>>>>enviando informacion>>>>>\n\n");
printf("\nDato enviado:\t");
// printf("\nargumento 3 %s:", argv[3]);
write(1,buffer,9);
n=sendto(sockfd,buffer,
strlen(buffer),0,&serv_addr,length);
if (n < 0) error("Sendto");
sleep(3);
n = recvfrom(sockfd,buffer,256,0,&from, &length);
if (n < 0) error("recvfrom");
printf("\nDato recivido:\t");
write(1,buffer,n);
printf("\n>>>>>>>>permisos de entrada>>>>>\n\n");
// RESPUESTA A LOS LEDS//////
pio = open(dev_name, O_RDWR|O_NONBLOCK);
if (pio < 0) {
printf("Error: I could not open the GPIO device.</p>\n");
return 1;
} else {
if(buffer[0]=='0')
{
printf("ACCESO DENEGADO\n");
64
write(pio,&on_led1,4);
sleep(2);
}
else if(buffer[0]=='1')
{
printf("ACCESO ACEPTADO\n");
write(pio,&on_led2,4);
sleep(2);
}
else
{
printf("ERROR EN LEDS\n");
write(pio,&err_led,4);
sleep(2);
}
write(pio,&off_led,4);
}
close(pio);
///fin ciclo while general
}
return 0;
}
//FUNCIONES ADICIONALES
////
void error(char *msg)
{
perror(msg);
exit(0);
}
//
void signal_handler_IO (int status)
{
//printf("received SIGIO signal.\n");
wait_flag = FALSE;
}
65
ANEXO B. Programa Interfaz Gráfica en Netbeans (JAVA).
package ungestion;
import controladora.BarChartDemo;
import controladora.CtrHistorial;
import controladora.CtrLugar;
import controladora.CtrRegistro;
import controladora.CtrTarjeta;
import controladora.CtrUsuario;
import controladora.Lecturaserial;
import entidades.Historial;
import entidades.Lugar;
import entidades.Registro;
import entidades.Tarjeta;
import entidades.Usuario;
import java.awt.Dialog.ModalExclusionType;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.Locale;
import javax.swing.ImageIcon;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import org.jfree.ui.RefineryUtilities;
/**
*
*
*/
public class Principal extends javax.swing.JFrame {
/** Creates new form Principal */
public Principal() {
initComponents();
this.setLocationRelativeTo(null);
jLabel5.setVisible(false);
jLabel6.setVisible(false);
jLabel11.setVisible(false);
}
boolean successConnection;
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
jTabbedPane1 = new javax.swing.JTabbedPane();
jPanel3 = new javax.swing.JPanel();
jLabel9 = new javax.swing.JLabel();
jLabel10 = new javax.swing.JLabel();
jButton5 = new javax.swing.JButton();
66
jScrollPane1 = new javax.swing.JScrollPane();
jTable1 = new javax.swing.JTable();
jButton6 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jPanel1 = new javax.swing.JPanel();
jLabel1 = new javax.swing.JLabel();
jLabel2 = new javax.swing.JLabel();
jLabel3 = new javax.swing.JLabel();
jLabel4 = new javax.swing.JLabel();
jTextField1 = new javax.swing.JTextField();
jTextField2 = new javax.swing.JTextField();
jTextField3 = new javax.swing.JTextField();
jButton1 = new javax.swing.JButton();
jTextField4 = new javax.swing.JTextField();
jButton7 = new javax.swing.JButton();
jButton8 = new javax.swing.JButton();
jButton9 = new javax.swing.JButton();
jLabel5 = new javax.swing.JLabel();
jLabel6 = new javax.swing.JLabel();
jLabel11 = new javax.swing.JLabel();
jButton10 = new javax.swing.JButton();
jPanel4 = new javax.swing.JPanel();
jLabel12 = new javax.swing.JLabel();
jButton12 = new javax.swing.JButton();
jScrollPane2 = new javax.swing.JScrollPane();
jTable2 = new javax.swing.JTable();
jButton13 = new javax.swing.JButton();
jButton14 = new javax.swing.JButton();
jTextField5 = new javax.swing.JTextField();
jLabel13 = new javax.swing.JLabel();
jPanel2 = new javax.swing.JPanel();
jButton3 = new javax.swing.JButton();
jButton4 = new javax.swing.JButton();
jLabel7 = new javax.swing.JLabel();
jLabel8 = new javax.swing.JLabel();
jButton11 = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("UNgestion");
setResizable(false);
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowOpened(java.awt.event.WindowEvent evt) {
formWindowOpened(evt);
}
});
jPanel3.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseEntered(java.awt.event.MouseEvent evt) {
jPanel3MouseEntered(evt);
}
});
jLabel9.setText("Ultima actualización: ");
jButton5.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/recursos/Buscar.png"))); // NOI18N
jButton5.setText("Buscar");
jButton5.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton5ActionPerformed(evt);
67
}
});
jTable1.setModel(new javax.swing.table.DefaultTableModel(
new Object [][] {
},
new String [] {
"Cedula", "Nombres", "Apellidos", "Tag Tarjeta"
}
) {
boolean[] canEdit = new boolean [] {
false, false, false, false
};
public boolean isCellEditable(int rowIndex, int columnIndex) {
return canEdit [columnIndex];
}
});
jScrollPane1.setViewportView(jTable1);
jButton6.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/recursos/Actualizar.png"))); //
NOI18N
jButton6.setText("Actualizar");
jButton6.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton6ActionPerformed(evt);
}
});
jButton2.setText("Salir");
jButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton2ActionPerformed(evt);
}
});
javax.swing.GroupLayout jPanel3Layout = new
javax.swing.GroupLayout(jPanel3);
jPanel3.setLayout(jPanel3Layout);
jPanel3Layout.setHorizontalGroup(
jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel3Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.TRAILING)
.addComponent(jScrollPane1,
javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE,
1020, Short.MAX_VALUE)
.addGroup(javax.swing.GroupLayout.Alignment.LEADING,
jPanel3Layout.createSequentialGroup()
.addComponent(jLabel9)
.addGap(12, 12, 12)
.addComponent(jLabel10,
javax.swing.GroupLayout.DEFAULT_SIZE, 871, Short.MAX_VALUE))
.addGroup(javax.swing.GroupLayout.Alignment.LEADING,
jPanel3Layout.createSequentialGroup()
68
.addComponent(jButton6)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlaceme
nt.RELATED)
.addComponent(jButton5))
.addComponent(jButton2,
javax.swing.GroupLayout.PREFERRED_SIZE, 80,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addContainerGap())
);
jPanel3Layout.setVerticalGroup(
jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel3Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.BASELINE)
.addComponent(jLabel9)
.addComponent(jLabel10,
javax.swing.GroupLayout.PREFERRED_SIZE, 15,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELAT
ED)
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.BASELINE)
.addComponent(jButton6)
.addComponent(jButton5))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELAT
ED)
.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE,
370, Short.MAX_VALUE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNREL
ATED)
.addComponent(jButton2)
.addContainerGap())
);
jTabbedPane1.addTab("Usuarios Registrados", jPanel3);
jLabel1.setText("Nombre: ");
jLabel2.setText("Apellido: ");
jLabel3.setText("Cedula: ");
jLabel4.setText("Asignar Tarjeta:");
jTextField1.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseReleased(java.awt.event.MouseEvent evt) {
jTextField1MouseReleased(evt);
}
});
jTextField1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField1ActionPerformed(evt);
}
});
jTextField3.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyReleased(java.awt.event.KeyEvent evt) {
jTextField3KeyReleased(evt);
69
}
});
jButton1.setText("Registrar");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
jTextField4.setEditable(false);
jTextField4.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseReleased(java.awt.event.MouseEvent evt) {
jTextField4MouseReleased(evt);
}
});
jButton7.setText("Tag Tarjeta");
jButton7.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton7ActionPerformed(evt);
}
});
jButton8.setText("Limpiar");
jButton8.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton8ActionPerformed(evt);
}
});
jButton9.setText("Lugares de Acceso");
jButton9.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton9ActionPerformed(evt);
}
});
jLabel5.setText("Lugar 1");
jLabel6.setText("Lugar 2");
jLabel11.setText("Lugar 3");
jButton10.setText("Salir");
jButton10.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton10ActionPerformed(evt);
}
});
javax.swing.GroupLayout jPanel1Layout = new
javax.swing.GroupLayout(jPanel1);
jPanel1.setLayout(jPanel1Layout);
jPanel1Layout.setHorizontalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel1Layout.createSequentialGroup()
.addContainerGap()
70
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.LEADING)
.addGroup(jPanel1Layout.createSequentialGroup()
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.G
roupLayout.Alignment.LEADING)
.addGroup(jPanel1Layout.createParallelGroup(javax.swi
ng.GroupLayout.Alignment.LEADING, false)
.addComponent(jLabel1,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)
.addComponent(jLabel2,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)
.addComponent(jLabel3))
.addComponent(jLabel4)
.addComponent(jButton7))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlaceme
nt.RELATED, 36, Short.MAX_VALUE)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.G
roupLayout.Alignment.TRAILING, false)
.addComponent(jTextField4,
javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jTextField3,
javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jTextField2,
javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jTextField1,
javax.swing.GroupLayout.PREFERRED_SIZE, 884,
javax.swing.GroupLayout.PREFERRED_SIZE)))
.addComponent(jLabel5)
.addComponent(jButton9)
.addComponent(jLabel6)
.addComponent(jLabel11)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel1Layout.createSequentialGroup()
.addComponent(jButton8,
javax.swing.GroupLayout.PREFERRED_SIZE, 126,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlaceme
nt.UNRELATED)
.addComponent(jButton1,
javax.swing.GroupLayout.PREFERRED_SIZE, 128,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlaceme
nt.UNRELATED)
.addComponent(jButton10,
javax.swing.GroupLayout.PREFERRED_SIZE, 83,
javax.swing.GroupLayout.PREFERRED_SIZE)))
.addContainerGap())
);
jPanel1Layout.setVerticalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel1Layout.createSequentialGroup()
.addContainerGap()
.addComponent(jLabel4)
.addGap(18, 18, 18)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.BASELINE)
.addComponent(jLabel1)
71
.addComponent(jTextField1,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.BASELINE)
.addComponent(jLabel2)
.addComponent(jTextField2,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.BASELINE)
.addComponent(jLabel3)
.addComponent(jTextField3,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.BASELINE)
.addComponent(jTextField4,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jButton7))
.addGap(18, 18, 18)
.addComponent(jButton9)
.addGap(18, 18, 18)
.addComponent(jLabel5)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELAT
ED)
.addComponent(jLabel6)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELAT
ED)
.addComponent(jLabel11)
.addGap(178, 178, 178)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.BASELINE)
.addComponent(jButton10)
.addComponent(jButton8)
.addComponent(jButton1))
.addContainerGap())
);
jTabbedPane1.addTab("Asignar Tarjeta", jPanel1);
jLabel12.setText("Historial de usos");
jButton12.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/recursos/Actualizar.png"))); //
NOI18N
jButton12.setText("Actualizar");
jButton12.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton12ActionPerformed(evt);
}
});
jTable2.setModel(new javax.swing.table.DefaultTableModel(
new Object [][] {
72
},
new String [] {
"Nombres", "Apellidos", "Cedula", "Sitio de Acceso", "Fecha"
}
));
jScrollPane2.setViewportView(jTable2);
jButton13.setText("Salir");
jButton13.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton13ActionPerformed(evt);
}
});
jButton14.setText("Graficar");
jButton14.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton14ActionPerformed(evt);
}
});
jTextField5.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField5ActionPerformed(evt);
}
});
jTextField5.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyReleased(java.awt.event.KeyEvent evt) {
jTextField5KeyReleased(evt);
}
});
jLabel13.setText("Buscar por cedula: ");
javax.swing.GroupLayout jPanel4Layout = new
javax.swing.GroupLayout(jPanel4);
jPanel4.setLayout(jPanel4Layout);
jPanel4Layout.setHorizontalGroup(
jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel4Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.TRAILING)
.addComponent(jScrollPane2,
javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE,
1020, Short.MAX_VALUE)
.addComponent(jLabel12,
javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel4Layout.createSequentialGroup()
.addComponent(jButton14,
javax.swing.GroupLayout.PREFERRED_SIZE, 91,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlaceme
nt.RELATED)
.addComponent(jButton13,
javax.swing.GroupLayout.PREFERRED_SIZE, 96,
javax.swing.GroupLayout.PREFERRED_SIZE))
73
.addGroup(javax.swing.GroupLayout.Alignment.LEADING,
jPanel4Layout.createSequentialGroup()
.addComponent(jButton12)
.addGap(18, 18, 18)
.addComponent(jLabel13)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlaceme
nt.RELATED)
.addComponent(jTextField5,
javax.swing.GroupLayout.DEFAULT_SIZE, 759, Short.MAX_VALUE)))
.addContainerGap())
);
jPanel4Layout.setVerticalGroup(
jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel4Layout.createSequentialGroup()
.addContainerGap()
.addComponent(jLabel12)
.addGap(18, 18, 18)
.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.BASELINE)
.addComponent(jButton12)
.addComponent(jTextField5,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel13))
.addGap(18, 18, 18)
.addComponent(jScrollPane2,
javax.swing.GroupLayout.PREFERRED_SIZE, 344,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.BASELINE)
.addComponent(jButton13)
.addComponent(jButton14))
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))
);
jTabbedPane1.addTab("Historial", jPanel4);
jButton3.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/recursos/Tarjeta Unal.jpg"))); //
NOI18N
jButton3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton3ActionPerformed(evt);
}
});
jButton4.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/recursos/usuario.png"))); //
NOI18N
jButton4.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton4ActionPerformed(evt);
}
});
jLabel7.setText("Tarjetas");
74
jLabel8.setText("Usuarios");
jButton11.setText("Salir");
jButton11.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton11ActionPerformed(evt);
}
});
javax.swing.GroupLayout jPanel2Layout = new
javax.swing.GroupLayout(jPanel2);
jPanel2.setLayout(jPanel2Layout);
jPanel2Layout.setHorizontalGroup(
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayo
ut.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addGap(78, 78, 78)
.addComponent(jButton4,
javax.swing.GroupLayout.PREFERRED_SIZE, 150,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGroup(jPanel2Layout.createSequentialGroup()
.addContainerGap()
.addComponent(jLabel8))
.addGroup(jPanel2Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel2Layout.createParallelGroup(javax.swing.G
roupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addGap(12, 12, 12)
.addComponent(jButton3,
javax.swing.GroupLayout.PREFERRED_SIZE, 225,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addComponent(jLabel7)))
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel2Layout.createSequentialGroup()
.addContainerGap(935, Short.MAX_VALUE)
.addComponent(jButton11,
javax.swing.GroupLayout.PREFERRED_SIZE, 97,
javax.swing.GroupLayout.PREFERRED_SIZE)))
.addContainerGap())
);
jPanel2Layout.setVerticalGroup(
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addGap(38, 38, 38)
.addComponent(jLabel7)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNREL
ATED)
.addComponent(jButton3, javax.swing.GroupLayout.PREFERRED_SIZE,
163, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELAT
ED)
.addComponent(jLabel8)
.addGap(12, 12, 12)
.addComponent(jButton4, javax.swing.GroupLayout.PREFERRED_SIZE,
231, javax.swing.GroupLayout.PREFERRED_SIZE)
75
.addGap(25, 25, 25)
.addComponent(jButton11)
.addContainerGap())
);
jTabbedPane1.addTab("Opciones", jPanel2);
javax.swing.GroupLayout layout = new
javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addContainerGap()
.addComponent(jTabbedPane1, javax.swing.GroupLayout.DEFAULT_SIZE,
1060, Short.MAX_VALUE)
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addContainerGap()
.addComponent(jTabbedPane1, javax.swing.GroupLayout.DEFAULT_SIZE,
546, Short.MAX_VALUE)
.addContainerGap())
);
pack();
}// </editor-fold>
private void updateTableContentbySearch(int cedula)
{
//TODO
CtrHistorial ctrhistorial = new CtrHistorial();
//TODO
List<Historial> currentTableContent = null;
Historial currentRegistro;
try
{
currentTableContent = ctrhistorial.getListbyCedula(cedula);
}
catch (Exception e)
{
JOptionPane.showMessageDialog(this, "No se pudo leer la base de
datos...");
successConnection = false; //Connection failure
this.setVisible(false);
this.dispose();
return;
}
successConnection = true; //Success connection
int tableLengh = currentTableContent.size(),i;
DefaultTableModel currentTableModel =
(DefaultTableModel)this.jTable2.getModel();
Object [] currentRow;
76
currentTableModel.setRowCount(0);
for (i=0;i<tableLengh;i++)
{
currentRegistro = currentTableContent.get(i);
currentRow = new Object[5];
currentRow[0] = currentRegistro.getNombres();
currentRow[1] = currentRegistro.getApellidos();
currentRow[2] = currentRegistro.getCedula();
currentRow[3] = currentRegistro.getUso();
currentRow[4] = currentRegistro.getFecha();
currentTableModel.addRow(currentRow);
}
}
private void updateTableContentbySearch(String lugar)
{
//TODO
CtrHistorial ctrhistorial = new CtrHistorial();
//TODO
List<Historial> currentTableContent = null;
Historial currentRegistro;
try
{
currentTableContent = ctrhistorial.getListbyUso(lugar);
}
catch (Exception e)
{
JOptionPane.showMessageDialog(this, "No se pudo leer la base de
datos...");
successConnection = false; //Connection failure
this.setVisible(false);
this.dispose();
return;
}
successConnection = true; //Success connection
int tableLengh = currentTableContent.size(),i;
DefaultTableModel currentTableModel =
(DefaultTableModel)this.jTable2.getModel();
Object [] currentRow;
currentTableModel.setRowCount(0);
for (i=0;i<tableLengh;i++)
{
currentRegistro = currentTableContent.get(i);
currentRow = new Object[5];
currentRow[0] = currentRegistro.getNombres();
currentRow[1] = currentRegistro.getApellidos();
currentRow[2] = currentRegistro.getCedula();
currentRow[3] = currentRegistro.getUso();
77
currentRow[4] = currentRegistro.getFecha();
currentTableModel.addRow(currentRow);
}
}
private void updateTableContent2()
{
CtrHistorial ctrhistorial = new CtrHistorial();
//TODO
List<Historial> currentTableContent = null;
Historial currentRegistro;
try
{
currentTableContent = ctrhistorial.getList();
}
catch (Exception e)
{
JOptionPane.showMessageDialog(this, "No se pudo leer la base de
datos...");
successConnection = false; //Connection failure
this.setVisible(false);
this.dispose();
return;
}
successConnection = true; //Success connection
int tableLengh = currentTableContent.size(),i;
DefaultTableModel currentTableModel =
(DefaultTableModel)this.jTable2.getModel();
Object [] currentRow;
currentTableModel.setRowCount(0);
for (i=0;i<tableLengh;i++)
{
currentRegistro = currentTableContent.get(i);
currentRow = new Object[5];
currentRow[0] = currentRegistro.getNombres();
currentRow[1] = currentRegistro.getApellidos();
currentRow[2] = currentRegistro.getCedula();
currentRow[3] = currentRegistro.getUso();
currentRow[4] = currentRegistro.getFecha();
currentTableModel.addRow(currentRow);
}
}
private void updateTableContent()
{
CtrUsuario ctrusuario = new CtrUsuario();
CtrRegistro ctrregistro = new CtrRegistro();
78
//TODO
List<Registro> currentTableContent = null;
Registro currentRegistro;
Usuario usuario;
try
{
currentTableContent = ctrregistro.getList();
}
catch (Exception e)
{
JOptionPane.showMessageDialog(this, "No se pudo leer la base de
datos...");
successConnection = false; //Connection failure
this.setVisible(false);
this.dispose();
return;
}
successConnection = true; //Success connection
int tableLengh = currentTableContent.size(),i;
DefaultTableModel currentTableModel =
(DefaultTableModel)this.jTable1.getModel();
Object [] currentRow;
currentTableModel.setRowCount(0);
for (i=0;i<tableLengh;i++)
{
currentRegistro = currentTableContent.get(i);
currentRow = new Object[4];
usuario = ctrusuario.getByCedula(currentRegistro.getCedula());
currentRow[0] = currentRegistro.getCedula();
currentRow[1] = usuario.getNombre();
currentRow[2] = usuario.getApellido();
currentRow[3] = currentRegistro.getTag();
currentTableModel.addRow(currentRow);
}
}
private void jTextField3KeyReleased(java.awt.event.KeyEvent evt) {
// TODO add your handling code here:
String textico=jTextField3.getText();
if(isNumeric(textico)==false)
{
JOptionPane.showMessageDialog(rootPane, "El dato en este campo debe
ser numerico");
jTextField3.setText("");
}
}
private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
this.dispose();
Tarjetavista tarjeta = new Tarjetavista();
79
tarjeta.setVisible(true);
tarjeta.setAlwaysOnTop(true);
}
private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
this.dispose();
Usuariovista usuariov = new Usuariovista();
usuariov.setVisible(true);
usuariov.setAlwaysOnTop(true);
}
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
if(jTextField1.getText().equals("") || jTextField2.getText().equals("")
|| jTextField3.getText().equals("")){
JOptionPane.showMessageDialog(rootPane, "No pueden haber campos
vacios");
}
else
{
CtrUsuario ctrusuario = new CtrUsuario();
CtrUsuario ctrusuario2 = new CtrUsuario();
CtrTarjeta ctrtarjeta = new CtrTarjeta();
CtrTarjeta ctrtarjeta2 = new CtrTarjeta();
CtrRegistro ctrregistro = new CtrRegistro();
CtrLugar ctracceso = new CtrLugar();
Usuario usuario = new Usuario();
Usuario usuario2 = new Usuario();
Tarjeta tarjeta = new Tarjeta();
Tarjeta tarjeta2 = new Tarjeta();
Registro registro = new Registro();
Lugar acceso = new Lugar();
//La tabla sitios esta predefinida con 3 sitios
//Llenando datos de la tabla acceso
acceso.setCedula(Integer.parseInt(jTextField3.getText()));
acceso.setRestaurante(0);
acceso.setEntrada(0);
acceso.setParqueadero(0);
if(jLabel5.isVisible())
{
acceso.setRestaurante(1);
}
if(jLabel6.isVisible())
{
acceso.setEntrada(1);
}
if(jLabel11.isVisible())
{
acceso.setParqueadero(1);
}
//Llenando datos de la tabla usuario
80
usuario.setNombre(jTextField1.getText());
usuario.setApellido(jTextField2.getText());
usuario.setCedula(Integer.parseInt(jTextField3.getText()));
//Llenando datos de la tabla Tarjeta
acceso.setTag(jTextField4.getText());
tarjeta.setTag(jTextField4.getText());
//Llenando datos de la tabla registro
registro.setCedula(Integer.parseInt(jTextField3.getText()));
registro.setTag(jTextField4.getText());
registro.setUltimouso("Ninguno");
//Intentando guardar los datos en las tablas
try
{
ctrusuario.save(usuario);
ctrtarjeta.save(tarjeta);
ctrregistro.save(registro);
ctracceso.save(acceso);
JOptionPane.showMessageDialog(rootPane, "Registro Exitoso");
}
catch(Exception e)
{
JOptionPane.showMessageDialog(rootPane, "No se pudo guardar el
registro. Contacte con soporte tecnico ");
}
}
}
private void jButton6ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
updateTableContent();
Date date = new Date();
int dia = date.getDay();
int mes = date.getMonth();
int año = 2010;
int hora = date.getHours();
int minutos=date.getMinutes();
int segundos=date.getSeconds();
jLabel10.setText("Hora: " + hora + ":" + minutos + ":" + segundos + "
Fecha: " + dia + "/" + mes + "/" + año);
}
private void jTextField4MouseReleased(java.awt.event.MouseEvent evt) {
// TODO add your handling code here:
}
private void formWindowOpened(java.awt.event.WindowEvent evt) {
// TODO add your handling code here:
}
private void jTextField1MouseReleased(java.awt.event.MouseEvent evt) {
// TODO add your handling code here:
}
private void jButton7ActionPerformed(java.awt.event.ActionEvent evt) {
81
// TODO add your handling code here:
Lecturaserial lectura = new Lecturaserial();
try {
String tagtarjeta = lectura.lectura();
jTextField4.setText(tagtarjeta);
} catch (Exception ex) {
JOptionPane.showMessageDialog(rootPane, "No se pudo leer la tarjeta,
verifique e intente de nuevo");
}
}
private void jButton8ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
jTextField1.setText("");
jTextField2.setText("");
jTextField3.setText("");
jTextField4.setText("");
}
private void jPanel3MouseEntered(java.awt.event.MouseEvent evt) {
// TODO add your handling code here:
}
private void jButton5ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
this.dispose();
Bucarreg buscar = new Bucarreg();
buscar.setVisible(true);
buscar.setAlwaysOnTop(true);
}
private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.dispose();
System.exit(0);
}
private void jButton9ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
Lugaresvista lugares = new Lugaresvista(this);
lugares.setVisible(true);
jLabel5.setVisible(false);
jLabel6.setVisible(false);
jLabel11.setVisible(false);
}
private void jButton10ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
this.dispose();
System.exit(0);
}
private void jButton11ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
this.dispose();
82
System.exit(0);
}
private void jButton13ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
this.dispose();
System.exit(0);
}
private void jButton12ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
updateTableContent2();
}
private void jButton14ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
CtrHistorial ctrHistorial = new CtrHistorial();
CtrLugar ctrLugar = new CtrLugar();
System.out.println("Accesos : " + ctrLugar.getAccesosResta());
System.out.println("Accesos : " + ctrLugar.getAccesosEntra());
System.out.println("Accesos : " + ctrLugar.getAccesosParque());
System.out.println("Accesos : " + ctrHistorial.getHistoriaResta());
System.out.println("Accesos : " + ctrHistorial.getHistoriaEntra());
System.out.println("Accesos : " + ctrHistorial.getAccesosParque());
BarChartDemo demo = new BarChartDemo("Grafica de
Historial",ctrHistorial.getHistoriaResta(),ctrHistorial.getHistoriaEntra(),ctrHis
torial.getAccesosParque(),ctrLugar.getAccesosResta(),ctrLugar.getAccesosEntra(),c
trLugar.getAccesosParque());
demo.pack();
RefineryUtilities.centerFrameOnScreen(demo);
demo.setVisible(true);
}
CtrHistorial ctrhisto = new CtrHistorial();
private void jTextField5KeyReleased(java.awt.event.KeyEvent evt) {
// TODO add your handling code here:
if(!isNumeric(jTextField5.getText()))
{
JOptionPane.showMessageDialog(rootPane, "El dato en este campo debe
ser numerico");
jTextField5.setText("");
}
else
{
int ced = Integer.parseInt(jTextField5.getText());
updateTableContentbySearch(ced);
}
}
private void jTextField5ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}
private static boolean isNumeric(String dato)
83
{
try
{
Integer.parseInt(dato);
return true;
}
catch(NumberFormatException nfe)
{
return false;
}
}
/**
* @param args the command line arguments
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Principal().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton10;
private javax.swing.JButton jButton11;
private javax.swing.JButton jButton12;
private javax.swing.JButton jButton13;
private javax.swing.JButton jButton14;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JButton jButton4;
private javax.swing.JButton jButton5;
private javax.swing.JButton jButton6;
private javax.swing.JButton jButton7;
private javax.swing.JButton jButton8;
private javax.swing.JButton jButton9;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel10;
public javax.swing.JLabel jLabel11;
private javax.swing.JLabel jLabel12;
private javax.swing.JLabel jLabel13;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
public javax.swing.JLabel jLabel5;
public javax.swing.JLabel jLabel6;
private javax.swing.JLabel jLabel7;
private javax.swing.JLabel jLabel8;
private javax.swing.JLabel jLabel9;
public javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
public javax.swing.JPanel jPanel3;
private javax.swing.JPanel jPanel4;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JScrollPane jScrollPane2;
public javax.swing.JTabbedPane jTabbedPane1;
public javax.swing.JTable jTable1;
private javax.swing.JTable jTable2;
84
private javax.swing.JTextField jTextField1;
private javax.swing.JTextField jTextField2;
private javax.swing.JTextField jTextField3;
private javax.swing.JTextField jTextField4;
private javax.swing.JTextField jTextField5;
// End of variables declaration
}
85