Universidad Técnica Federico Santa María Departamento de ...lsb/elo325/clases/proyectos/ControlAccesoViaWeb... · Universidad Técnica Federico Santa María Departamento de Electrónica

Universidad Técnica Federico Santa María Departamento de Electrónica

“Acceso Controlado vía WEB”

Informe Proyecto Final

Integrantes: Paola Rojas C. Pablo Naveas F. Claudio Ramírez S. Carlos Silva L. Christian Pelissier Q. Profesor: Leopoldo Silva Bijit Fecha: Junio de 2004.

Universidad Técnica Federico Santa María Departamento de Electrónica Seminario de Computadores I

2

Índice: Índice: ...................................................................................................................................... 2 Introducción ............................................................................................................................. 3 Control de Acceso.................................................................................................................... 4

Tarjeta de Desarrollo EasyWeb. .......................................................................................... 4 Tarjetas Inteligentes ............................................................................................................. 5 Lector de Tarjetas MIFARE ................................................................................................ 7

Proyecto Inicial ........................................................................................................................ 8 Control de acceso parte II ........................................................................................................ 9

Detalle del funcionamiento del sistema: .............................................................................. 9 Implementación propiamente tal: ...................................................................................... 11 Códigos utilizados en el desarrollo .................................................................................... 13


3

Introducción

El trabajo inicial realizado en el seminario de microcontroladores contempló la conexión de la tarjeta Easyweb a un lector MIFARE. P&P H6152BA. Esto, con el objetivo de entregar un servicio de acceso controlado a recintos. Mediante la lectura y posterior adquisición del código serial único presente en cada tarjeta inteligente USM se entregó o denegó el acceso a un usuario en particular, gracias a un registro de usuarios almacenado en forma local. Se contempló a su vez la incorporación o eliminación de un usuario a través de los botones disponibles en la tarjeta.

Para el proyecto final, se decidió utilizar las capacidades de conectividad Ethernet de la tarjeta de desarrollo Easyweb, para lo cual se utilizó un packet driver y un stack TCP/IP programados en C y disponibles en la red. De este modo, se evitó el uso innecesario de memoria del microcontrolador trasladando el registro de usuarios a un servidor remoto.

Además de lo anterior, se amplió la comunicación serial con el lector, haciéndola full-duplex (el uC envía comandos al lector de tarjetas), logrando con esto acceder a un bloque de memoria de tarjeta inteligente en el que se encuentra almacenado el RUT del usuario. Adquiriendo entonces dos datos: número serial de la tarjeta inteligente y RUT del usuario. Datos que a su vez son enviados a un servidor mediante una conexión Web generada gracias al stack TCP utilizado. Este servidor procesará la información responderá si el acceso se encuentra autorizado para el usuario o no. En caso de estar autorizado el acceso se activara uno de los relés de la tarjeta Easyweb, desplegando además por el display de la misma el éxito.


4

Control de Acceso

La idea del control de acceso es proveer un control al ingreso a un determinado recinto, permitiendo con esto mejorar el nivel de seguridad en este, pues se limita el acceso al mismo a un numero limitado de individuos que cumplan con ciertas características que gracias a la tecnología disponible puede ser controlado centralizadamente.

Para el desarrollo del proyecto de control de acceso se utilizarán los siguientes implementos:

� Tarjeta de Desarrollo EasyWeb. � Tarjetas Inteligentes. � Lector de Tarjetas MIFARE Standard Card.

A continuación se detallan algunas características de las anteriores:

Tarjeta de Desarrollo EasyWeb.

Algunas características de la tarjeta de desarrollo EasyWeb son:

�� MSP430F149 Microcontrolador Texas Instruments. �� Controlador LAB CS8900 + Transformador LAN y conector RJ45. �� Stack TCP/IP de código abierto de Andreas Dannenberg. �� Tres LED de estatus para la LAN. �� Un LED para propositos generales. �� Dos reles de 10A/240VAC. �� Cuatro botones. �� Salida RS232. �� Buzzer.


5

�� Display LCD de 16x2. �� 24LC515 (64K memoria eeprom para almacenamiento de información). �� Conector JTAG. �� Cristal oscilador de 32 768 Hz. �� Cristal oscilador de 8Mhz.

Tarjetas Inteligentes Las tarjetas inteligentes MIFARE están basadas en el chip Mifare MF1-S50 de Philips,

tienen una distancia de lectura y escritura sin contacto (de modo inalámbrico). Pueden tener almacenada en su memoria distintas aplicaciones, sin uso alguno de baterías. Gracias a esto pueden ser utilizadas en diversas aplicaciones como lo son:

�� Control de Acceso. �� Almacenamiento de patrones biométricos. �� Monedero electrónico. �� Tarjetas de lealtad. �� Tarjetas de débito para universidades. �� Transporte público. �� Etc.

A continuación en la siguiente figura se muestra en detalle de como se encuentran

construidas este tipo de tarjetas:


6

Características: � Una tarjeta que cumple con el estándar MIFARE está conformada por 16 sectores,

donde cada sector posee 4 bloques de 16 bytes. � El bloque cero del sector cero es de sólo lectura donde se almacena la información

del número serial de la tarjeta o Card ID, datos del fabricante e información de control.

� Los bloques finales de cada sector (3, 7, 11, … ,63) almacenan los datos de configuración de cada sector. Estos datos de configuración incluyen las claves de acceso A y B como también las condiciones de acceso al sector. Este bloque recibe el nombre de Sector Trailer.

A continuación se presenta un esquemático de la distribución de la memoria de las tarjetas inteligentes que cumplen con el estándar MIFARE.

En el proyecto a desarrollar se utilizaran las tarjetas inteligentes que tienen en su poder

los alumnos, profesores y funcionarios de la UTFSM. En estas tarjetas inteligentes sólo se encuentra almacenada información de interés (datos de los distintos usuarios) en los sectores 1 y 2, como se puede apreciar en el detalle que se muestra a continuación:

� Sector 1 – Bloque 4: almacena el RUT del usuario. � Sector 2 – Bloque 8: almacena el Nombre del usuario. � Sector 2 – Bloque 9: almacena el primer Apellido del usuario. � Sector 2 – Bloque 10: almacena el segundo Apellido del usuario. Para el caso particular de la aplicación a desarrollar solo es necesario el Card-ID y el Rut

del usuario por lo que solo será necesario leer el bloque 4 del sector 1.


7

Lector de Tarjetas MIFARE

El lector de tarjetas inteligentes que se utilizará es el MIFARE Standard Card fabricado por la empresa Elatec. Este lector tiene la capacidad de leer tarjetas inteligentes ubicadas a una distancia entre 5 a 9 cm, a través de una antena.

A continuación se muestra una fotografía de el lector de tarjetas utilizado.

Características: � Antena Incluida. � Frecuencia de Operación 13.56Mhz. � Interfaz serial incorporada compatible con los estándares RS232/422/485. � Led de operación y led de lectura incorporado. � Lectura de tarjetas a una distancia entre 5 y 9 cm. � Alimentación requerida: 5V/80 mA. � Modo apagado para bajo consumo de energía. � Encriptación de los datos del Tx y Rx.


8

Proyecto Inicial El trabajo inicial realizado en el seminario de microcontroladores contempló la conexión

de la tarjeta EasyWeb a un lector de tarjetas MIFARE. Esto, con el objetivo de entregar un servicio de acceso controlado a recintos. Mediante la lectura y posterior adquisición del Card-ID presente en cada tarjeta inteligente USM se entregó o denegó el acceso a un usuario en particular, gracias a un registro de usuarios almacenado en forma local. Se contempló a su vez la incorporación o eliminación de un usuario a través de los botones disponibles en la tarjeta.

El detalle de los aspectos relevantes de la primera etapa del proyecto se encuentra a continuación.

Descripción:

� Implementación de Sistema Operativo tiempo real. � Lectura de tarjetas se realiza en un solo sentido (lector->EasyWeb). � Implementación de distintas tareas. � Almacenamiento y borrado de tarjetas mediante botones. � Sólo se almacenan números seriales de tarjeta. � Números de serie de tarjetas almacenados en memoria del micro. � Apertura de relé al producirse un éxito. � Aviso por display en caso de fracaso y éxito.

A continuación se presenta un esquemático del funcionamiento del proyecto inicial:


9

Control de acceso parte II La segunda parte del proyecto surgió entre otros factores por el contacto con una

empresa externa que desea poner en uso las características de la credencial universitaria para una aplicación específica de control de acceso.

Las limitaciones del proyecto inicial, principalmente en lo referente a la información obtenida de la tarjeta inteligente (solamente el Card-ID), resultaban en una sub-utilización las características avanzadas que presenta este tipo de dispositivos, que precisamente le han valido que se conozca como tarjeta inteligente. Por lo tanto en esta segunda fase se procede también a leer el Rut del usuario que se encuentra almacenado en el bloque #4 del sector #1. Esto permite implementar un mecanismo de autentificación avanzada mediante Nº de tarjeta y RUT del usuario.

Para lograr el mecanismo de autentificación avanzado que se busca implementar no basta con obtener los datos respectivos de la tarjeta inteligente (Nº de tarjeta y RUT) sino que además se desea que estos datos sean procesados por un servidor que autentifique al respectivo usuario y que valide o no su ingreso al recinto en cuestión, por lo que será fundamental la utilización de las funciones de red que posee la tarjeta de desarrollo EasyWeb, la cual se implementará mediante el stack TCP/IP uIP disponible en la página web del ramo.

Como se dijo anteriormente, el Stack TCP/IP escogido es el uIP creado por Adam Dunkels, el cual presenta las siguientes características que son fundamentales para su implementación:

� Programado en C; buena documentación. � Soporta múltiples conexiones y datagramas. � Refragmenta paquetes. � Permite implementar aplicaciones propias, que luego corren sobre uIP (una a

la vez). Entonces una aplicación corriendo sobre uIP será una función en C que es invocada por

uIP en respuesta a ciertos eventos como son el envío y recepción de datos, establecimiento de una conexión y necesidad de retransmisiones.

Detalle del funcionamiento del sistema:

Se debe ubicar la tarjeta inteligente a una distancia entre 5 y 9 cm. del lector, el cual por defecto leerá de forma automática el bloque #0 del sector #0 de la tarjeta (CARD-ID). Este es enviado en forma continua y de manera automática por la interfaz serial del lector, durante todo el tiempo que se tenga puesta la tarjeta al alcance del lector. Luego manteniendo la tarjeta dentro del alcance del lector se envía el comando de selección de tarjeta (“Enter - S”), obteniéndose en caso de éxito el número serial de la tarjeta. Una vez seleccionada ésta se procede a enviar por la interfaz serial el comando para autentificarse en un determinado sector de ésta y así se accede a los bloques de información almacenados. El tipo de acceso será dependiendo de la clave de seguridad ingresada y los valores de acceso definidos en el Sector Trailer. El comando enviado es “l< número de Sector (del 0 al 15) >”


10

(“l01” para el caso de la credencial universitaria), ante lo cual se puede obtener distintas respuestas del procedimiento de autentificación:

“L” Autentificación exitosa “F” Fallo en el procedimiento de autentificación. “E” Error en la clave de acceso o clave no valida. “N” Si se quitó la tarjeta del perímetro de alcance o no seleccionó ninguna

tarjeta.

Si la autentificación fue exitosa se podrá enviar el comando para poder leer el Rut del usuario el cual se encuentra almacenado en el bloque 4 del sector 1 mediante el comando “r04”, obteniéndose como respuesta en caso de un éxito el Rut del usuario. Una vez obtenidos los datos se procede a establecer una comunicación con el servidor “alumnos.elo.utfsm.cl” al puerto 80 (Web) mediante el stack TCP/IP utilizado, luego se crea un string con los datos obtenidos creando el siguiente comando “GET /~dcaro/datos.php?rut=123456789&numero=12345678” el cual es enviado al servidor para que este lo procese y responda la solicitud, si la respuesta del servidor es un “OK” se activan los relés produciéndose un éxito, en caso de obtener una respuesta “FAILED” no se activan los relés produciéndose un fallo. El esquema del procedimiento anterior puede ser apreciado en la siguiente figura:


11

Implementación propiamente tal: Descripción del programa principal main

While(1)

flag_card =1

=0

Tarjeta inválida, modo continuo lectura tarjeta

Envio de datos y regresa al estado inicial

Pregunta por si hay algo que enviar usando uIP

Inicialización Osc, Display, RS232

Inicializacion variables, flags=0

Inicio del stack uIP


12

Descripción de la rutinas de interrupciones Dependiendo de que flag esta habilitado hará distintas acciones, según el carácter recibido que es almacenado en la variable “RxB”.

A continuación se adjunta el código de los archivos main.c, deflector.c y app.c.

Flag0 Espera que lelgue en orden un “CR” y “LF” habilitando flag1

Flag1 Recupera el cod. Serial tarjeta Habilita flag2

Flag2 Envia un “CR” y luego un “s” Habilita flag3

Flag3 Envia un “L01” y espera un “l” para habilitar flag4 De lo contrario rechaza logueo

Flag4 Envia un “r04” para leer el sector, habilita flag5

Flag5 Almacena el RUT habilita el flag_card (pertenece al main)


13

Códigos utilizados en el desarrollo

Main.c // Versión Final Proyecto Driver lector de tarjetas// Comunicación bi-direccional RS232 y TCP/IP

/*..\..\UIP\..\UIP\..\APPS\NEWAPP\..\CRYSTAL\..\NEWAPP\..\..\NEWAPP\*/

#include <stdlib.h> /* For system(). */#include <stdio.h> /* For printf(). */#include <msp430x14x.h>#include <string.h>#include "defslector.c"

#undef HTONS

#include "uip.h"#include "uip_arp.h"

#include "cs8900a.h"

#define BUF ((struct uip_eth_hdr *)&uip_buf[0])

#ifndef NULL#define NULL (void *)0#endif /* NULL */

static unsigned short start, current;

#define server_IPADDR0 200U // The first octet of the server IP address.#define server_IPADDR1 1U //The second octet of the server IP address.#define server_IPADDR2 17U //The third octet of the server IP address.#define server_IPADDR3 197U //The fourth octet of the IP address.

const u16_t server[2] ={ HTONS((server_IPADDR0 << 8) | server_IPADDR1),

HTONS((server_IPADDR2 << 8) | server_IPADDR3)};

void app_done(unsigned char error){

if (error == APP_ERR_OK)//mensaje aceptado{

flag_card=0;tone2(100,10,200,200);tone2(100,10,200,200);tone2(100,10,200,200);tone2(100,10,200,200);Put_Ins(Clear_Display);Delayx100us(retclear);printf("Datos enviados ");


14

tone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);Put_Ins(Clear_Display);Delayx100us(retclear);RELAY1_OFF;RELAY2_OFF;printf("Ingrese Tarjeta\n");printf(" USM \n");

}else//datos no aceptados.

{flag_card=0;}}

#define RT_CLOCK_SECOND 3

/*--------------------------------------------------------------------------*/static unsigned shortrt_ticks(void){

extern unsigned short ticks;return ticks;

}/*--------------------------------------------------------------------------*/int main(void){

u8_t i, arptimer;

InitOsc2();InitPorts();Init_Display();RS232Init ();

strcpy(get,"GET /~dcaro/datos.php?rut=");

strcpy(get2,"&numero=");

get3= '\n';separacion [1] = 'A';

flag0 = 1; flag1 = 0;flag2 = 0; flag23 = 0;flag3 = 0; flag4 = 0;flag5 = 0; flag_card = 0;F = 1;

STATUS_LED_OFF;

Put_Ins(Clear_Display);Delayx100us(retclear);

Put_Ins(Cursor_Off);Delay(retins);printf("Ingrese Tarjeta\n");printf(" USM \n");

/* Initialize the uIP TCP/IP stack. */uip_init();


15

uip_arp_init();

/* Initialize the device driver. */cs8900a_init();

/* Configure the SMTP module with an SMTP server and the hostname of thehost.*/

app_configure( (u16_t *)server);

start = rt_ticks();arptimer = 0;

while(1) {/* Let the tapdev network device driver read an entire IP packet

into the uip_buf. If it returns > 0, there is a packet in theuip_buf buffer. */

uip_len = cs8900a_poll();

if(uip_len > 0) {/* A packet is present in the packet buffer. We call the appropriate ARP

functions depending on what kind of packet we have received. If the packet is anIP packet, we should call uip_input() as well. */

if(BUF->type == htons(UIP_ETHTYPE_IP)) {uip_arp_ipin();uip_input();

/* If the above function invocation resulted in data that should be sent outon the network, the global variable uip_len is set to a value > 0. */

if(uip_len > 0) {uip_arp_out();cs8900a_send();}

}else if(BUF->type == htons(UIP_ETHTYPE_ARP)) {

uip_arp_arpin();/* If the above function invocation resulted in data that should be sent out

on the network, the global variable uip_len is set to a value > 0. */if(uip_len > 0) {

cs8900a_send();}

}}else {

/* The poll function returned 0, so no packet was received. Instead wecheck if there is time that we do the periodic processing. */

current = rt_ticks();

if((u16_t)(current - start) >= (u16_t)RT_CLOCK_SECOND / 2) {start = current;for(i = 0; i < UIP_CONNS; i++) {

uip_periodic(i);/* If the above function invocation resulted in data that should be sent

out on the network, the global variable uip_len is set to a value > 0. */if(uip_len > 0) {

uip_arp_out();cs8900a_send();

}}

#if UIP_UDPfor(i = 0; i < UIP_UDP_CONNS; i++) {

uip_udp_periodic(i);


16

/* If the above function invocation resulted in data that should be sentout on the network, the global variable uip_len is set to a value > 0. */

if(uip_len > 0) {uip_arp_out();cs8900a_send();

}}

#endif /* UIP_UDP */

/* Call the ARP timer function every 10 seconds. */if(++arptimer == 20) {

uip_arp_timer();arptimer = 0;

}}

}

if (flag_card) {flag_card = 0; jj = 0; iii = 0;if (F){ // tarjeta válidaif (app_send(get, 52)==0)

{//No se puede establecer conexion con el servidor

}else

{//Preparó el mensajetone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);Put_Ins(Clear_Display);Delayx100us(retclear);printf("Conectando.");tone(1000,10,200,200);tone(1000,10,200,200);printf(".");tone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);printf(".");tone(1000,10,200,200);printf(".");tone(1000,10,200,200);tone(1000,10,200,200);}

}else { // tarjeta no válida

F = 1;

tone2(1000,10,200,200);tone2(1000,10,200,200);tone2(1000,10,200,200);printf("Ingrese Tarjeta \n");printf(" USM \n");

}tone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);

flag0 = 1;


17

tone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);RS232TXChar('c');

IE1 |= URXIE0;}

}

}

#pragma vector = UART0RX_VECTOR__interrupt void RXInterrupt (void){

_EINT();RXBuffer[RXWriteIndex++] = U0RXBUF; // store received byte and// inc receive indexRXWriteIndex &= RXBUFSIZE-1; // reset indexRXCharCount++; // received, inc countRxB = cRS232GetChar(); // Rx del byte

if (flag0) {RELAY2_OFF;switch (RxB) {

case CR : sem = 1;break;

case LF : if (sem) {flag1 = 1;flag0 = 0;sem = 0;

}break;

default : sem = 0;break;

}}if (flag1) {switch (RxB){default:

if(ii<8){switch (RxB){case CR: break;case LF: break;default:

stringrx [ii] = RxB; // stringrx recepcion de nªde tarjetaii++;break;}

}else{switch(RxB) {default: break;


18

case LF: flag1 = 0; //desactiva rutina de captura de Nª de tarjetaii = 0;//printf("%s \n", stringrx); // código adquirido//printf(" **** \n");printf("Mantenga Tarjeta \n");flag2 = 1;break;

}}break;

}}

if (flag2) {switch (RxB) {case LF : RS232TXChar(CR);

break;

case '?': flag23 = 1;flag2 = 0;break;

default : break;}}

if (flag23) {switch (RxB) {case LF : RS232TXChar('s');

flag23 = 0;flag3 = 1;break;

default : break;}

}

if (flag3) {switch (RxB) {case LF : RS232TXChar('l');

tone(500,10,200,100);RS232TXChar('0');

tone(500,10,200,100);RS232TXChar('1');

tone(500,10,200,100);RS232TXChar(CR);

break;

case 'L': STATUS_LED_ON;

flag3 = 0;flag4 = 1;break;

case 'F': //Put_Ins(Clear_Display);//Delayx100us(retclear);printf("Tarjeta Invalida \n");//Put_Data('\n');

//01234567890123456


19

flag_card = 1;flag3 = 0;F = 0;break;

default : break;}}

if (flag4) { // capturar el rutswitch (RxB){

default: break;case LF: RS232TXChar('r');

Delay(33000);RS232TXChar('0');Delay(33000);RS232TXChar('4');RELAY1_ON;flag4 = 0;flag5 = 1;break;

}}

if (flag5) {

if(jj<11) {

if (jj > 1){rutRx [iii] = RxB; // stringrx recepcion de nªde tarjetajj++;iii++;}else jj++;

}else{ switch(RxB) {

default: break;case LF: IE1 &= ~URXIE0;

flag5 = 0;RELAY2_ON;printf(" **OK** \n");flag_card = 1;break;

}}

}}

//static interrupt [0x0C] void TXInterrupt (void)#pragma vector = UART0TX_VECTOR__interrupt void TXInterrupt (void)

{_EINT();if (TXCharCount){ // send if chars are in buffer

U0TXBUF = TXBuffer[TXReadIndex++]; // load tx register, inc indexTXReadIndex &= TXBUFSIZE-1; // adjust indexTXCharCount--; // char sent, dec count

}else // buffer empty, nothing to do


20

TXBufferEmpty = BUFFER_EMPTY; // set empty flag}

deflector.c #include "defslector.h"

void InitOsc2(void){

WDTCTL = WDTPW | WDTHOLD; // stop watchdog timer

BCSCTL1 |= XTS; // XT1 as high-frequency_BIC_SR(OSCOFF); // turn on XT1 oscillator

do // wait in loop until crystalis stable

IFG1 &= ~OFIFG;while (IFG1 & OFIFG);

BCSCTL1 |= DIVA0; // ACLK = XT1 / 2BCSCTL1 &= ~DIVA1;

IE1 &= ~WDTIE; // disable WDT int.IFG1 &= ~WDTIFG; // clear WDT int. flag

WDTCTL = WDTPW | WDTTMSEL | WDTCNTCL | WDTSSEL | WDTIS1; // use WDT as timer,flag each

// 512 pulses fromACLK

while (!(IFG1 & WDTIFG)); // count 1024 pulses from XT1(until XT1's

// amplitude is OK)WDTCTL = WDTPW | WDTHOLD;

IFG1 &= ~OFIFG; // clear osc. fault int. flagBCSCTL2 |= SELM0 | SELM1; // set XT1 as MCLK

}

void InitPorts(void){

P1SEL = 0;P1OUT = 0; //P1DIR = BIT5 | BIT6; //enable only Relay outputs

P2SEL = 0;P2OUT = 0;//P2OUT |= BIT1;P2DIR = ~BIT0; //only P2.0 is input

P3SEL |= BIT4 | BIT5; //enable UART0P3DIR |= BIT4; //enable TXD0 as outputP3DIR &= ~BIT5; //enable RXD0 as input

P4SEL = 0;P4OUT = 0;P4DIR = BIT2 | BIT3; //only buzzer pins are outputs

P6SEL = 0x80;


21

P6OUT = 0;P6DIR = 0x00; // all output

P4SEL |= BIT4 | BIT5;TBCCTL4 |= CM1 | CCIE | CAP;

// P4SEL |= BIT5;TBCCTL5 |= CM1 | CCIE | CAP;

}

void Delay (unsigned int retardo){ unsigned int kk;

for (kk=0 ; kk < retardo; kk++); //9+a*12 cycles}

void Delayx100us(unsigned int retardo){ unsigned int kk;

for (kk=0; kk < retardo; kk++) Delay (_100us);}

void InitUART0 (void) //UART0 init{

BCSCTL1 &= ~DIVA0; // ACLK = XT1 / 4 = MCLK / 4BCSCTL1 |= DIVA1;UCTL0 = CHAR; //Sart bit, 8 data bits, no

parity, 1 stopUTCTL0 = SSEL0; //ACLK is UART clockU0BR0 = 0xd0; //2000000:9600=208U0BR1 = 0x00;UMCTL0 = 0x00; //no modulationME1 |= UTXE0 | URXE0; //enable UART modulP3SEL |= 0x30; // P3.4,5 = USART0 TXD/RXDP3DIR |= BIT4; //enable TXD0 as outputP3DIR &= ~BIT5; //enable RXD0 as inputIE1 |= URXIE0; // Enable USART0 RX interruptIE1 |= UTXIE0; // Enable USART0 TX interrupt_EINT(); //enable interrupt

}

void Put_Val(unsigned char val){ //Interfaz de comunicación en modo 4 bits.

E_ON; P2OUT = (P2OUT & 0x0F)|( val & 0xF0); //sale nibble superiorDelay(1); // ancho del pulso E 400nsE_OFF; Delay(1); // tiempo de ciclo de E max 1400 nsE_ON; P2OUT = (P2OUT & 0x0F)|((val<<4)& 0xF0); //sale nibble inferiorDelay(1);E_OFF; Delay(1);RS_OFF;

}

void Put_Ins(unsigned char Ins) {RS_OFF; Delay(1);Put_Val(Ins);Delay(retins);

}

void Put_Data(unsigned char Ch) {RS_ON;Delay(1);Put_Val( Ch);


22

Delay(retdata);}

void Put_Str(char *Str) {unsigned int i,j;j=strlen(Str);for (i = 0; i < j; i++)Put_Char(*(Str+i));

}

void Init_Display(void) {Delayx100us(700); //esperar 70 ms. Queda en modo 8 bits.E_ON; P2OUT = Set_Function+Data_Length_4+Enable_High;Delay(1); E_OFF;Delay(24);//esperar cambio a modo 4 bitsPut_Ins(Set_Function + Data_Length_4 + Two_Display_Lines + Font_5x7);//no

basta unaPut_Ins(Set_Function + Data_Length_4 + Two_Display_Lines + Font_5x7);//la

segunda es aceptadaPut_Ins(Set_Display + Display_On + Cursor_On + Blink_Off);Put_Ins(Clear_Display);Delayx100us(retclear); //esperar 1,6 ms no

funciona. son 3msPut_Ins(Set_Entry_Mode + Increment_Address + Shift_Display_Off);

}

static int linea =1;

int putchar(int c){

if (c == '\n'){if (linea==1)

{Put_Ins(Set_DDRAM_Address + Line2_Offset);//segunda línealinea=2;}

else{Put_Ins(Set_DDRAM_Address + 0); //primera línealinea=1;}

}else Put_Data( (unsigned char) c );return c;

}

//generador de ringtones

int tone(int tiempo, int ts, int frec, int silencio){int t;for (t = 0; t <tiempo;t++) //tiempo*2frec=duración

{//BUZ1_OFF;//BUZ2_ON;Delay(frec);//BUZ2_OFF;//BUZ1_ON;Delay(frec);

}for (t = 0; t <ts;t++)

{//BUZ2_OFF; //creacion de silencios//BUZ1_OFF; //ej. silencio=temponDelay(silencio); //silencio de negra

}return (0);


23

}

int tone2(int tiempo, int ts, int frec, int silencio){int t;for (t = 0; t <tiempo;t++) //tiempo*2frec=duración

{BUZ1_OFF;BUZ2_ON;Delay(frec);BUZ2_OFF;BUZ1_ON;Delay(frec);

}for (t = 0; t <ts;t++)

{BUZ2_OFF; //creacion de silenciosBUZ1_OFF; //ej. silencio=temponDelay(silencio); //silencio de negra

}return (0);}

/*void InitCaptura (void){

P4SEL |= BIT4;TBCCTL4 |= CM1 | CCIE | CAP;_EINT();

}*//*#define TONE_0() for (x=0; x<1; x++){tone(1000,10,200,200);

tone(1500,10,150,200);tone(1000,10,200,200);tone(1500,10,150,200);tone(1000,10,200,200);tone(1500,10,150,200);tone(1000,10,200,200);tone(1500,10,150,200);tone(1500,10,200,200);}*/

void RS232Init (void){

RXWriteIndex = RXReadIndex = RXCharCount = 0;TXWriteIndex = TXReadIndex = TXCharCount = 0;TXBufferEmpty = BUFFER_EMPTY; // reset empty flag/*UART_INIT; // setup interface:

// refer to "MSP430 Family User's Guide// - choose baudrate// - select mode (stop bits, parity ...)// - enable interrupts */

InitUART0();}

void RS232TXChar (char cByte){

TXBuffer[TXWriteIndex++] = cByte; // load byte to buffer and inc indexTXWriteIndex &= TXBUFSIZE-1; // adjust index to borders of bufferTX_INT_DISABLE; // disable transmit interrupt (in IE1)TXCharCount++; // new char, inc countTX_INT_ENABLE; // enable interrupt (in IE1)


24

if (TXBufferEmpty && TXCharCount) // buffer had been empty{

TXBufferEmpty = !BUFFER_EMPTY; // reset empty flagU0TXBUF = TXBuffer[TXReadIndex++]; // load tx register, inc index//Put_Data(cByte);TXReadIndex &= TXBUFSIZE-1; // adjust indexTXCharCount--; // char sent, dec count

}}

unsigned char RS232RXBufferCount (void){

return (RXCharCount);}

char cRS232GetChar (void){

char Byte;if (RXCharCount){ // char still available

Byte = RXBuffer[RXReadIndex++]; // get byte from bufferRXReadIndex &= RXBUFSIZE-1; // adjust indexRX_INT_DISABLE; // disable rx interrupt (IE2)RXCharCount--; // one char read, dec countRX_INT_ENABLE; // done, enable int (IE2)return (Byte);

}elsereturn (0); // if there is no new char

}


25

app.c #include "uip.h"#include "app.h"

//#include "smtp-strings.h"//#include "smtp-strings.c" //lsb#include <string.h>

#define STATE_SEND_MSG 0#define STATE_APP_SENDED 1

#define retclear 15 // 1,53 ms 1530 us#define Clear_Display 0x01 // 0 0 0 0 0 0 0 1

static u16_t appserver[2];

static voidsenddata(struct app_state *s){

char *textptr;

if(s->textlen != 0 &&s->textlen == s->sendptr) {return;

}

textptr = (char *)uip_appdata;switch(s->state) {case STATE_SEND_MSG:

textptr = s->msg;if(s->sendptr == 0) {s->textlen = s->msglen;

}

break;

default:return;

}

textptr += s->sendptr;

if(s->textlen - s->sendptr > uip_mss()) {s->sentlen = uip_mss();

} else {s->sentlen = s->textlen - s->sendptr;

}

/* textptr[s->sentlen] = 0;printf("Sending '%s'\n", textptr);*/

uip_send((u8_t *)textptr, s->sentlen); //lsb}

static voidacked(struct app_state *s){

s->sendptr += s->sentlen;


26

s->sentlen = 0;

if(s->sendptr == s->textlen) {s->state = STATE_APP_SENDED;}

}

static voidnewdata(struct app_state *s) // recepción de datos{

s->state = STATE_APP_SENDED; //????switch(s->state) {case STATE_APP_SENDED:

if(*(char *)uip_appdata == 'O') {app_done(APP_ERR_OK);uip_close();

}else{

//Put_Ins(Clear_Display);//Delayx100us(retclear);printf("Fallo conexion \n");printf("Intente de nuevo \n");app_done(1);uip_close();

}

break;

}

}voidapp_appcall(void){

struct app_state *s;

s = (struct app_state *)uip_conn->appstate;

if(uip_connected()) {/* senddata();*/return;

}if(uip_acked()) {

acked(s);}if(uip_newdata()) {

newdata(s);}if(uip_rexmit() ||

uip_newdata() ||uip_acked()) {senddata(s);

} else if(uip_poll()) {senddata(s);

}/* if(uip_closed()) {

printf("Done\n");}*/


27

}

unsigned charapp_send(char *msg, u16_t msglen) // envío de datos{

struct uip_conn *conn;struct app_state *s;

conn = uip_connect(appserver, HTONS(80));if(conn == NULL) {

Put_Ins(Clear_Display);Delayx100us(retclear);printf("Fallo2 conexion \n");printf("Intente de nuevo \n");tone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);tone(1000,10,200,200);Put_Ins(Clear_Display);Delayx100us(retclear);printf("Ingrese Tarjeta\n");printf(" USM \n");return 0;

}s = (struct app_state *)conn->appstate; //lsb

s->state = STATE_SEND_MSG;s->sentlen = s->sendptr = s->textlen = 0;s->msg = msg;s->msglen = msglen;

return 1;}

/*-----------------------------------------------------------------------------------*/

voidapp_configure( u16_t *server){

appserver[0] = server[0];appserver[1] = server[1];

}

app.h #ifndef __APP_H__#define __APP_H__

#include "uipopt.h"

/*** Error number that signifies a non-error condition.*/

#define APP_ERR_OK 0

void app_done(unsigned char error);

/* Functions. */void app_configure( u16_t *smtpserver);

unsigned char app_send( char *msg, u16_t msglen);


28

void app_appcall(void);

struct app_state {u8_t state;char *msg;u16_t msglen;u16_t sentlen, textlen;u16_t sendptr;

};

#ifndef UIP_APPCALL#define UIP_APPCALL app_appcall // para llamado de uIP#endif

#ifndef UIP_APPSTATE_SIZE#define UIP_APPSTATE_SIZE (sizeof(struct app_state))#endif

#endif /* __APP_H__ */

Documents

Universidad Técnica Federico Santa María Departamento de ...lsb/elo325/clases/proyectos/ControlAccesoViaWeb... · Universidad Técnica Federico Santa María Departamento de Electrónica