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


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

http://es.wikipedia.org/wiki/Etiquetas_RFID

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:


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.

http://es.wikipedia.org/wiki/Licencia_de_software

http://es.wikipedia.org/wiki/Free_Software_Foundation

http://es.wikipedia.org/wiki/Software

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


sleep(2);

}

else if(buffer[0]=='1')

{

printf("ACCESO ACEPTADO\n");


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);



}

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();


jButton5 = new javax.swing.JButton();

66

jScrollPane1 = new javax.swing.JScrollPane();

jTable1 = new javax.swing.JTable();








jTextField1 = new javax.swing.JTextField();















jScrollPane2 = new javax.swing.JScrollPane();

jTable2 = new javax.swing.JTable();











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);


javax.swing.ImageIcon(getClass().getResource("/recursos/Actualizar.png"))); //

NOI18N

jButton6.setText("Actualizar");




}

});

jButton2.setText("Salir");




}

});

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,


.addComponent(jLabel9)

.addGap(12, 12, 12)

.addComponent(jLabel10,

javax.swing.GroupLayout.DEFAULT_SIZE, 871, Short.MAX_VALUE))



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(


.addGroup(jPanel3Layout.createSequentialGroup()

.addContainerGap()


ut.Alignment.BASELINE)





.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELAT

ED)






ED)

.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE,


.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNREL

ATED)


.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() {


jTextField1ActionPerformed(evt);

}

});

jTextField3.addKeyListener(new java.awt.event.KeyAdapter() {

public void keyReleased(java.awt.event.KeyEvent evt) {

jTextField3KeyReleased(evt);

69

}

});

jButton1.setText("Registrar");




}

});

jTextField4.setEditable(false);

jTextField4.addMouseListener(new java.awt.event.MouseAdapter() {

public void mouseReleased(java.awt.event.MouseEvent evt) {

jTextField4MouseReleased(evt);

}

});

jButton7.setText("Tag Tarjeta");




}

});

jButton8.setText("Limpiar");




}

});

jButton9.setText("Lugares de Acceso");




}

});

jLabel5.setText("Lugar 1");







}

});







.addContainerGap()

70


ut.Alignment.LEADING)


.addGroup(jPanel1Layout.createParallelGroup(javax.swing.G

roupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createParallelGroup(javax.swi

ng.GroupLayout.Alignment.LEADING, false)


javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,

Short.MAX_VALUE)


javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,

Short.MAX_VALUE)

.addComponent(jLabel3))




nt.RELATED, 36, Short.MAX_VALUE)


roupLayout.Alignment.TRAILING, false)

.addComponent(jTextField4,

javax.swing.GroupLayout.Alignment.LEADING)







javax.swing.GroupLayout.PREFERRED_SIZE)))









javax.swing.GroupLayout.PREFERRED_SIZE)


nt.UNRELATED)





nt.UNRELATED)




.addContainerGap())

);




.addContainerGap()


.addGap(18, 18, 18)




71


javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,


.addGap(18, 18, 18)







.addGap(18, 18, 18)







.addGap(18, 18, 18)







.addGap(18, 18, 18)


.addGap(18, 18, 18)



ED)



ED)


.addGap(178, 178, 178)






.addContainerGap())

);

jTabbedPane1.addTab("Asignar Tarjeta", jPanel1);

jLabel12.setText("Historial de usos");


javax.swing.ImageIcon(getClass().getResource("/recursos/Actualizar.png"))); //

NOI18N

jButton12.setText("Actualizar");




}

});

jTable2.setModel(new javax.swing.table.DefaultTableModel(

new Object [][] {

72

},

new String [] {

"Nombres", "Apellidos", "Cedula", "Sitio de Acceso", "Fecha"

}

));

jScrollPane2.setViewportView(jTable2);





}

});

jButton14.setText("Graficar");




}

});

jTextField5.addActionListener(new java.awt.event.ActionListener() {


jTextField5ActionPerformed(evt);

}

});

jTextField5.addKeyListener(new java.awt.event.KeyAdapter() {

public void keyReleased(java.awt.event.KeyEvent evt) {

jTextField5KeyReleased(evt);

}

});

jLabel13.setText("Buscar por cedula: ");








.addContainerGap()


ut.Alignment.TRAILING)


javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE,









nt.RELATED)




73




.addGap(18, 18, 18)



nt.RELATED)


javax.swing.GroupLayout.DEFAULT_SIZE, 759, Short.MAX_VALUE)))

.addContainerGap())

);




.addContainerGap()


.addGap(18, 18, 18)








.addGap(18, 18, 18)




.addGap(18, 18, 18)





.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,

Short.MAX_VALUE))

);

jTabbedPane1.addTab("Historial", jPanel4);


javax.swing.ImageIcon(getClass().getResource("/recursos/Tarjeta Unal.jpg"))); //

NOI18N




}

});


javax.swing.ImageIcon(getClass().getResource("/recursos/usuario.png"))); //

NOI18N




}

});

jLabel7.setText("Tarjetas");

74

jLabel8.setText("Usuarios");





}

});








ut.Alignment.LEADING)


.addGap(78, 78, 78)





.addContainerGap()



.addContainerGap()


roupLayout.Alignment.LEADING)


.addGap(12, 12, 12)




.addComponent(jLabel7)))



.addContainerGap(935, Short.MAX_VALUE)




.addContainerGap())

);




.addGap(38, 38, 38)


.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNREL

ATED)

.addComponent(jButton3, javax.swing.GroupLayout.PREFERRED_SIZE,

163, javax.swing.GroupLayout.PREFERRED_SIZE)


ED)


.addGap(12, 12, 12)

.addComponent(jButton4, javax.swing.GroupLayout.PREFERRED_SIZE,

231, javax.swing.GroupLayout.PREFERRED_SIZE)

75

.addGap(25, 25, 25)


.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)


layout.createSequentialGroup()

.addContainerGap()

.addComponent(jTabbedPane1, javax.swing.GroupLayout.DEFAULT_SIZE,


.addContainerGap())

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)


layout.createSequentialGroup()

.addContainerGap()

.addComponent(jTabbedPane1, javax.swing.GroupLayout.DEFAULT_SIZE,


.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


//TODO



try

{

currentTableContent = ctrhistorial.getListbyUso(lugar);

}

catch (Exception e)

{


datos...");



this.dispose();

return;

}








{







77



}

}

private void updateTableContent2()

{


//TODO



try

{

currentTableContent = ctrhistorial.getList();

}

catch (Exception e)

{


datos...");



this.dispose();

return;

}








{









}

}

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)

{


datos...");



this.dispose();

return;

}








{



usuario = ctrusuario.getByCedula(currentRegistro.getCedula());


currentRow[1] = usuario.getNombre();

currentRow[2] = usuario.getApellido();

currentRow[3] = currentRegistro.getTag();


}

}

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) {


this.dispose();

Tarjetavista tarjeta = new Tarjetavista();

79

tarjeta.setVisible(true);

tarjeta.setAlwaysOnTop(true);

}



this.dispose();

Usuariovista usuariov = new Usuariovista();

usuariov.setVisible(true);

usuariov.setAlwaysOnTop(true);

}



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);

}


{

acceso.setEntrada(1);

}


{

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 ");

}

}

}



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) {


}

private void formWindowOpened(java.awt.event.WindowEvent evt) {


}

private void jTextField1MouseReleased(java.awt.event.MouseEvent evt) {


}


81


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 jPanel3MouseEntered(java.awt.event.MouseEvent evt) {


}



this.dispose();

Bucarreg buscar = new Bucarreg();

buscar.setVisible(true);

buscar.setAlwaysOnTop(true);

}

private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {


}



this.setDefaultCloseOperation(EXIT_ON_CLOSE);

this.dispose();

System.exit(0);

}



Lugaresvista lugares = new Lugaresvista(this);

lugares.setVisible(true);




}



this.dispose();

System.exit(0);

}



this.dispose();

82

System.exit(0);

}



this.dispose();

System.exit(0);

}



updateTableContent2();

}



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) {


if(!isNumeric(jTextField5.getText()))

{

JOptionPane.showMessageDialog(rootPane, "El dato en este campo debe

ser numerico");


}

else

{

int ced = Integer.parseInt(jTextField5.getText());

updateTableContentbySearch(ced);

}

}

private void jTextField5ActionPerformed(java.awt.event.ActionEvent evt) {


}

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.JLabel jLabel1;


public javax.swing.JLabel jLabel11;











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;





// End of variables declaration

}

85

Documents

Formato Tesis Final