Cerradura con Tarjetas Telefonicas
El principal objetivo de realizar este proyecto es, primeramente, crear un dispositivo capaz de realizar la lectura y almacenamiento de algunos bytes importantes (número de serie) para después compararlos al volver a introducirla y así poder utilizarla como una cerradura electrónica. También se podría utilizar para activar algunos dispositivos eléctricos o electrónicos, que requieran seguridad para su activación.
DESARROLLO
Las tarjetas telefónicas tienen en su interior, un microprocesador en el cual con sólo 128 bits, el teléfono es capaz de identificar información como ser: país fabricante de la tarjeta y saldo de la tarjeta.
Para poder leer la tarjeta, el teléfono necesita sincronizar señales eléctricas del tipo digital en cada una de los contactos de la tarjeta.
Por ejemplo, para poder descontar saldo se hace una rutina diferente que la rutina para realizar la lectura de cada uno de los bits, hay otra rutina que se encarga de resetear la tarjeta y así diversas rutinas encargadas de hacer verificaciones, validaciones y otras cuestiones de seguridad.
Las tarjetas actualmente utilizadas en México, son las llamadas ”tarjetas de segunda generación”, ya que las de la primera generación contaban con 256 bits.
Primero realicé un programa en c++, que se encarga de leer el número de serie de las tarjetas telefónicas de 128 bits. Este programa trabaja en msdos y se conecta en el puerto paralelo de la PC y se encarga de leer solamente la parte correspondiente del número de serie.
El programa lo puede bajar de nuestra web en http://www.webelectronica- .com.ar con la clave “cerradura”. El diagrama de conexiones para el puerto paralelo es el de la figura 1 y es necesario utilizar una fuente externa de alimentación para obtener mejores resultados.
El programa es muy sencillo y sólo basta con correrlo después de conectar el lector de la tarjeta, teclear la letra correspondiente y luego dar Enter para leer el número de serie en hexadecimal, que es el mismo que se va a poner en el programa de ensamblador. El aspecto del programa lector lo vemos en la figura 2.
Después de leer la tarjeta se obtiene el código en hexadecimal, tal como se observa en la figura 3.
En la figura 4 se ve el mapa de bits y su correspondencia a cada función, por eso puse con negritas la parte que más interesa de la tarjeta, la razón de escoger esta parte, es por que esta sección nunca se modifica y la sección del descuente se va decrementando.
Cada vez que se hace una llamada, estos bits van a servir para programarlos en el PIC y así poder hacer la validación de la tarjeta.
Es por eso, que más adelante se va a explicar cómo se ignoran los 24 bits del comienzo para sólo leer los 4 bytes del número de serie.
Después de eso investigué acerca de las rutinas de lectura de una de estas tarjetas, en una página de hackers en la cual se hablaba de los emuladores.
En la figura 5 se ve una de las rutinas que hace la caseta para poder leer los bits de la tarjeta. En el PIC, va a ser necesario dos salidas, una para el control de la tarjeta y otra para leer el contacto de I/O.
Primero se debe realizar el reset poniendo a uno RST, luego subiendo a CLK. Finalmente se baja primero el CLK y por último el RST.
Con esto, el PIC deberá estar leyendo el primer BIT del mapa de la tarjeta; para leer los restantes, sólo basta con generar pulsos de reloj en el contacto CLK y por cada uno se obtendrá un BIT.
En la figura 6 vemos el gráfico del programa ICPROG. Para leer y grabar pics se verifica que los datos de la tarjeta “opcional” se guardaron en la EEPROM, después de poner el código correcto del dip switch.
FUNCIONAMIENTO DEL CIRCUITO
El circuito sólo se presenta con la ranura para poder insertar la tarjeta, el circuito está programado con 5 mapas de tarjetas telefónicas con las cuales se puede accionar la cerradura. Cuenta también con un dip switch que se coloca en el interior del lugar donde se va instalar la cerradura, y sirve para dar de alta una sexta tarjeta.
Para dar de alta la sexta tarjeta sólo se tiene que poner el código binario en los switchs luego se inserta la tarjeta, cuando prenda el led de “retirar tarjeta”, los bits quedan almacenados en la memoria EEPROM del PIC, por lo tanto no son volátiles.
El circuito tiene 3 leds. El verde (meter) indica que se debe insertar una tarjeta, el rojo (sacar) que se debe retirar y el amarillo (abierto) indica que se logró accionar la cerradura.
En la salida RB5 se puede adaptar el cerrojo eléctrico por medio de un transistor, optoacoplador o un relevador.
En la figura 7 vemos el diagrama de la cerradura y en la figura 8 se visualizan los datos de la tarjeta a través del programa.
Cerradura
Lector alterno
Con este circuito podés leer las tarjetas PROM y modificarle algunos bits también.
Si solo pensás leerlas, no hace falta que armes el circuito de borrado que está abajo a la derecha (el que usa 21V).
Los cables de color rojo son los que salen de la plaqueta para conectarse a la tarjeta.
Los números 2,3,4,4,10,12,13,15,18... 25 son los pines del puerto paralelo de la PC a los que tenés que conectar (el pin numero 11 no figura en el gráfico, pero hay que conectarlo al positivo de 5v). Lo mas importante de el es la parte que se refiere al control. donde se maneja la terminal de clk y rst, la otra parte es la de de la lectura.
Fragmento del Reset:
Código: Seleccionar todo
RESET:
case'l':
{
clrscr();
printf(" El mapa completo de la tarjeta en binario es:");
printf("\n\n ");
a=b=c=d=o=p=q=r=0;
outportb(0x378,0);
outportb(0x378,4);
delay(1);
outportb(0x378,20);
delay(1);
outportb(0x378,4);
delay(1);
outportb(0x378,0);
delay(1);
x=inportb(0x379);
x=x>>5;
m=(x&1);
se comineza la rutina de reset, la instruccion outportb(0x378,X)
donde la X se refiere a el numero posicional de cada terminal del puerto de salida bit, en este caso el contacto rst de la tarjeta esta en el 4 pin del puerto paralelo (las terminales de salida comienzan desde el pin 2 del puerto paralelo) por lo que su valor posicional binario es 4
Código: Seleccionar todo
No de pin 1 2 3 4 5 6 7 8 9
o o o o o o o o o
valor posicional 1 2 4 8 16 32 64 128
Para que el puerto comienza con todas las salidas en cero, luego la sig instruccion es: outportb(0x378,4) ; aqui se levanta reset.
luego la siguiente instruccion es outportb(0x378,20); aqui hay que revisarlo con cuidado, observen en el diagrama del lector, el contacto clk esta conectado en el pin 6 que corresponde al volor posicional 16 ( recuerden que la rutina de reset: debe de subir primero la terminal rst dejandola en alto despues,debe de subir la terminal de clk, luego debe de bajar esta ultima, y por ultimo baja rst.) como debemos de mantener rst en alto entonces se le suman 16 a los 4 que ya habia en el puerto
por eso la instrucuccion es outportb(0x378,20) y asi tenemos la terminal rst y clk en alto,
Despues se baja clk, se le restan 16 y por eso la sig instruccion es ouportb(0x378,4) asi queda de nuevo solamente la terminal rst en alto.
despues para bajar rst la sig instruccion es : outportb(0x378,0)
y el puerto queda de nuevo en ceros.
y en la terminal de I/O de la tarjeta se encuentra el primer bit de su mapa.
el cual se lee con la instruccion: inportb(0x379)
LECTURA:
la instruccion inportb(0x379) se utiliza para leer el puerto, pero se lee todo lo que haya en el puerto de entrada que hay 5 pines de lectura. sin embargo el puerto se utiliza como si tuviera 8 bits (3 de ellos son pines virtuales internos)
e pin que utilizamos es el 7mo bit de lectura.
por eso para leerlo con mayor facilidad se asina la instruccion inportb(0x379) a una variable llamda x, x=outportb(0x379) luego a esta se le hace un corrimiento con ala derecha con >> x=x>>5; luego se le hace un enmascaramiento con la operacion AND 1
y se le asigna una variable llamada m, para poder manipularla sin afectar a x, m=(x&1);
despues las demas instruciones se utilizan los IF para que se imprima un 1 o un 0 segun sea lo que se esta leyendo, solamente se sacan pusos en clk sacando 0 y 16 por el puerto.
Si quieren el Programa se los dejo: Limitación a 128Kbytes
Codigo fuente en ASM
Código: Seleccionar todo
;***********************************************************************************************
; "CERRADURA DE TARJETAS" ;
;AUTOR: ANTONIO IGNACIO ESQUIVEL MÉNDEZ ;
; ;
;email: ezkybel@hotmail.com ;
; -"dOLpHIn"- ;
;***********************************************************************************************
; REGISTROS
;-----------------------------------------------------------------------------------------------
#include<p16f84A.inc>
CUENTA EQU 0x0c
IGNORA EQU 0x0d
DATO1 EQU 0x0e
DATO2 EQU 0x0f
DATO3 EQU 0x10
DATO4 EQU 0x11
VECES EQU 0x12
CUENTA2 EQU 0x13
CUENTA3 EQU 0x14
CUENTA4 EQU 0x15
EE_1 EQU 0x16
EE_2 EQU 0x17
EE_3 EQU 0x18
EE_4 EQU 0x19
VERIFICA EQU 0x1A
;***********************************************************************************************
; CONFIGURACION DE LOS PINES DE CONTROL
;-----------------------------------------------------------------------------------------------
#define clk PORTB,0
#define rst PORTB,1
#define meter PORTB,2
#define entrada PORTB,3
#define start PORTB,4
#define sacar PORTB,5
#define cerrojo PORTB,6
;***********************************************************************************************
; MAPAS DE LAS TARJETAS
; (SOLO SE REGISTRAN LOS 4 BYTES CORRESPONDIENTES AL NUMERO DE SERIE DE CADA TARJETA)
;-----------------------------------------------------------------------------------------------
#define t1_1 0x04 ;TARJETA1: EN ESTE CASO LOS BYTES
#define t1_2 0x1D ;DEL NUMERO DE SERIE EN HEXADECIMAL
#define t1_3 0x37 ;SON:
#define t1_4 0x89 ;04 1D 37 89
;-----------------------------------------------------------------------------------------------
#define t2_1 0x2F ;TARJETA2: EN ESTE CASO LOS BYTES
#define t2_2 0xCC ;DEL NUMERO DE SERIE EN HEXADECIMAL
#define t2_3 0xE1 ;SON:
#define t2_4 0x18 ;2F CC E1 18
;-----------------------------------------------------------------------------------------------
#define t3_1 0x0C ;TARJETA3: EN ESTE CASO LOS BYTES
#define t3_2 0xB2 ;DEL NUMERO DE SERIE EN HEXADECIMAL
#define t3_3 0xB5 ;SON:
#define t3_4 0x0E ;0C B2 B5 0E
;-----------------------------------------------------------------------------------------------
#define t4_1 0x38 ;TARJETA4: EN ESTE CASO LOS BYTES
#define t4_2 0x23 ;DEL NUMERO DE SERIE EN HEXADECIMAL
#define t4_3 0x79 ;SON:
#define t4_4 0xB0 ;38 23 79 B0
;-----------------------------------------------------------------------------------------------
#define t5_1 0x38 ;TARJETA5: EN ESTE CASO LOS BYTES
#define t5_2 0x07 ;DEL NUMERO DE SERIE EN HEXADECIMAL
#define t5_3 0x30 ;SON:
#define t5_4 0x19 ;38 07 30 19
;***********************************************************************************************
; INICIO
;-----------------------------------------------------------------------------------------------
ORG 0
goto INICIO
ORG 1B
;-----------------------------------------------------------------------------------------------
INICIO bsf STATUS,RP0 ;SE CONFIGURAN LOS PUERTOS
movlw b'11111111' ;
movwf PORTA ;
movlw b'10011000' ;
movwf PORTB ;TAMBIEN EL REGISTRO OPTION_REG
movlw b'00000111' ;PARA ABILITAR LA LECTURA Y
movwf OPTION_REG ;ESCRITURA DE LA EEPROM
bcf STATUS,RP0 ;
bcf clk ;SE COMIENZA CON clk EN CERO
bcf rst ;SE COMIENZA CON rst EN CERO
bcf sacar ;SE APAGA EL LED "sacar"
bsf meter ;SE PRENDE EL LED "meter"
bcf cerrojo ;SE ASEGURA QUE EL CERROJO ESTE CERRADO
;-----------------------------------------------------------------------------------------------
COMIENZO btfss start ;ESPERA LA INTRODUCCION DE LATARJETA
goto COMIENZO ;POR LA ACTIVACION DEL PIN "start"
nop ;
bcf meter ;SI SE INTRUDUJO LA TARJETA SE APAGA EL LED "meter"
bsf rst ;RUTINA ENCARGADA DE RESETEAR LA TARJETA
bsf clk ;
nop ;
bcf clk ;
bcf rst ;
bcf STATUS,C ;SE GUARDA EL PRIMER BIT OBTENIDO DE LA TARJETA
btfsc entrada ;EN EL REGISTRO "VERIFICA" Y SE LE HACE UN CORRIMIENTO
bsf STATUS,C ;A LA IZQUIERDA PARA ESPERAR LOS OTROS 7 BITS
rlf VERIFICA ;RESTANTES DE ESTE BYTE
goto VALIDAR ;
;-----------------------------------------------------------------------------------------------
VALIDAR movlw 7 ;EN ESTA PARTE SE ASEGURA QUE SE ESTE INTRODUCIENDO
movwf VECES ;UNA TARJETA Y QUE ESTA SEA VALIDA
ALMACENA0 bsf clk ;ESTO SE HACE VERIFICANDO QUE EL VALOR
nop ;OBTENIDO DEL PRIMER BYTE DE LA TARJETA
bcf clk ;SEA DIFERENTE DE 255 (0xFF)
bcf STATUS,C ;
btfsc entrada ;
bsf STATUS,C ;PARA HACER ESTO SE ALMACENAN LOS SIGUIENTES
rlf VERIFICA ;7 BITS EN EL REGISTRO "VERIFICA" HACIENDO
decfsz VECES,F ;7 CORRIMIENTOS A LA IZQUIERDA,
goto ALMACENA0 ;LUEGO SE COMPARA CON EL VALOR 255 QUE SE
movlw 0xFF ;CARGO PREVIAMENTE EN EL REGISTRO W
subwf VERIFICA,W ;
btfss STATUS,Z ;SI EL BYTE LEIDO ES 255 SE VA A "SACATARJETA"
goto IGNORABITS ;SI ES DIFERENTE CONTINUA CON EL PROGRAMA
goto SACATARJETA ;
;-----------------------------------------------------------------------------------------------
IGNORABITS movlw .16 ;AQUI SE IGNORAN LOS SIGUIENTES 16 BITS
movwf IGNORA ;PARA COMENZAR A ALMACENAR LOS SIGUIENTES
SIGUIENTE bsf clk ;4 BYTES QUE SON LOS QUE CORRESPONDEN
nop ;AL NUMERO DE SERIE DE LA TARJETA
bcf clk ;ESTOS SON LOS QUE SE VAN A COMPARAR
decfsz IGNORA,F ;PARA SABER SI SE VA A ABRIR O NO LA CERRADURA
goto SIGUIENTE ;
goto ALMACENAR ;
;-----------------------------------------------------------------------------------------------
;
ALMACENAR movlw 8 ;
movwf VECES ;
ALMACENA1 bsf clk ;
nop ;AQUI SE ALMACENA EL PRIMER BYTE DE LA TARJETA
bcf clk ;LEIDA EN UN REGISTRO LLAMADO
bcf STATUS,C ;"DATO1"
btfsc entrada ;
bsf STATUS,C ;
rlf DATO1 ;
decfsz VECES,F ;
goto ALMACENA1 ;
;-----------------------------------------------------------------------------------------------
movlw 8 ;
movwf VECES ;
ALMACENA2 bsf clk ;
nop ;
bcf clk ;AQUI SE ALMACENA EL SEGUNDO BYTE DE LA TARJETA
bcf STATUS,C ;LEIDA.EN UN REGISTRO LLAMADO
btfsc entrada ;"DATO2"
bsf STATUS,C ;
rlf DATO2 ;
decfsz VECES,F ;
goto ALMACENA2 ;
;-----------------------------------------------------------------------------------------------
movlw 8 ;
movwf VECES ;
ALMACENA3 bsf clk ;
nop ;
bcf clk ;AQUI SE ALMACENA EL TERCER BYTE DE LA TARJETA
bcf STATUS,C ;LEIDA.EN UN REGISTRO LLAMADO
btfsc entrada ;"DATO3"
bsf STATUS,C ;
rlf DATO3 ;
decfsz VECES,F ;
goto ALMACENA3 ;
;-----------------------------------------------------------------------------------------------
movlw 8 ;
movwf VECES ;
ALMACENA4 bsf clk ;
nop ;
bcf clk ;AQUI SE ALMACENA EL CUARTO BYTE DE LA TARJETA
bcf STATUS,C ;LEIDA EN UN REGISTRO LLAMADO
btfsc entrada ;"DATO4"
bsf STATUS,C ;
rlf DATO4 ;
decfsz VECES,F ;
goto ALMACENA4 ;
goto OPCION ;SE SIGUE CON EL PROGRAMA
;-----------------------------------------------------------------------------------------------
OPCION bcf STATUS,Z ;EN ESTA PARTE SE PREGUNTA POR EL
movf PORTA,W ;ESTADO DE PORTA, SI ES IGUAL AL
andlw b'00011111' ;CODIGO BINARIO QUE HABILITA LA ESCRITURA
xorlw b'00001110' ;DE LA EEPROM PARA INGRESAR UNA 6ta TARJETA Y
btfss STATUS,Z ;SALTA A LA RUTINA "ESCRITURA1". Y SI NO ENTONCES VA
goto LEEEEPROM ;A LA RUTINA "LEEEEPROM"
goto ESCRITURA1 ;EN ESTE CASO EL CODIGO DE ACCESO ES "01110"
;(SE PUEDE CAMBIAR ESTE CODIGO)
;-----------------------------------------------------------------------------------------------
LEEEEPROM movlw 0 ;
movwf EEADR ;
bsf STATUS,RP0 ;
bsf EECON1,RD ;EN ESTA PARTE SE LEEN LOS DATOS ALMACENADOS
bcf STATUS,RP0 ;EN LA EEPROM, POR SI PREVIAMENTE SE HABIA
movf EEDATA,W ;REGISTRADO EL CODIGO DE LA 6ta TARJETA
movwf EE_1 ;PARA TAMBIEN COMPARARLOS EN LAS RUTINAS "COMPARA"
movlw 1 ;
movwf EEADR ;
bsf STATUS,RP0 ;
bsf EECON1,RD ;LOS DATOS LEIDOS SE ALMACENAN EN LOS REGISTROS
bcf STATUS,RP0 ;"EE_1 EE_2 EE_3 EE_4"
movf EEDATA,W ;
movwf EE_2 ;
movlw 2 ;
movwf EEADR ;
bsf STATUS,RP0 ;
bsf EECON1,RD ;
bcf STATUS,RP0 ;
movf EEDATA,W ;
movwf EE_3 ;
movlw 3 ;
movwf EEADR ;
bsf STATUS,RP0 ;
bsf EECON1,RD ;
bcf STATUS,RP0 ;
movf EEDATA,W ;
movwf EE_4 ;
goto COMPARA1 ;VA A LA SIGUIENTE RUTINA
;-----------------------------------------------------------------------------------------------
COMPARA1 movf DATO1,W ;
bcf STATUS,Z ;EN LAS 4 RUTINAS SIGUIENTES:
sublw t1_1 ;COMPARA1,COMPARA2,COMPARA3 Y COMPARA4
btfsc STATUS,Z ;SE HACE LA COMPARACION DE LOS DATOS OBTENIDOS
goto COMPARA2 ;DE LA TARJETA QUE SE ESTA INTRUDICIENDO CON LOS
movf DATO1,W ;DATOS QUE ESTAN REGISTRADOS AL PRINCIPIO DEL
bcf STATUS,Z ;PROGRAMA, Y TAMBIEN LOS DATOS QUE SE PUDIERON
sublw t2_1 ;HABER ALMACENADO EN LA EEPROM.
btfsc STATUS,Z ;PRIMERO SE COMPARA DATO1 QUE ES EL DATO ACTUAL DE
goto COMPARA2 ;LA TARJETA CON CADA UNO DE LOS DATOS REGISTRADOS.
movf DATO1,W ;
bcf STATUS,Z ;
sublw t3_1 ;
btfsc STATUS,Z ;EN ELPRIMER MOMENTO EN QUE ALGUNO DE ELLOS NO COINCIDA
goto COMPARA2 ;ENTONCES SE ENVIA A LA RUTINA "SACATARJETA"
movf DATO1,W ;
bcf STATUS,Z ;
sublw t4_1 ;
btfsc STATUS,Z ;
goto COMPARA2 ;
movf DATO1,W ;
bcf STATUS,Z ;
sublw t5_1 ;
btfsc STATUS,Z ;
goto COMPARA2 ;
movf DATO1,W ;
bcf STATUS,Z ;
subwf EE_1,W ;
btfsc STATUS,Z ;
goto COMPARA2 ;
goto SACATARJETA ;
;-----------------------------------------------------------------------------------------------
COMPARA2 movf DATO2,W
bcf STATUS,Z
sublw t1_2
btfsc STATUS,Z
goto COMPARA3
movf DATO2,W
bcf STATUS,Z
sublw t2_2
btfsc STATUS,Z
goto COMPARA3
movf DATO2,W
bcf STATUS,Z
sublw t3_2
btfsc STATUS,Z
goto COMPARA3
movf DATO2,W
bcf STATUS,Z
sublw t4_2
btfsc STATUS,Z
goto COMPARA3
movf DATO2,W
bcf STATUS,Z
sublw t5_2
btfsc STATUS,Z
goto COMPARA3
movf DATO2,W
bcf STATUS,Z
subwf EE_2,W
btfsc STATUS,Z
goto COMPARA3
goto SACATARJETA
;-----------------------------------------------------------------------------------------------
COMPARA3 movf DATO3,W
bcf STATUS,Z
sublw t1_3
btfsc STATUS,Z
goto COMPARA4
movf DATO3,W
bcf STATUS,Z
sublw t2_3
btfsc STATUS,Z
goto COMPARA4
movf DATO3,W
bcf STATUS,Z
sublw t3_3
btfsc STATUS,Z
goto COMPARA4
movf DATO3,W
bcf STATUS,Z
sublw t4_3
btfsc STATUS,Z
goto COMPARA4
movf DATO3,W
bcf STATUS,Z
sublw t5_3
btfsc STATUS,Z
goto COMPARA4
movf DATO3,W
bcf STATUS,Z
subwf EE_3,W
btfsc STATUS,Z
goto COMPARA4
goto SACATARJETA
;-----------------------------------------------------------------------------------------------
COMPARA4 movf DATO4,W
bcf STATUS,Z
sublw t1_4
btfsc STATUS,Z
goto ABRIR
movf DATO4,W
bcf STATUS,Z
sublw t2_4
btfsc STATUS,Z
goto ABRIR
movf DATO4,W
bcf STATUS,Z
sublw t3_4
btfsc STATUS,Z
goto ABRIR
movf DATO4,W
bcf STATUS,Z
sublw t4_4
btfsc STATUS,Z
goto ABRIR;
movf DATO4,W
bcf STATUS,Z
sublw t5_4
btfsc STATUS,Z
goto ABRIR
movf DATO4,W
bcf STATUS,Z
subwf EE_4,W
btfsc STATUS,Z
goto ABRIR
goto SACATARJETA
;***********************************************************************************************
; ESCRITURA DE LA EEPROM
;-----------------------------------------------------------------------------------------------
ESCRITURA1 bcf STATUS,RP0 ;
movlw 0 ;
movwf EEADR ;
movf DATO1,W ;
movwf EEDATA ;LAS SIGUIENTES 4 RUTINAS SE ENCARGAN DE
bsf STATUS,RP0 ;ESCRIBIR EN LA EEPROM LOS DATOS DE LA "6ta"
bsf EECON1,WREN ;TARJETA, ESTO SE HACE SOLO EN EL CASO QUE
movlw 0x55 ;EL CODIGO BINARIO DE LOS DIPSWITCH SEA EL
movwf EECON2 ;CORRECTO.
movlw 0xAA ;LOS DATOS SE ALMACENAN EN LAS DIRECCIONES
movwf EECON2 ;0,1,2 Y 3 DE LA EEPROM
bsf EECON1,WR ;
bcf STATUS,RP0 ;
call RETARDO_WR ;
goto ESCRITURA2 ;
;-----------------------------------------------------------------------------------------------
ESCRITURA2 bcf STATUS,RP0
movlw 1
movwf EEADR
movf DATO2,W
movwf EEDATA
bsf STATUS,RP0
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf STATUS,RP0
call RETARDO_WR
goto ESCRITURA3
;-----------------------------------------------------------------------------------------------
ESCRITURA3 bcf STATUS,RP0
movlw 2
movwf EEADR
movf DATO3,W
movwf EEDATA
bsf STATUS,RP0
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf STATUS,RP0
call RETARDO_WR
goto ESCRITURA4
;-----------------------------------------------------------------------------------------------
ESCRITURA4 bcf STATUS,RP0
movlw 3
movwf EEADR
movf DATO4,W
movwf EEDATA
bsf STATUS,RP0
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf STATUS,RP0
call RETARDO_WR
goto SACATARJETA
;-----------------------------------------------------------------------------------------------
SACATARJETA call PARPADEA ;RUTINA QUE SE ENCARGA DE REINICIAR EL
btfsc start ;PROGRAMA Y MANDAR LLAMAR LA RUTINA "PARPADEA"
goto SACATARJETA ;EL CUAL HACE DESTELLAR EL LED "sacar" INDICANDO
bsf meter ;QUE SE RETIRE LA TARJETA,
goto INICIO ;EN CASO DE QUE SEA INVALIDA O SE HAYA TERMINADO
;DE LEER O ESCRIBIR
;-----------------------------------------------------------------------------------------------
PARPADEA bsf sacar ;
call RETARDOLED ;SE ENCARGA DE HACER DESTELLAR EL LED
bcf sacar ;"sacar"
call RETARDOLED ;
return ;
;-----------------------------------------------------------------------------------------------
ABRIR bsf cerrojo ;
call ABIERTO ;ACTIVA LA APERTURA DE LA CERRADURA
bcf cerrojo ;EN CASO DE ABERSE CUMPLIDO TODAS LAS CONDICIONES
goto SACATARJETA ;
;***********************************************************************************************
; RETARDOS
;-----------------------------------------------------------------------------------------------
ABIERTO movlw 6
movwf CUENTA4
AUNNO3 call RETARDOLED
decfsz CUENTA4,F
goto AUNNO3
return
RETARDOLED movlw .30
movwf CUENTA3
AUNNO2 call RETARDO_WR
decfsz CUENTA3,F
goto AUNNO2
return
RETARDO_WR movlw .13
movwf CUENTA2
AUNNO1 call RETARDO
decfsz CUENTA2,F
goto AUNNO1
return
RETARDO movlw 0xFF
movwf CUENTA
AUNNO decfsz CUENTA,F
goto AUNNO
return
;***********************************************************************************************
; FIN
;-----------------------------------------------------------------------------------------------
END
Código: Seleccionar todo
:020000040000FA
:020000001B28BB
:0A0036008316FF3085009830860025
:1000400007308100831206108610861206150613EB
:10005000061E28280000061186140614000006104B
:1000600086100310861903149A0D36280730920063
:100070000614000006100310861903149A0D920B43
:100080003828FF301A02031D4628572910308D00EA
:100090000614000006108D0B48284E2808309200E8
:1000A0000614000006100310861903148E0D920B1F
:1000B000502808309200061400000610031086191C
:1000C00003148F0D920B5B28083092000614000079
:1000D0000610031086190314900D920B6628083041
:1000E0009200061400000610031086190314910DE7
:1000F000920B71287B28031105081F390E3A031D46
:1001000082281B29003089008316081483120808EE
:10011000960001308900831608148312080897009E
:1001200002308900831608148312080898000330EF
:100130008900831608148312080899009F280E0866
:100140000311043C0319BE280E0803112F3C0319A8
:10015000BE280E0803110C3C0319BE280E0803111B
:10016000383C0319BE280E080311383C0319BE2879
:100170000E08031116020319BE2857290F08031190
:100180001D3C0319DD280F080311CC3C0319DD28A1
:100190000F080311B23C0319DD280F080311233C9B
:1001A0000319DD280F080311073C0319DD280F0888
:1001B000031117020319DD28572910080311373CD2
:1001C0000319FC2810080311E13C0319FC2810084E
:1001D0000311B53C0319FC2810080311793C0319DD
:1001E000FC2810080311303C0319FC2810080311E7
:1001F00018020319FC28572911080311893C031917
:10020000612911080311183C031961291108031110
:100210000E3C0319612911080311B03C031961292F
:1002200011080311193C031961291108031119025E
:100230000319612957298312003089000E088800AC
:100240008316081555308900AA3089008814831256
:1002500071212A298312013089000F088800831632
:10026000081555308900AA3089008814831271213D
:100270003929831202308900100888008316081576
:1002800055308900AA3089008814831271214829C9
:100290008312033089001108880083160815553031
:1002A0008900AA30890088148312712157295C21A2
:1002B000061A572906151B2886166B2186126B21F4
:1002C00008000617652106135729063095006B2193
:1002D000950B672908001E3094007121940B6D293D
:1002E00008000D3093007721930B73290800FF302D
:0802F0008C008C0B7929080039
:00000001FF
Codigo fuente en C++
Código: Seleccionar todo
#include<conio.h>
#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<dos.h>
#include<math.h>
void main (void)
{
int a,b,c,d,e,f,g,h,i,j,v,x,m,n,o,p,q,r,y,comp,saldo1;
float saldo;
double serie;
char opcion;
char cf2[10];
a=b=c=d=e=f=g=h=i=j=v=x=m=n=o=p=q=r=y=c=o=m=p=saldo=saldo1=0;
do
{
clrscr();
textcolor(12);
cprintf("\r\n LECTOR DEL NUMERO DE SERIE DE LAS TARJETAS TELEFONICAS DE 512 BITS");
textcolor(9);
cprintf("\r\n\n -\"dOLpHIn\"-");
textcolor(7);
printf("\n\n\n l): Leer tarjeta");
printf("\n t): Terminar el programa");
printf("\n c): Comentarios");
printf("\n\n>\n>");
opcion=getch();
opcion=tolower(opcion);
switch(opcion)
{
case'l':
{
clrscr();
printf(" El mapa completo de la tarjeta en binario es:");
printf("\n\n ");
a=b=c=d=o=p=q=r=0;
outportb(0x378,0);
outportb(0x378,4);
delay(1);
outportb(0x378,20);
delay(1);
outportb(0x378,4);
delay(1);
outportb(0x378,0);
delay(1);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
v=1;
printf("1");
for(n=0;n<7;n++)
{
outportb(0x378,16);
delay(1);
outportb(0x378,0);
delay(1);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
v=v<<1;
v=v++;
printf("1");
}
if(m==0)
{
v=v<<1;
printf("0");
}
}
printf(" ");
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
p=p<<1;
p=p++;
printf("1");
}
if(m==0)
{
p=p<<1;
printf("0");
}
}printf(" ");
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
q=q<<1;
q=q++;
printf("1");
}
if(m==0)
{
q=q<<1;
printf("0");
}
}printf(" ");
for(n=0;n<8;n++)
{
textcolor(10);
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
a=a<<1;
a=a++;
cprintf("1");
}
if(m==0)
{
a=a<<1;
cprintf("0");
}
}printf(" %02X %02X %02X ",v,p,q);
cprintf("%02X\n",a);
printf("\r ");
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
b=b<<1;
b=b++;
cprintf("1");
}
if(m==0)
{
b=b<<1;
cprintf("0");
}
}printf(" ");
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
c=c<<1;
c=c++;
cprintf("1");
}
if(m==0)
{
c=c<<1;
cprintf("0");
}
}cprintf(" ");
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
d=d<<1;
d=d++;
cprintf("1");
}
if(m==0)
{
d=d<<1;
cprintf("0");
}
}printf(" ");
e=0;
for(n=0;n<8;n++)
{
textcolor(12);
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
e=e<<1;
e=e++;
cprintf("1");
}
if(m==0)
{
e=e<<1;
cprintf("0");
}
}textcolor(10);
cprintf(" %02X %02X %02X ",b,c,d);
textcolor(12);
cprintf("%02X\n",e);
printf("\r ");
textcolor(7);
f=o=0;
for(n=0;n<8;n++)
{
textcolor(3);
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
cprintf("1");
o=o<<1;
o=o++;
f=f++;
}
if(m==0)
{
o=o<<1;
cprintf("0");
}
}printf(" ");
g=p=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
cprintf("1");
p=p<<1;
p=p++;
g=g++;
}
if(m==0)
{
p=p<<1;
cprintf("0");
}
}printf(" ");
h=q=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
q=q<<1;
q=q++;
cprintf("1");
h=h++;
}
if(m==0)
{
q=q<<1;
cprintf("0");
}
}printf(" ");
i=r=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
r=r<<1;
r=r++;
cprintf("1");
i=i++;
}
if(m==0)
{
cprintf("0");
}
}textcolor(3);
cprintf(" %02X %02X %02X %02X\n",o,p,q,r);
printf("\r ");
j=o=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
o=o<<1;
o=o++;
textcolor(3);
cprintf("1");
j=j++;
}
if(m==0)
{
o=o<<1;
textcolor(3);
cprintf("0");
}
}printf(" ");
textcolor(7);
saldo=(((4096*f)+(512*g)+(64*h)+(8*i)+(1*j))/100);
saldo1=(((4096*f)+(512*g)+(64*h)+(8*i)+(1*j))%100);
p=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
p=p<<1;
p=p++;
printf("1");
}
if(m==0)
{
p=p<<1;
printf("0");
}
}printf(" ");
q=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
q=q<<1;
q=q++;
printf("1");
}
if(m==0)
{
q=q<<1;
printf("0");
}
}printf(" ");
r=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
r=r<<1;
r=r++;
printf("1");
}
if(m==0)
{
r=r<<1;
printf("0");
}
}textcolor(3);
cprintf(" %02X ",o);
textcolor(7);
printf("%02X %02X %02X\n ",p,q,r);
textcolor(7);
o=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
o=o<<1;
o=o++;
cprintf("1");
j=j++;
}
if(m==0)
{
o=o<<1;
cprintf("0");
}
}printf(" ");
textcolor(7);
p=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
p=p<<1;
p=p++;
printf("1");
}
if(m==0)
{
p=p<<1;
printf("0");
}
}printf(" ");
q=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
q=q<<1;
q=q++;
printf("1");
}
if(m==0)
{
q=q<<1;
printf("0");
}
}printf(" ");
r=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
r=r<<1;
r=r++;
printf("1");
}
if(m==0)
{
r=r<<1;
printf("0");
}
}printf(" %02X %02X %02X %02X\n ",o,p,q,r);
for(y=0;y<11;y++)
{
o=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
o=o<<1;
o=o++;
cprintf("1");
}
if(m==0)
{
o=o<<1;
cprintf("0");
}
}printf(" ");
p=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
p=p<<1;
p=p++;
printf("1");
}
if(m==0)
{
p=p<<1;
printf("0");
}
}printf(" ");
q=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
q=q<<1;
q=q++;
printf("1");
}
if(m==0)
{
q=q<<1;
printf("0");
}
}printf(" ");
r=0;
for(n=0;n<8;n++)
{
outportb(0x378,16);
outportb(0x378,0);
x=inportb(0x379);
x=x>>5;
m=(x&1);
if(m==1)
{
r=r<<1;
r=r++;
printf("1");
}
if(m==0)
{
r=r<<1;
printf("0");
}
}printf(" %02X %02X %02X %02X\n ",o,p,q,r);
}
if(v!=255)
{
serie=(16777216*a)+(65536*b)+(unsigned)(256*c)+d;
textcolor(10);
if(r!=0)
{
cprintf("\r\nNumero de serie: 2%09.f",serie);
textcolor(7);
}
else
{
cprintf("\r\nNumero de serie: 4%09.f",serie);
textcolor(7);
}
if(e==35)
{
textcolor(12);
cprintf("\r\n\nValor: $30.00");
textcolor(7);
}
if(e==37)
{
textcolor(12);
cprintf("\r\n\nValor: $50.00");
textcolor(7);
}
if(e==50)
{
textcolor(12);
cprintf("\r\n\nValor: $100.00");
textcolor(7);
}
textcolor(3);
cprintf("\r\n\nSaldo: $%.f.%02d",saldo,saldo1);
textcolor(7);
cprintf("\r\n Presiona una tecla para regresar...");
getch();
}
}
if(v==255)
{
printf("\n\nEsta tarjeta es invalida, ¢ no esta conectada...");
printf("\nPresione una tecla para continuar...");
textcolor(7);
getch();
}
}break;
case'c':
{
clrscr();
printf("\n\n favor de mandar comentarios a ezkybe@hotmail.com ");
printf("\n\n\n\n\nr) regresar");
printf("\n\n>\n>");
textcolor(7);
getch();
}break;
case't':
{
outportb(0x378,0);
clrscr();
printf("El programa ha terminado, puedes cerrarlo");
exit();
}break;
}
}while(opcion!='t');
}
Aqui estan los archivos del proyecto, el diagrama esta funcionando bien solo que no esta muy especificado, por lo que tendran que darle una leida a las configuraciones del codigo para los puertos, creo que al parecer lo unico que le falta al diagra son los nombres de las conexiones del chip de la tarjeta pero quedaria asi: clk -> PORTB,3 rst ->PORTB,1 y I/O ->PORTA,4, para dar de alta o baja la tarjeta ustedes pueden meter una clave, para me ter su propia clave deben ingresar "00000000" (creo) en caso de que esta no sea la clave , pueden ingresar la clave maestra "28092006" (esa si no se olvida fue la fecha de mi boda), pues les paso toda la informacion (hace 1 año no lo hubiera echo por nada del mundo), el pic utilizado es el pic16f628a. El .hex que hay que grabar en el pic es: "corregido.hex" en el archivo .rar que adjunto viene todo lo que use en la presentacion en este proyecto de cerradura.
Descripción del proyecto LECTOR de Chips y Cerradura con Tarjetas CHIP
Se trata de un circuito que tiene un soket para este tipo de tarjetas. Lo que hice primero fue realizar un program en c++ con el cual se obtiene el numero de serie de las 5 tarjetas que se quiere utilizar como "llaves". Luego en el programa en ensamblador (el cual no lo subieron a la red) se escriben estos numeros obtenidos de el programa anterior, para que el pic lo reconosca. Entonces tu tienes ya registradas las 5 tarjetas y solo con ellas se puede accesar, si el pic detecta que es una tarjeta valida enciende un led, esta salida tu la pudes conectar a una cerradura electrica, o permites encender un aparto etc.
Supongamos que tu utilizas este circuito para ponerla en la cerradura de una puerta. Entonces ya tienes tus 5 "llaves". pero tienes una visita o se te pierde una.
entonces el circuito cuenta con un dip switch el cual sirve como clave para permitir que des de alta una sexta tarjeta.
Ahora solo pones la clave en el dipswitch metes la tarjeta, el dispositivo la registra y ya la puedes utilizar como otra llave. solo la persona que sepa la clave del dipswitch podra dar de alta la sexta tarjeta, al dar de alta otra tarjeta se borra el dato de la tarjeta anterior y dejara de servir como otra llave. Ttodas estas modificaciones no afectan a las primeras 5 llaves. ya que estas solo se pueden modificar desde el codigo .asm
El archivo .asm esta con comentarios para facilitar el entendimiento y poder modificarlo sera facil. pero no lo pusieron en la red.
hay dos programas en el .zip el que dice cum lee toda la tarjeta, y el que dice lector2 lee solo 128bits pero resalta en un cuadro el numero de serie en hexadecimal.
INSTRUCCIONES DE PROGRAMACION
Primero se leen las tarjetas telefónicas que se vallan a utilizar como llaves con el circuito lector de tarjetas y el programa para ejecutarlo, y se copia su código en hexadecimal correspondiente al numero de serie, en el archivo .asm.
Este archivo tiene comentado todo el programa en ensamblador se recomienda abrirlo con el mplab. Ahí se indica la sección que se debe de modificar y el código que en mi caso utilice según mis tarjetas. El PIC tendría registradas las 5 tarjetas con su número de serie. Para modificar la clave de registro de la tarjeta opcional se puede modificar en la parte de la etiqueta “OPCION” en la instrucción:
Código: Seleccionar todo
xorlw b'00001110'
Para dar de alta la sexta tarjeta solo se tiene que ingresar el código binario correcto por el dipswitch. En este caso la combinación es “01110”
Después de esto se saca la tarjeta y se deshace la combinación correcta del dipswitch, y la tarjeta será una mas para poder abrir la cerradura.
Para remplazar esta tarjeta se repite el mismo procedimiento con la nueva tarjeta.
Este proyecto Fue enviado a los señores de Saber Electrónica y resulta que el montaje que envio Dh0lpin a los de la revista tiene unos errores. En el aporte enviado se mencionaba que las tarjetas eran de 128 bits, por eso en el programa que puso solo lee hasta el 128vo bit pero logró modificarlo (demasiado tarde pues ya lo habia enviado el archivo a la editorial), por esto en el archivo .zip está un programa en c que lee el mapa completo de la tarjeta. de todos modos los dos sirven y el que lee los 128 bits resalta en un recuadro el código de serie.
Con respecto a la lectura y velocidad
En casos comunes siempre ha funcionado con el retardo de 1 milisegundo, una vez se hizo sin retardo y la tarjeta no fue capaz de responder con velocidad, se he probado con un retardo de 1 miliseg. en una computadora portátil con un procesador PIII a 350 mhz y en una computadora en P4 a 1.6Ghz y en los dos corre sin poblemas.
Aqui esta el adjunto completo: En Google Drive:
Código: Seleccionar todo
https://drive.google.com/open?id=1fsR6qoV6Msx--1o5VpvM1_Q3L1tu-Nve