Lector de Chips de Tarjetas Telefonicas

Sección dedicada a imágenes de circuitos, diagramas que no requieren explicación previa, Proyectos sencillos.
Area para desarrollo de proyectos, colaboración de toda la comunidad en proyectos. Solución de dudas y aportes.

No publicar manuales, no publicar temas ajenos a los proyectos. de ser necesario, hacer indicación con enlace entre etiquetas CODE
Avatar de Usuario
Enigma
Administrador del Sitio
Administrador del Sitio
Mensajes: 1268
Registrado: 20 Oct 2013, 16:26
Genero: Mujer
Profesion: Webmaster CEO SEO
Ubicacion: Matrix
Navegador: Chrome
Contactar:

Lector de Chips de Tarjetas Telefonicas

Mensaje sin leer por Enigma » 30 Mar 2015, 16:27

Lector de Chips de Tarjetas Telefonicas
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.

Imagen

Cerradura
Imagen

Lector alterno
Imagen

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);
cuando oprimimos la tecla"l"

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
Por eso se comienza con la instruccion outportb(0x378,0)
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
Codigo fuente en HEX

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'  
Solo se pude modificar los 5 bits marcados con negritas. Para cambiar la clave de registro de la tarjeta. Después de hacer las programaciones correspondientes se compila el archivo y se graba en el PIC con el .hex. Se arma todo el circuito y se energiza.

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:
cerradura_tarjeta.zip
En Google Drive:

Código: Seleccionar todo

https://drive.google.com/open?id=1fsR6qoV6Msx--1o5VpvM1_Q3L1tu-Nve
No tiene los permisos requeridos para ver los archivos adjuntos a este mensaje.



dolphin

Re: Lector de Chips de Tarjetas Telefonicas

Mensaje sin leer por dolphin » 28 Sep 2015, 23:01

Hola a todos hace algunos años yo hice este circuito y fui quien lo envió a saber electronica en aquel entonces no programa muy bien ,y era muy confuso y largo el programa además que ya no se usa mucho el puerto paralelo así que aquí les dejo mis últimas actualizaciones de este proyecto si el administrador de este sitio se pone en contacto conmigo le pasó el código pero en la descripción de los vídeos esta completo. Saludos a todos



[youtube]https://www.youtube.com/channel/UCJcySu ... 2xtpYfLDHg[/youtube]

ezkybel
Mensajes: 1
Registrado: 29 Sep 2015, 10:03
Genero: Hombre
Profesion: Ing. Electronico
Ubicacion: SLP
Navegador: Chrome
Contactar:

Re: Lector de Chips de Tarjetas Telefonicas

Mensaje sin leer por ezkybel » 29 Sep 2015, 10:19

Buenas días a todos soy nuevo en el foro, yo soy el usuario "dolphin" y soy el autor de este proyecto, solo quiero compartir con ustedes las actualizaciones de este proyecto, ya que lo que esta posteado fue lo primero que hice, en aquel entonces comenzaba a programar y aunque el código es 100% funcional no es muy educativo debido a que es muy complejo, actualmente tengo este proyecto para arduino por lo que es mucho mas sencillo ademas de que se pueden leer datos de la tarjeta y visualizarlos por medio del monitor serie ya que hoy en día la mayoría de los PCs ya no cuentan con el puerto paralelo, así que aquí les dejo el link de los vídeos que subí a youtube en la descripción del vídeo viene el código fuente para estos proyectos, desafortunadamente por falta de tiempo no he podido hacer un diagrama pero si alguno de ustedes puede hacerlo basándose en el código de arduino se los agradeceré mucho
Saludos a todos

https://www.youtube.com/user/aepiscis/videos

[youtube]https://www.youtube.com/RA09tOYfVqg[/youtube]


Este es la primera parte del proyecto que estoy realizando para la lectura del chip de una tarjeta telefónica, en esta parte se lee el número de serie de la tarjeta a excepción del primer digito, ya que este no se encuentra en el chip.

La siguiente etapa será almacenar dicho número de serie en la memoria eeprom del arduino para que la tarjeta quede identificada como una llave, y así posteriormente usarla como sistema de seguridad aplicado por ejemplo a cerraduras.

Este proyecto lo realice hace años con un PIC16f628A y ahora me gustaría traducirlo a Adrduino, Para mayor información acerca de las tarjetas telefónicas dejo un link de una publicacion en donde explico mas a detalle cómo funcionan estas tarjetas.

Este es el codigo:

Código: Seleccionar todo

const int RST  = 2;
const int CLK  = 3;
const int IO   = 4;
const int SWT  = 5;
const int JMP  = 6;
const int DOOR = 7;

const int t_del = 20;

byte i;
byte x;
byte conteo;
byte Serie[4];
unsigned long Num_serie;

//*******Rutina de Reset*********

void reset()
{
   digitalWrite(RST, HIGH);
   delayMicroseconds(t_del);
   digitalWrite(CLK, HIGH);
   delayMicroseconds(t_del);
   digitalWrite(CLK, LOW);
   delayMicroseconds(t_del);
   digitalWrite(RST, LOW);
   delayMicroseconds(t_del);
}

//*******Rutina de Pulso*********
void pulso(void)
{
   digitalWrite(CLK, HIGH);
   delayMicroseconds(t_del);
   digitalWrite(CLK, LOW);
   delayMicroseconds(t_del);
}

//*******************************
void setup() {

  Serial.begin(9600);

  pinMode(IO, INPUT); 
  pinMode(CLK, OUTPUT); 
  pinMode(RST, OUTPUT); 
  pinMode(JMP, INPUT); 
  pinMode(SWT, INPUT); 
  pinMode(DOOR, OUTPUT); 
}

void loop() {

  if (digitalRead(SWT) == HIGH){     //detecta si entro la tarjeta al socket

  delay(500);

  conteo=0;
  x=0;
  Serie[0]=0;
  Serie[1]=0;
  Serie[2]=0;
  Serie[3]=0;

  reset(); // Resetea la tarjeta

  delay(1);
  for(i=0;i<23;++i){ // Ignora los siguientes 23 bytes    
    pulso();
  }

  for(i=0;i<32;++i){
    pulso(); //incrementa la direccion del mapa de la tarjeta

    if (digitalRead(IO) == HIGH){  
      bitSet(Serie[x],0);  
    }

    if(conteo<7){
      Serie[x]= Serie[x] << 1;
      conteo++;
    }
    else{
      conteo=0;
      x++; 
    } 
  }

  Num_serie=Serie[3]+unsigned(256 * Serie[2])+(65536 * Serie[1])+(16777216 * Serie[0]);
  Serial.print("Numero de serie: ");
  Serial.println(Num_serie);
  while(digitalRead(SWT) == HIGH);
  delay(10);
  }
}
[youtube]https://www.youtube.com/Dv0g8aaJ7Wo[/youtube]

Esta es la segunda parte de la programación de el lector de Tarjetas telefonicas,
En esta parte se puede dar de alta un numero de serie y este se guarda en la memoria eeprom al oprimir el boton antes de insertar la tarjeta(enciende led amarillo).
Despues de darla de alta solamente se inserta la tarjeta y el lector validara si es la que previamente se dio de alta de ser asi dara el acceso (enciende led verde) y de lo contrario encendera el led rojo.

Este es el codigo:

Código: Seleccionar todo

#include <EEPROM.h>

const int RST  = 2;
const int CLK  = 3;
const int IO   = 4;
const int SWT  = 5;
const int JMP  = 6;
const int DOOR = 7;
const int LED_A = 8;
const int LED_R = 9;

const int t_del = 20;

byte i;
byte x;
byte conteo;
byte Serie[4];
byte Iguales;
unsigned long Num_serie;

//*******Rutina de Reset*********

void reset()
{
   digitalWrite(RST, HIGH);
   delayMicroseconds(t_del);
   digitalWrite(CLK, HIGH);
   delayMicroseconds(t_del);
   digitalWrite(CLK, LOW);
   delayMicroseconds(t_del);
   digitalWrite(RST, LOW);
   delayMicroseconds(t_del);
}

////*******Rutina de Pulso*********
void pulso(void)
{
   digitalWrite(CLK, HIGH);
   delayMicroseconds(t_del);
   digitalWrite(CLK, LOW);
   delayMicroseconds(t_del);
}

//*******************************
void setup() {

  Serial.begin(9600);

  pinMode(IO, INPUT); 
  pinMode(CLK, OUTPUT); 
  pinMode(RST, OUTPUT); 
  pinMode(JMP, INPUT); 
  pinMode(SWT, INPUT); 
  pinMode(DOOR, OUTPUT); 
  pinMode(LED_R, OUTPUT); 
  pinMode(LED_A, OUTPUT); 
}

void loop() {
  digitalWrite(LED_A,LOW);
  digitalWrite(LED_R,LOW);
  digitalWrite(DOOR,LOW);

  if (digitalRead(SWT) == HIGH){     //detecta si entro la tarjeta al socket

  delay(500);

  conteo=0;
  x=0;
  Serie[0]=0;
  Serie[1]=0;
  Serie[2]=0;
  Serie[3]=0;

  reset(); // Resetea la tarjeta

  delay(1);
  for(i=0;i<23;++i){ // Ignora los siguientes 23 bytes    
    pulso();
  }

  for(i=0;i<32;++i){ //Aqui se almacenan los 32 bits de numero de serie en los 4 bytes de "Serie[]"
    pulso(); //incrementa la direccion del mapa de la tarjeta

    if (digitalRead(IO) == HIGH){  
      bitSet(Serie[x],0);  
    }

    if(conteo<7){
      Serie[x]= Serie[x] << 1;
      conteo++;
    }
    else{
      conteo=0;
      x++; 
    } 
  }

  Num_serie=Serie[3]+unsigned(256 * Serie[2])+(65536 * Serie[1])+(16777216 * Serie[0]);

  if (Num_serie!=4294967295 && Num_serie!=0)
  {
    if (digitalRead(JMP) == LOW){ // si el boton esta presionado entra en modo grabacion 
       for(i=0;i<4;++i){
         EEPROM.write(i,Serie[i]);
       }
       digitalWrite(LED_A,HIGH);
       Serial.println("Tarjeta Guardada");
    }
    else //Si no esta presionado entonces compara el numero de serie con el almacena y decide si da el acceso
    {
        Iguales=0;
        for(i=0;i<4;++i){
         if(Serie[i]==EEPROM.read(i)){ //Compara que los 4 bytes de la EEPROM con los del numero de serie
           Iguales++;
         }
       }
       if (Iguales==4){   // sin son iguales da el acceso
           digitalWrite(LED_R,LOW);
           digitalWrite(DOOR,HIGH);
           Serial.println("Acceso Correcto");
       }
       else{             // de lo contrario prende el led Rojo
         digitalWrite(LED_R,HIGH);
         digitalWrite(DOOR,LOW);
         Serial.println("Acceso Denegado");
       }
    }
  } 
  else{
    digitalWrite(LED_R,HIGH);
    Serial.println("Tarjeta Invalida");
  }  

  Serial.print("Numero de serie: ");
  Serial.println(Num_serie);
  while(digitalRead(SWT) == HIGH);
  delay(10);
  }
}

Avatar de Usuario
Enigma
Administrador del Sitio
Administrador del Sitio
Mensajes: 1268
Registrado: 20 Oct 2013, 16:26
Genero: Mujer
Profesion: Webmaster CEO SEO
Ubicacion: Matrix
Navegador: Chrome
Contactar:

Re: Lector de Chips de Tarjetas Telefonicas

Mensaje sin leer por Enigma » 06 Oct 2015, 14:28

Agradecemos tu gran aporte, este aporte lo tenía hace muchos años en unos apuntes y desconocía al autor (2008 - 2009 por ahí en esos años creo) y es agradable saber que se comparte sin interés. He adaptado tu post y le he puesto los aportes respectivos y los videos.

Te agradezco en nombre de EnigmaTeam.

Avatar de Usuario
Enigma
Administrador del Sitio
Administrador del Sitio
Mensajes: 1268
Registrado: 20 Oct 2013, 16:26
Genero: Mujer
Profesion: Webmaster CEO SEO
Ubicacion: Matrix
Navegador: Chrome
Contactar:

Re: Lector de Chips de Tarjetas Telefonicas

Mensaje sin leer por Enigma » 10 Mar 2018, 09:23

Es nesesario usar el mplab al dar de alta todas sus tarjettas que quieran que sean las llaves.
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. Ambos funcionan con el mismo hardware

Responder

Volver a “Proyectos y Circuitos Didacticos”