Leer y escribir en Smart Cards..

[pocher]

Hola.

Os indico lo que hice:

Codigo:#include <16F876.h>
#use fast_io(A) 
#use delay(clock=4000000) 
#fuses XT,NOWDT,NOPROTECT,NOLVP,NOBROWNOUT, NOWRT
#include <2402.c> // SDA=PIN_C4 , SCL = PIN_C3 
#include <lcd_c.c> 

void main() 
{ 
   int dato1,dato2,dato3; 
   EEPROM_ADDRESS direccion; 
   init_ext_eeprom(); 
   lcd_init(); 
   dato1 = 2;      //Codigo secreto correcto (2)
   dato2 = 9;      //Código incorrecto (9)
   direccion = 100; 

   while(1)
   {
      lcd_putc("f";
      
      if(input(PIN_A0))
      {
         write_ext_eeprom(direccion,dato1);   //Grabación del dato correcto (2)
         delay_ms(1000);
      }   
      if(input(PIN_A1))
      {
         write_ext_eeprom(direccion,dato2);   //Grabación de un dato incorrecto (9)         
         delay_ms(1000);
      }
      
      dato3 = read_ext_eeprom(direccion);
      
      if (dato3==2)                     //¿El código de la tarjeta es 2?
      {
         lcd_gotoxy(1,1);
         printf(lcd_putc,"Codigo OK";
         output_high(PIN_C0);            //Abre puerta
         delay_ms(2000);
         output_low(PIN_C0);         
      }
      else
      {
         lcd_gotoxy(1,1);         
         printf(lcd_putc,"Codigo falso";
         delay_ms(2000);         
      }
   } 
} 

Los pines de la tarjeta SLE 4442 son los siguientes:

1: VCC ---> a 5V
2: RST
3: CLK (SCL)  ---> a RC3 mediante pullup
4: N.C.
5:GND
6: N.C.
7: I/O (SDA) ---> a RC4 mediante pullup
8:N.C.

Un saludo

[LordLafebre]

Hola:

Pocher me perdi un poco en el codigo... no entiendo bien como funciona esto:

write_ext_eeprom(direccion,dato1);

tengo claro que dato es el valor que quieres guardar, pero con direccion me confundo un poco, si direccion es la posiscion de la eeprom, no se que byte de control estas utilizando... ...

las funciones para basic son estas:

I2CREAD DataPin,ClockPin,Control,{Address,}[Var{,Var...}]{,Label}
I2CWRITE DataPin,ClockPin,Control,{Address,}[Value{,Value...}]{,Label}

datapin y clockpin no hay problema, tampoco en adress y value, lo que no encuentro en tu codigo es el byte de control...

Con esto del byte de control me perdi un poco, ya que existe uno para leer y escribir en una memoria principal, otros dos para memoria de proteccion y otros dos para memoria de seguridad... aqui es donde me pierdo....



Esos son los bytes de control de los que hablo...

[pocher]

Hola LordLafebre.

Me miro más detenidamente el fichero 2402.c que por si no tienes instalado el CCS te lo pego.

Codigo:///////////////////////////////////////////////////////////////////////////
////   Library for a MicroChip 24LC02B configured for a x8 org         ////
////                                                                   ////
////   init_ext_eeprom();    Call before the other functions are used  ////
////                                                                   ////
////   write_ext_eeprom(a, d);  Write the byte d to the address a      ////
////                                                                   ////
////   d = read_ext_eeprom(a);  Read the byte d from the address a     ////
////                                                                   ////
////   b = ext_eeprom_ready();  Returns TRUE if the eeprom is ready    ////
////                            to receive opcodes                     ////
////                                                                   ////
////   The main program may define EEPROM_SDA                          ////
////   and EEPROM_SCL to override the defaults below.                  ////
////                                                                   ////
////                            Pin Layout                             ////
////   -----------------------------------------------------------     ////
////   |                                                         |     ////
////   | 1: NC   Not Connected | 8: VCC   +5V                    |     ////
////   |                       |                                 |     ////
////   | 2: NC   Not Connected | 7: WP    GND                    |     ////
////   |                       |                                 |     ////
////   | 3: NC   Not Connected | 6: SCL   EEPROM_SCL and Pull-Up |     ////
////   |                       |                                 |     ////
////   | 4: VSS  GND           | 5: SDA   EEPROM_SDA and Pull-Up |     ////
////   -----------------------------------------------------------     ////
////                                                                   ////
///////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996, 2003 Custom Computer Services          ////
//// This source code may only be used by licensed users of the CCS C  ////
//// compiler.  This source code may only be distributed to other      ////
//// licensed users of the CCS C compiler.  No other use, reproduction ////
//// or distribution is permitted without written permission.          ////
//// Derivative programs created using this software in object code    ////
//// form are not restricted in any way.                               ////
///////////////////////////////////////////////////////////////////////////
#ifndef EEPROM_SDA

#define EEPROM_SDA  PIN_C4
#define EEPROM_SCL  PIN_C3

#endif


#use i2c(master, sda=EEPROM_SDA, scl=EEPROM_SCL)

#define EEPROM_ADDRESS BYTE
#define EEPROM_SIZE    256

void init_ext_eeprom() {
   output_float(EEPROM_SCL);
   output_float(EEPROM_SDA);
}

BOOLEAN ext_eeprom_ready() {
   int1 ack;
   i2c_start();            // If the write command is acknowledged,
   ack = i2c_write(0xa0);  // then the device is ready.
   i2c_stop();
   return !ack;
}

void write_ext_eeprom(BYTE address, BYTE data) {
   while(!ext_eeprom_ready());
   i2c_start();
   i2c_write(0xa0);
   i2c_write(address);
   i2c_write(data);
   i2c_stop();
}


BYTE read_ext_eeprom(BYTE address) {
   BYTE data;

   while(!ext_eeprom_ready());
   i2c_start();
   i2c_write(0xa0);
   i2c_write(address);
   i2c_start();
   i2c_write(0xa1);
   data=i2c_read(0);
   i2c_stop();
   return(data);
}

La verdad que cuando lo probé lo hice tal cual está y funcionó.

[LordLafebre]

Hola:

Pues al parecer estas utilizando el mismo bite de control de las 24CXX que es
%10100000... voy a probarlo...

Gracias pocher...

[LordLafebre]

Hola:

pues te comento que no me funciono asi... luego viendo en el data, me da este diagrama de flujo para hacerla andar:



aun no lo pruebo... ya lo intentaré...

Como anecdota te comento lo siguiente....

Al intentar con ese byte (A0) y grabar los mismos datos en la misma posicion de memoria que tu ejemplo en el primer intento segun yo si me grabo el 2... pero luego al intentar grabar otro valor y leerlo seguia con el 2.... no se si tu intentaste grabar diferentes datos, incluso en otras posiciones de memoria...?

[pocher]

Sí, si que probé con otros números en diferentes posiciones de memoria y iba bien. Las 32 primeras posiciones no las toqué.

[pocher]

Esto me lo grabé hace tiempo:

SLE4442, se encuadra en una SMARTCARD, pues no puede ser escrita si antes no le ingresas una clave de 3 bytes y puedes equivocarte solo 3 veces en ingresarla, si pasas tres veces queda bloqueada para siempre, el modelo anterior no tiene esta proteccion, la SLE4432, pero si se pueden proteger los primeros 32 bytes en forma ireversible, tambien estuve leyendo sobre la SLE44428 que es de 1 K pero con protocolo 3 wire.

Casi seguro que la tarjeta que tengo no es la SLE4442

[LordLafebre]

Hola:

Pues la cosa no parece estar tan facil despues de todo... el amigo Carlos (dogflu66) muy gentilmente me paso estas hojas de una revista... y las pongo aqui por si a alguien mas les interesa...

http://rapidshare.de/files/12698751/Lector_Tarjeta_Chip.rar.html

Ahora me tomare un tiempo para leerlas ya que esta todo entendible (español) porque en el data me estaba perdiendo...

[pocher]

Oye muy bueno el enlace. Ojala hubiera tenido esta información hace tiempo.

[LordLafebre]

Hola:

Asi es... muy buena la info... las gracias nuevamente a dogflu66 y a ver que sale de esto...

[pikman]

Hola, LordLafebre, bueno te cuento que yo desarrolle una libreria de control completa para la tarjeta SLE4442 de Simens, que no es ni nada tiene que ver con una memoria 24CXX.

Puedo ayudarte pero por razones contractuales con la empresa que me contrato por el desarrollo es que no publicare el codigo completo ni partes de el, pero te puedo guiar sin problemas, y si miras el asm que te paso chaly seguro puedes darte cuenta que las rutinas no son I2C.

La confusion y que a POCHER le haya funcionado con las libreias de I2C es proque exixten tarjetas "identicas" con memorias de este tipo enbebidas, puedes mirar si quieres en www.micromodule.com, donde ademas encontraras mas info porque son una empresa suplidora de tarjetas inteligentes, tambien hay algo en www.makinterface.com y www.maxking.com.

La SLE4442 es una tarjeta que responde a un protocolo propietario de simens/infineon, y la configuracion de contactos e inetrface responde al standart
ISO 7816.

La capacidad de memoria de la tarjeta es 256 bytes, de los cuales solo 224 son utilizables por el usuario, porque los primeros 32, se utilizan por el fabricante y el usuario para etiquetar la aplicacion.

Los primeros 4 bytes son exclusivos del fabricante, y corresponden a la informacion de la tarjeta, protocolo ( 2 wire/3 wire ect), fabricante, forma e leerla y otros datos que encontraras en la hoja de datos que si no la tiene completa te la puedo enviar.

Los demas bytes son para que el usuario pueda distinguir su aplicacion de los demas colocando datos especificos, estos bytes despues se pueden convertir en ROM ejecutando el comando 0x3C ( write protection memory ).

Para poder leer la tarjeta lo primeroq ue hay que hacer es resetarla, ejecutando el RESET Y ANSWER to RESET, de esta manera la tarjeta se prepara para poder comunicar y luego envia lo que se llama RESPUESTA AL RESET O ANSWER TO RESET, que es una trama de 32 bits ( 8 bytes) que le indican al lector que protocolo usar para poder dialogar con la tarjeta, si no haes esto "jamas" te vas a comunicar con ella.

Bueno aqui te pongo los pasos a seguir para leer el ATR.

Colocar una resistencia de 10K entre I/O y VCC, pues I/O no tiene pul-up
interno.

1-Alimentar la tarjeta

2-Detectar si esta la tarjeta en el lector.
 
3-Poner en 1 la linea  RST.

4-Enviar un pulso de 50 Us por CLK.

5-Poner en 0 la linea RST.

6-Enviar un pulso de 50 Us por CLK.

7-Leer el valor de I/O y almacenarlo en el micro.

8-Volver al punto 6 32 veces, y luego dejar CLK y RST en 0.

9-Ya tenemos el ATR en los 4 Bytes, 0xA2,0x13,0x10,0x91

Si miras el data sheet este valor identifica a la tarjeta.

Ahora solo te resta crear la funcion para que haga esto y ya tienes el primer paso, despues hay que desarrollar una funcion para cada comando.

Esta tarjeta tiene la particularidad de que no se puede escribir sin antes ingresar un PASSWORD que es de 6 caracteres numericos expresados en BCD en 3 bytes, por ejemplo si fuese la clave decimal 123456 se almacena 0x12,0x34,0x56, en la tarjeta y tiene un delicado proceso de verificacion, si la clave es ingresada 3 veces mal, puedes ir despidiendote de escribirla porque ya no sera posible, si seguira permitiendo leerla.

Un saludo y espero que te sirva.

saludos

ARIEL / PIKMAN.

[LordLafebre]

Hola:

Gracias PIKMAN por la ayuda que me ofreces, estoy de acuerdo contigo y entiendo el por que no puedes publicar el codigo, bueno, con respecto a lo de la primera tarjeta fue mucho problema porque en donde la compre no sabian ni lo que me vendieron , pero luego me confirmaron que es una SLE4442, a mas de esa tengo dos mas para dañarlas antes de que pueda hacerla funcionar , ahora me aclaras algunas cosas que no entendia bien en el data, veamos si se anima alguien mas y hacemos una libreria, yo trabajo en Basic y voy a intentar hacerla en este lenguaje, hoy en la noche empezare con esto.

Gracias PIKMAN...

Saludos a todos...!!!

[pikman]

OK, bueno, no conozco mucho el picbasic, pero puedo ayudarte, comienza por la rutina de RESET y ANSWER TO RESET, pegala y te ayudo.

saludos
ARIEL

[LordLafebre]

Hola:

Bueno, aqui pongo algo de lo que entendi, lo que no me quedo claro es:

7-Leer el valor de I/O y almacenarlo en el micro.

como puedo leer...?

por lo otro hice algo como esto, la conexion esta asi:

SLE     PIC
CLK----BO
I/O-----B1
RST-----B2

Codigo:"Smart Cards
i var byte

PORTB=0 "Encero el puerto B

    high portb.2 "rst en 1 (1)
    high portb.0:pause 50: low portb.0 "pulso de 50 ms para clk (2) 
    low portb.2 "rst en 0 (3)
    high portb.0:pause 50: low portb.0 "pulso de 50 ms para clk (4)
    "-
    "leer el valor de I/O (5)
    "-
    for i=0 to 31
        high portb.0 "Volver al punto 6 32 veces
        pause 50
        low portb.0 
        pause 50
    next i
    low portb.0
    low portb.2

Ruego un poquito de paciencia... con algo como esto no me he metido nunca...

Y el data me marea sinceramente , luego del mensaje tuyo Pikman me quedaron claras algunas cosas...

Gracias Ariel por la paciencia

[Chaly29]

Hola LordLafebre, primera ves que posteo en PICBasic y espero me entiendas, luego de que le das el pulso de reloj (flanco ascendente) a la tarjeta, revisas el estado del pin I/O que seria la entrada de datos, según el dato almacenado en la tarjeta será el estado en que se encuentre I/O, en este primer pulso tendrás el D0 del primer byte, al segundo pulso D1 del primer byte y así sucesivamente asta completar los 4 bytes o 32 pulsos:

Codigo:PORTB=0 "Encero el puerto B

   high portb.2 "rst en 1 (1)
   high portb.0:pause 50: low portb.0 "pulso de 50 ms para clk (2) 
   low portb.2 "rst en 0 (3)
   for i=0 to 31
      high portb.0 "Volver al punto 6 32 veces
      ----
      AQUI VERIFICAS EL ESTADO DE I/O
      SI LO ENTERIOR ES 1 PONES EN HIGH BIT.7 DEL BYTES4
      BORRAS EL CARRY DEL STATUS
      ROTAS A LA DERECHA 1 POSICION BYTE4
      ROTAS A LA DERECHA 1 POSICION BYTE3
      ROTAS A LA DERECHA 1 POSICION BYTE2
      ROTAS A LA DERECHA 1 POSICION BYTE1
      ----
      pause 50
      low portb.0 
      pause 50
   next i
   low portb.0
   low portb.2

Espero me puedas entender, ya que como sabe de Basic no calo nada

Un saludo, suerte

Atte. CARLOS