
Reeditado por www.tecnicoselectronicos.com


  ======================================================================
            Lo que necesitas saber sobre tarjetas de microchip
  ======================================================================

                  (C) Stephane BAUSSON - (93,94,95)
              Versin 1.12 (Ultima revisin: 18-05-1995)


                           4, Rue de Grand
                          F-88630 Chermisey
                               Francia

 ----------------------------------------------------------------------
>>> Ser bienvenida cualquier sugerencia o comentario sobre tarjetas <<<
>>>                  de microchip  inteligentes.                    <<<
 ----------------------------------------------------------------------

Este documento est archivado en
nic.funet.fi:/pub/doc/telecom/phonecard/chips

Agradecimientos:
~~~~~~~~~~~~~~~~
    XRed                   xxxxxx@etsit.upv.es
    Proux Jean-Philippe ## proux@idris.fr
    Tomi Engdahl        ## Tomi.Engdahl@hut.fi
    Gerrit Telkamp      ## telkamp@eis.cs.tu-bs.de
    Martin Schulte      ## schulte@thp.Uni-Koeln.DE
    Georges Zotos       ## picard@hol.ath.forthnet.gr
    Ales "MCA" Markarov ## xmarkarov@sun.felkcvut.cz
    Toni Cebrian        ## acebrian@etsit.upv.es

Cronologa del Documento:
~~~~~~~~~~~~~~~~~~~~~~~~~
    Versin 1.12 : Cdigo del fabricante aadido.
    Versin 1.11 : Tarjetas de Croacia aadidas.
    Versin 1.10 : Tarjetas de Rumana aadidas.
    Versin 1.09 : Tarjetas de Espaa aadidas.
    Versin 1.08 : Modificacin del contador octal de 1 fase en las
                   tarjetas de Grecia.
    Versin 1.07 : Modificacin del contador octal de 5 fases en las
                   tarjetas de 128 bits.
    Versin 1.06 : Diagrama de un nuevo lector
    Versin 1.02 : Introduccin de las tarjetas de Alemania
    Versin 1.00 : Primera publicacin escrita del documento.

Glosario:
~~~~~~~~~
    TBC : pendiente de confirmacin
    TBD : pendiente de definicin
-------------------------------------------------------------------

                               * Contenido *
                               ~~~~~~~~~~~~~

 I ) Las tarjetas de Gemplus, Solaic Schlumberger, Oberthur:

    1.1 - Introduccin:
    1.2 - ESQUEMA del microchip:
    1.3 - Atribucin de los segmentos del conector:
    1.4 - Caractersticas principales:
    1.5 - DIAGRAMA DE TEMPORIZACIONES:
    1.6 - Mapa de memoria de las tarjetas de Francia y Mnaco:
    1.7 - Mapa de memoria de las tarjetas de Andorra, Repblica Checa,
          Finlandia, Gabn, Irlanda, Mexico, Noruega, Portugal y
          Suecia:
    1.8 - Mapa de memoria de las tarjetas de Espaa y Croacia:


II ) Las tarjetas de ODS: (tarjetas de Alemania)

    2.1 - Introduccin:
    2.2 - Conector:
    2.3 - Caractersticas principales:
    2.4 - Diagrama de temporizaciones:
    2.5 - Mapa de memoria:

      2.5.1 - Mapa de memoria para el contador octal de 5 fases:
      2.5.2 - Mapa de memoria para el contador de unidades octal de 4
              fases:

    2.6 - Caractersticas elctricas:


III) Esquemas de lectores de tarjetas:

    3.1 - Lector 1:
    3.2 - Lector 2:

IV) El programa:

-----------------------------------------------------------------------

I ) Las tarjetas de Gemplus, Solaic, Schlumberger, Oberthur: (Tarjetas
    de Francia)
    ==================================================================

    1.1 - Introduccin:
          ~~~~~~~~~~~~

    Desde mediados de los aos 80 ha aparecido en el mercado una
nueva generacin de tarjetas (las llamadas "inteligentes", o de
microchip) que han sustituido a las tarjetas magnticas en la mayora
de sus aplicaciones, sobre todo en el pago por servicios de
telecomunicacin, y como tarjetas de crdito. Estas tarjetas son mucho
ms seguras que las tarjetas magnticas, y hay varios tipos de
tarjetas de microchip que se adaptan a la aplicacin en cuestin. Las
ms simples son las de Memoria Simple, com las usadas por Telecard
para el pago en cabinas de telfonos (normalmente, todo el contenido
de la memoria es legible, y hay una zona de memoria protegida frente a
escritura para los datos de fabricante), y luego estn las tarjetas
ms sofisticadas: tarjetas de memoria con una zona protegida mediante
una clave, que podran contener datos personales en la zona
protegida. Finalmente, existen tarjetas de microprocesador (siguiendo
el protocolo estndar ISO-7816), que son las ms seguras, ya que
contienen su propio sistema operativo que bloque la entrada/salida de
datos a menos que la clave correcta haya sido introducida. (Estas
tarjetas se usan cuando se necesita una gran confidencialidad, por
ejemplo en tarjetas bancarias, codificadores de seales de TV,
tarjetas de sanidad, etc.)

    No crea el lector que podr llamar gratis con las tarjetas de
telepago, incluso si stas son las menos seguras. Toda la memoria es
accesible, ya que la tarjeta no contiene datos personales, pero las
tarjetas estn construdas suficientemente bien como para ofrecer un
medio de pago seguro para cabinas de telfono.

    As que, qu es una tarjeta de telfonos exactamente? En general,
es una memoria EPROM de 256 bits (como en el caso de las tarjetas de
Francia), o una memoria EEPROM de 128 bits (como las tarjetas de
Alemania, por ejemplo), con una salida serie y otros contactos de
control.

    Entonces, por qu no se pueden rellenar? Bueno, para rellenar la
tarjeta, se tendra que borrar primero con luz ultravioleta, pero a
sabiendas de que las tarjetas estn recubiertas de una resina opaca a
la luz ultravioleta. Incluso si uno llegase a borrar la tarjeta, luego
tendra que programar los datos del fabricante en la zona protegida
contra escritura por un fusible que fue fundido en la misma fbrica de
la tarjeta, despus de que sta fuera programada.

    Sin embargo puede resultar muy interesante estudiar cmo funcionan
estas tarjetas, y ver qu clase de datos contiene y cmo los datos
estn organizados en su interior, o ver cuntas unidades le quedan
libres. Adems, hay un montn de aplicaciones en las que se pueden
usar estas tarjetas (slo para uso personal, por supuesto), ya que se
podran utilizar para abrir puertas, o para proteger un programa,
etc...

    Las tarjetas de Francia fueron credas en 1984, y entonces los
fabricantes decidieron usar tecnologa NMOS, pero ahora estn
plantendose cambiarlas todas a tecnologa CMOS antes de 1994. Adems,
estn pensando incluir circuitos EEPROM para proteger las tarjetas y
aadir una gran cantidad de datos tiles, con los que posiblemente el
usuario acabe comprando el pan cada da, o cualquier otra cosa.

    Estas nuevas tarjetas se denominan tarjetas de Segunda Generacin.


    1.2 - ESQUEMA del microchip:
          ~~~~~~~~~~~~~~~~~~~~~~

                    .-------------------.
                    |                   |
                  --|> Clk              |
                    | _                 |
                  --| R/W               |
                    |                   |
                  --| Reset             |
                    |                   |
                  --| Fusible           |
                    |                   |
                  --| Vpp               |
                    |                   |
                    |                   |
                    '-.               .-'
                      |               |
                    .-------------------.
                    |               Out |-- Salida serie
                    '-------------------'


    1.3 - Atribucin de contactos:
          ~~~~~~~~~~~~~~~~~~~~~~~~



                               CHIP AFNOR
                               ----------
        Posicin Afnor                              Posicin ISO
(en la esquina superior izquierda                (en el medio de la
        de la tarjeta)                         tarjeta a la izquierda)
        
 -------------+-------------                 -------------+-------------
|   8         |         4   |               |   1         |         5   |
|             |             |               |             |             |
+-------\     |     /-------+               +-------\     |     /-------+
|   7    +----+----+    3   |               |   2    +----+    +    6   |
|        |         |        |               |        |         |        |
+--------|         |--------+               +--------|         |--------+
|   6    |         |    2   |               |   3    |         |    7   |
|        +    +----+        |               |        +----+----+        |
+-------/     |     \-------+               +-------/     |     \-------+
|   5         |         1   |               |   4         |         8   |
|             |             |               |             |             |
 -------------+-------------                 -------------+-------------

NB: slo la posicin del chip est normalizada segn ISO, y no la
    atribucin de conectores.

Contactos:     1 : Vcc = 5V        5 : Masa
----------     2 : R/W             6 : Vpp = 21V
               3 : Reloj           7 : I/O
               4 : Reset           8 : Fusible

    1.4 - Caractersticas principales:
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        - Protocolo sncrono.
        - Tecnologa NMOS.
        - Organizacin de 256x1 bits.
        - 96 bits protegidos mediante fusible.
        - 85mW de consumo en modo lectura.
        - Voltaje de programacin 21 V
        - Tiempo de acceso: 500ns
        - Rango trmico de operacin: -10C +70C
        - Retencin de los datos durante diez aos.


    1.5 - Diagramas de temporizaciones:
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+21V                                     _____________
+5V ____________________________________|             |________________ Vpp
                                        :             :
+5V                  ___________________:_____________:________________ Reset
0V  ________________|                   :             :
                    :                   :             :
+5V     ____        :      ____         :       ______:______
0V  ___|    |_______:_____|    |________:______|      :      |_________ Reloj
       :    :       :     :    :        :      :      :      :
+5V    :    :       :     :    :        :______:______:      :           _
0V  ___:____:_______:_____:____:________|      :      |______:_________ R/W
       :    :       :     :    :        :      :      :      :
+5V    :    :       :_____:    :________:      :      :      :_________
0V  XXXXXXXXXXXXXXXXX_____XXXXXX________XXXXXXXXXXXXXXXXXXXXXX_________ Salida
       :    :       :     :    :        :<-----><---->:      :
       :    :       :     :    :        :10 a    10 a        :
       :    :       :     :    :        :50 ms   50ms        :
      Reset de       Bit 1        Bit2                           Bit 3
     la tarjeta     lectura      lectura  Bit2 escribe a 1      lectura



    1.6 - Mapa de memoria de las tarjetas de Francia y Mnaco:
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Bytes       Bits      Binario     Hex

                    +-----------+-----+
  1        1 --> 8  |           |     | ---> Cdigo fabricante [TBC]
                    +-----------+-----+
  2       9 --> 16  | 0000 0011 | $03 | ---> Tarjeta francesa
                    | 0000 0100 | $04 |
                    | 0000 0101 | $05 |
                    +-----------+-----+
  3      17 --> 24  |           |     |
                    +-----------+-----+
  4      25 --> 32  |           |     |
                    +-----------+-----+
  5      33 --> 40  |           |     |
                    +-----------+-----+
  6      41 --> 48  |           |     |
                    +-----------+-----+
  7      49 --> 56  |           |     |
                    +-----------+-----+
  8      57 --> 64  |           |     |
                    +-----------+-----+
  9      65 --> 72  |           |     |
                    +-----------+-----+
 10      73 --> 80  |           |     |
                    +-----------+-----+
 11      81 --> 88  | 0001 0000 | $10 |
                    +-----------+-----+
 12      33 --> 40  | 0001 0011 | $13 | ---> Tarjeta de 120 unidades
                    | 0000 0110 | $06 | ---> Tarjeta de  50 unidades
                    | 0000 0101 | $05 | ---> Tarjeta de  40 unidades
                    +-----------+-----+
 13-31  97 --> 248  |           |     | ---> El rea de unidades: cada
                    |           |     |      vez que se usa una unidad,
                    |           |     |      un bit se escribe a "1".
                    |           |     |      Normalmente, las primeras
                    |           |     |      diez unidades se escriben
                    |           |     |      de fbrica a modo de test.
                    |           |     |
                    +-----------+-----+
 32    249 --> 256  | 1111 1111 | $FF | ---> La tarjeta est vaca.
                    +-----------+-----+


    1.7 - Mapa de memoria para las tarjetas de Andora, Repblica Checa,
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          Finlandia, Gabn, Irlanda, Noruega, Portugal, Suecia,
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          Luxemburgo:
          ~~~~~~~~~~~

Bytes       Bits      Binario     Hex

                    +-----------+-----+                            96
  1        1 --> 8  |           |     | ---> Checksum Byte = 216 -  b(i)
                    +-----------+-----+                            i=9
  2       9 --> 16  | 1000 0011 | $83 | ---> Tarjeta prepago
                    +-----------+-----+-----------+-----+
3-4      17 --> 32  | 1000 0000 | $10 | 0001 0010 | $12 | --->  10u
                    |           |     | 0010 0100 | $24 | --->  22u
                    |           |     | 0010 0111 | $27 | --->  25u
                    |           |     | 0011 0010 | $32 | --->  30u
                    |           |     | 0101 0010 | $52 | --->  50u
                    |           |     | 0110 0010 | $62 | --->  60u
                    |           |     | 0111 0111 | $77 | --->  75u
                    |           |     | 1000 0010 | $82 | --->  80u
                    | 0001 0001 | $11 | 0000 0010 | $02 | ---> 100u
                    |           |     | 0010 0010 | $22 | ---> 120u
                    |           |     | 0101 0010 | $52 | ---> 150u
                    +-----------+-----+-----------+-----+
  5      33 --> 40  | 0000 0000 | $00 | ---> Schlumberger
                    | 0100 0000 | $40 | ---> Gemplus
                    +-----------+-----+
  6      41 --> 48  |           |     |
  7      49 --> 56  |           |     |
  8      57 --> 64  |           |     | ---> Nmero de serie
  9      65 --> 72  |           |     |
 10      73 --> 80  |           |     |
                    +-----------+-----+
 11      81 --> 88  | 0001 0001 | $11 | ---> [TBC]
                    +-----------+-----+
 12      89 --> 96  | 0001 1101 | $1D | ---> French Cincarte [TBC]
                    | 0001 1110 | $1E | ---> Suecia
                    | 0010 0100 | $24 | ---> Mexico [TBC]
                    | 0011 0000 | $30 | ---> Noruega
                    | 0011 0011 | $33 | ---> Andorra
                    | 0011 1001 | $39 | ---> Luxemburgo
                    | 0011 1100 | $3C | ---> Irlanda
                    | 0100 0111 | $47 | ---> Portugal
                    | 0101 0101 | $55 | ---> Repblica Checa/Yugoslavia [TBC]
                    | 0101 1111 | $5F | ---> Gabn
                    | 0110 0101 | $65 | ---> Finlandia
                    +-----------+-----+
 13-31  97 --> 248  |           |     | ---> El rea de unidades: cada
                    |           |     |      vez que se usa una unidad,
                    |           |     |      un bit se escribe a "1".
                    |           |     |      Normalmente, las primeras
                    |           |     |      dos unidades se escriben
                    |           |     |      de fabrica a modo de test.
                    |           |     |
                    +-----------+-----+
 32    249 --> 256  | 0000 0000 | $00 |
                    +-----------+-----+


    1.8 - Mapa de memoria para las tarjetas de Espaa, Croacia:
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Bytes       Bits       Binario    Hex

                    +-----------+-----+                            96
  1        1 --> 8  |           |     | ---> Checksum Byte = 216 -  b(i)
                    +-----------+-----+                            i=9
  2       9 --> 16  | 1000 0011 | $83 | ---> Tarjeta prepago
                    +-----------+-----+
  3      17 --> 24  | 1111 1111 | $FF | [TBC]
                    +-----------+-----+
  4      25 --> 32  | 1111 1111 | $FF | [TBC]
                    +-----------+-----+
  5      33 --> 40  |           | $90 | ---> Oberthur (chip builder)
                    |           | $30 | ---> G+D
                    +-----------+-----+
  6      41 --> 48  |           |     |
  7      49 --> 56  |           |     | ---> Nmero de serie
  8      57 --> 64  |           |     |
                    +-----------+-----+-----------+-----+
9-10     65 --> 80  | 0001 0100 | $14 | 1000 1010 | $8A | ---> 1000 pesetas
                    | 0010 0101 | $25 | 0000 0100 | $04 | ---> 2000 pesetas
                    | 0010 0101 | $25 | 0000 0110 | $06 | ---> 2100 pesetas
                    +-----------+-----+-----------+-----+
 11      81 --> 88  | 0001 1110 | $1E |
                    +-----------+-----+
 12      89 --> 96  | 0010 0010 | $22 | ---> Espaa
                    | 0010 0110 | $26 | ---> Croacia
                    +-----------+-----+
 13      97 --> 104 | 1111 1111 | $FF | ---> Las primeras diez unidades
                    | 11xx xxxx | $xx |      se escriben de fbrica a
                    | xxxx xxxx | $xx |      modo de test.
                    | xxxx xxxx | $xx | ---> Area de contador lento.
                    | xxxx xxxx | $xx |
                    +-----------+-----+
                    | xxxx xxxx | $xx |
                    | xxxx xxxx | $xx | ---> Area de contador rpido.
 32    249 --> 256  | xxxx xxxx | $xx |
                    +-----------+-----+

    El rea de contador lento:
    --------------------------
        - Incremento: cuenta las unidades en pasos de 5 pesetas
        - Tamao:
                 * [b107 ... b206] para tarjetas de 1000 pesetas
                 * [b127 ... b166] para tarjetas de 2000 pesetas
                 * [b107 ... b166] para tarjetas de 2100 pesetas

    El rea de contador rpido:
    ---------------------------
        - Incremento: cuenta las unidades en pasos de
                 * 10 pesetas para las tarjetas de 1000 pesetas
                 * 20 pesetas para las tarjetas de 2000 pesetas
                 * 20 pesetas para las tarjetas de 2100 pesetas

        - Tamao:
                 * [b207 ... b256] para las tarjetas de 1000 pesetas
                 * [b167 ... b256] para las tarjetas de 2000 pesetas
                 * [b167 ... b256] para las tarjetas de 2100 pesetas

    Ejemplo de una rea de rontador rpido: (tarjeta de 1000 pesetas)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 00
          0000 0000
          0000 0000
          0000 0000
          0000 0000
          0011 1110 ---> Se han usado 14*10 pesetas
          1000 1110

     NB: Varias unidades se pueden usar: en este caso slo la ltima
         unidad se marcara como usada, como en el ejemplo anterior,
         donde algunas unidades estn marcadas con "0", pero sin
         embargo se cuentan como usadas.



II ) Las tarjetas de ODS, Giesecke & Devrient, ORGA Karten systeme,
     ==============================================================
     Uniqua, Gemplus, Schlumberger y Oldenbourg Kartensysteme:
     =========================================================

    2.1 - Introduccin:
          ~~~~~~~~~~~~
        Estas tarjetas son de hecho memorias NMOS de 128 bits, y el
    mapa de dichas memorias es de la siguiente manera:

               Area EPROM protegida de 64 bits (zona del fabricante).
               Area EEPROM de 40 bits (5x8 bits).
               Area de 24 bits marcados a "1".


    2.2 - Contactos:
          ~~~~~~~~~~

           ISO 7816-2

 ,-------------+-------------,
 |   1         |         5   |        Contactos:
 |             |             |        ----------
 +-------\     |     /-------+
 |   2    +----+    +    6   |          1 : Vcc = 5V    5 : Masa
 |        |         |        |          2 : Reset       6 : n.c.
 +--------|         |--------+          3 : Reloj       7 : I/O
 |   3    |         |    7   |          4 : n.c.        8 : n.c.
 |        +----+----+        |
 +-------/     |     \-------+      n.c. : no conectado
 |   4         |         8   |
 |             |             |
 '-------------+-------------'


    2.3 - Caractersticas principales:
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        - Compatible ISO 7816-1 e ISO 7816-2.
        - Usa slo una fuente de alimentacin de 5V
        - Bajo consumo
        - Tecnologa NMOS.

    2.4 - Diagramas de temporizacin:
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~

Inicializacin:
---------------

    El contador de direcciones se inicializa a 0 cuando la seal de
reloj CLK se activa, y la lnea de control R est alta ("1" lgico).
Nota: el contador de direcciones no puede ser inicializado mientras
contenga los valores 0 a 7.

      __________________
_____|                  |_____________________________________________ Reset
     :                  :
     :        _____     :  _____       _____       _____       _____
_____:_______|     |____:_|     |_____|     |_____|     |_____|     |_ Reloj
     :       :          : :     :     :     :     :     :     :     :
_____:_______:__________:_:_____:_____:_____:_____:_____:_____:_____:_
_____:___n___|_____0____:_|_____1_____|_____2_____|_____3_____|___4_:_ (Dir.)
     :                  :       :           :           :           :
_____:                  :_______:___________:___________:___________:_
_____XXXXXXXXXXXXXXXXXXXX_______|___________|___________|___________|_ Datos
Bit n                      Bit 0    Bit 1       Bit 2       Bit 3

    El contador de direcciones se incrementa en 1 con cada inicio de
pulso de la seal de reloj CLK, mientras la lnea de control R
permanezca baja ("0" lgico). El dato contenido en el bit al que se
apunta aparece en el contacto de entrada/salida (I/O) cada vez que la
seal de reloj cae (transicin "1" a "0"). Por lo tanto, es imposible
disminuir el contenido del contador de direccin para apuntar a un bit
anterior: el contador debe ser inicializado y despus incrementado
hasta obtener el dato requerido.


Escritura:
----------

    Se puede escribir en todos los bits del 64 al 104 que estn
vrgenes o borrados. Cuando se escribe un dato en una posicin de
memoria, se marca un "0" en dicha posicin. La siguiente secuencia
describe el mecanismo de escritura:

1 - La seal R se activa mientras la seal de reloj CLK permanece
    inhibida ("0" lgico), para desactivar el incremento de contador
    de direcciones durante un pulso de reloj.

2 - La seal CLK se activa durante 10 ms por lo menos, para escribir
    el bit de la direccin de memoria.

    Cuando la operacin de escritura acaba, y la seal CLK baja, el
contador de direccin se desbloquea, y el contenido de la direccin de
memoria que se acaba de escribir, que debera ser "0", se muestra en
el contacto de entrada/salida (I/O), para ser verificado.

    El siguiente pulso de reloj aumentar el contenido del registro de
direccin una unidad, y la secuencia de grabacin puede repetirse para
el siguiente bit.


             _____                               _____
____________|     |_____________________________|     |______________  Reset
            :                                   :
    ___     :          _____           ___      :          _____
___|   |____:_________|     |_________|   |_____:_________|     |____  Reloj
   :        :         :     :         :   :     :         :     :
___:________:_________:_____:_________:___:_____:_________:_____:_____
 n |      n+1         |     n+2       |   :    n+3        |     :      (Dir.)
---'--------:---------'-----:---------'---:-----:---------'-----:-----
            :         :     :             :     :         :     :
________   _:         :     : ____________:  ___:         :     :
________XXX_XXXXXXXXXXXXXXXXXX____________ XX___XXXXXXXXXXXXXXXXXXXXXX  I/O
  n      n+1          :     :     n+1        n+2          :     :
                      :     :                             :     :
                     escritura                           escritura


La secuencia WriteCarry:
------------------------

    Esta secuencia se usa para borrar un contador, cuando el contador
de direccin contiene la direccin del bit inmediatamente anterior a
la del contador a ser borrado. La secuencia WriteCarry procede de la
siguiente manera:

1 - El contador de direccin contiene la direccin del bit (no
    escrito) en la fase inmediatamente superior a la que va a ser
    borrada.

2 - La seal R se activa para inhibir el incremento del contador de
    direccin, mientras la seal de reloj CLK permanezca baja.

3 - La seal CLK se activa durante un mnimo de 10ms, mientras R
    permanezca inhibida, para escribir (un "0") en el bit de la
    direccin de memoria.

4 - R se activa una segunda vez para inhibir de nuevo el incremento
    del contador de direccin.

5 - A continuacin, CLK se activa durante un mnimo de 1ms mientras R
    permanece baja, para escribir en el bit de la direccin de
    memoria, borrando as el nivel de contador inmediatamente inferior
    al bit de direccin de memoria.

      _____                     _____
_____|     |___________________|     |________________________________  Rst
     :                         :
     :           _______       :              _______        ___
_____:__________|       |______:____________|       |______|   |______  Reloj
     :          :       :      :            :       :      :   :
     :          :       :      :            :       :      :   :
<----------------------- address n ----------------------->:<--- n+1 ------
     :          :       :      :            :       :          :
     :          :       :      :            :       :          :
_____:          :       :______:            :       :__________: _____
_____XXXXXXXXXXXXXXXXXXXX______XXXXXXXXXXXXXXXXXXXXXX__________XX_____  I/O
                :       :  n                :       :     n        n+1
                :       :                   :       :
                  Write                       Erase

     2.5 - Mapa de memoria:
           ~~~~~~~~~~~~~~~~

      2.5.1 - Mapa de memoria para el contador octal de 5 fases:
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Bytes       Bits      Binario     Hex

                    +-----------+-----+
  1       1 -->   8 |           | $F4 | ---> Alemania
                    |           | $80 |
                    + - - - - - + - - +
                    | 0001 0000 | $10 | ---> Rumana [TBC]
                    +-----------+-----+
  2       9 -->  16 | 0010 1011 | $2B | ---> Rumana [TBC]
                    + - - - - - + - - +
                    | 0010 1111 | $2F | ---> Alemania
                    | 0110 1111 | $6F |
                    + - - - - - + - - +
                    | 0011 0111 | $37 | ---> Holanda
                    +-----------+-----+
  3      17 -->  24 | 1111 1111 | $FF | ---> Alemania, Holanda
                    | 0010 1111 | $2F | ---> Rumana [TBC]
                    +-----------+-----+
  4      25 -->  32 |           | $2A | ---> Solaic
                    |           | $4A | ---> ODS
                    |           | $8A | ---> G+D
                    |           | $CA | ---> Gemplus
                    +-----------+-----+
  5      33 -->  40 |           |     |
  6      41 -->  48 |           |     | ---> Area de entidad emisora
  7      49 -->  56 |           |     |      (protegida frente a
  8      57 -->  64 |           |     |       escritura)
                    +-----------+-----+
  9      65 -->  72 |           |     | ---> c4096  )
 10      73 -->  80 |           |     | --->  c512  )
 11      81 -->  88 |           |     | --->   c64  ) Contador octal 
 12      89 -->  96 |           |     | --->    c8  ) de 5 fases
 13      97 --> 104 |           |     | --->    c0  )
                    +-----------+-----+
 14     105 --> 112 | 1111 1111 | $FF |
 15     113 --> 120 | 1111 1111 | $FF | ---> Area de bits marcados "1"
 16     120 --> 128 | 1111 1111 | $FF |
                    +-----------+-----+


      2.5.2 - Mapa de memoria para el contador octal de 4 fases:
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Bytes       Bits      Binario     Hex

                    +-----------+-----+
  1       1 -->   8 |           | $94 | ---> Grecia
                    |           | $92 |
                    +-----------+-----+
  2       9 -->  16 | 0011 1011 | $3B | ---> Grecia
                    +-----------+-----+
  3      17 -->  24 | 1111 1111 | $FF |
                    +-----------+-----+
  4      25 -->  32 |           |     |
  5      33 -->  40 |           |     |
  6      41 -->  48 |           |     | ---> Nmero de serie
  7      49 -->  56 |           |     |
  8      57 -->  64 |           |     |
                    +-----------+-----+
  9      65 -->  72 |           |     | ---> c512 )
 10      73 -->  80 |           |     | --->  c64 )
 11      81 -->  88 |           |     | --->   c8 ) Contador octal
 12      89 -->  96 |           |     | --->   c0 ) de 4 fases
                    +-----------+-----+
 13      97 --> 104 | 1111 1111 | $FF |
 14     105 --> 112 | 1111 1111 | $FF |
 15     113 --> 120 | 1111 1111 | $FF | ---> Area de bits marcados "1"
 16     120 --> 128 | 1111 1111 | $FF |
                    +-----------+-----+

El rea de la entidad emisora:
------------------------------

    Esta rea consiste de 40 bits. El contenido lo especifica la
entidad emisora de la tarjeta al fabricante de la misma, que graba los
datos de forma indeleble durante el proceso de fabricacin de la
tarjeta. En esta zona se incluyen datos como nmeros de serie, fechas
y centros de distribucin.

    Esta zona es de slo lectura.

La zona de contador:
--------------------

    La zona del contador almacena las unidades de crdito de la
tarjeta. Su valor inicial lo fija la entidad emisora de la tarjeta y
tambin se graba durante el proceso de fabricacin.

    La zona del contador se divide en un contador de baco de cinco o
cuatro fases. El valor octal de cada fase se define como el nmero de
bits "1", multiplicado por el coeficiente 8^n, donde n est entre 4 y
0 o entre 3 y 0.

      Ejemplo: Un contador octal de 5 fases con 15818 unidades restantes.
      --------

             Byte9      Byte10     Byte11     Byte12     Byte13
    --------------------------------------------------------------
            00000111 - 00111111 - 01111111 - 00000001 - 00000011
    --------------------------------------------------------------
            octal(3)   octal(6)   octal(7)   octal(1)   octal(2)
    --------------------------------------------------------------
     Valor = 3*8^4   +  6*8^3   +  7*8^2   +  1*8^1   +  2*8^0
    --------------------------------------------------------------
     TOTAL = 15818 Unidades


Nota: Slo se puede reducir el valor del contador, y no est permitido
~~~~~ escribir en l un valor mayor al valor antiguo.

NB: De hecho, la mayora de las unidades de la tarjeta no representan
    pasos de cobro del sistema de telecomunicacin, sino unidades
    monetarias. Por ejemplo, en Alemania cada paso cuesta 30 pfennigs.


    2.6 - Caractersticas elctricas:
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~

Valores lmite:
---------------

                       +--------+------+------+------+
                       |Smbolo | Min  |  Max | Uni. |
+----------------------+--------+------+------+------+
| Voltaje aliment.     |   Vcc  | -0.3 |    6 |   V  |
+----------------------+--------+------+------+------+
| Tensin de entrada   |   Vss  | -0.3 |    6 |   V  |
+----------------------+--------+------+------+------+
| Temp. almacenamiento |  Tstg  |  -20 |  +55 |  C  |
+----------------------+--------+------+------+------+
| Disipacin           |    Pd  |   -  |   50 |  mW  |
+----------------------+--------+------+------+------+


Caractersticas DC:
-------------------
                              +--------+-----+-----+-----+------+
                              |Smbolo | Min.| Tip.| Max.| Uni. |
+-----------------------------+--------+-----+-----+-----+------+
| Corriente alimentacin      |   Icc  |  -  |  -  |   5 |   mA |
+-----------------------------+--------+-----+-----+-----+------+
| Tensin entrada (baja)      |    Vl  |   0 |  -  | 0.8 |    V |
+-----------------------------+--------+-----+-----+-----+------+
| Tensin entrada (alta)      |    Vh  | 3.5 |  -  | Vcc |    V |
+-----------------------------+--------+-----+-----+-----+------+
| Corriente de entrada R      |    Ih  |  -  |  -  | 100 |   uA |
+-----------------------------+--------+-----+-----+-----+------+
| Corriente de entrada CLK    |    Il  |  -  |  -  | 100 |   uA |
+-----------------------------+--------+-----+-----+-----+------+
| Corriente salida (Vol=0.5V) |   Iol  |  -  |  -  |  10 |   uA |
+-----------------------------+--------+-----+-----+-----+------+
| Corriente salida (Voh=5V)   |   Ioh  |  -  |  -  | 0.5 |   mA |
+-----------------------------+--------+-----+-----+-----+------+

Caractersticas AC:
-------------------    +--------+------+------+------+
                       |Smbolo | Min. | Max. | Uni. |
+----------------------+--------+------+------+------+
| Duracin pulso       |    tr  |   50 |   -  |  us  |
| R direccin reset    |        |      |      |      |
+----------------------+--------+------+------+------+
| Duracin pulso       |    ts  |   10 |   -  |  us  |
| R escritura          |        |      |      |      |
+----------------------+--------+------+------+------+
| CLK alto             |    th  |    8 |   -  |  us  |
+----------------------+--------+------+------+------+
| CLK bajo             |    tl  |   12 |   -  |  us  |
+----------------------+--------+------+------+------+
| Ventana escritura    | Twrite |   10 |   -  |  ms  |
+----------------------+--------+------+------+------+
| Ventana borrado      | Terase |   10 |   -  |  ms  |
+----------------------+--------+------+------+------+
|                      |   tv1  |    5 |   -  |  us  |
+----------------------+--------+------+------+------+
|                      |   tv2  |  3.5 |   -  |  us  |
+----------------------+--------+------+------+------+
|                      |   tv3  |  3.5 |   -  |  us  |
+----------------------+--------+------+------+------+
|                      |   tv4  |  3.5 |   -  |  us  |
+----------------------+--------+------+------+------+
|                      |   tv5  |  3.5 |   -  |  us  |
+----------------------+--------+------+------+------+
|                      |   tv6  |    5 |   -  |  us  |
+----------------------+--------+------+------+------+
|                      |   tv7  |    5 |   -  |  us  |
+----------------------+--------+------+------+------+
|                      |   tv8  |   10 |   -  |  us  |
+----------------------+--------+------+------+------+



III) Esquemas de lectores:
    ======================

     3.1 - Lector 1:
           ~~~~~~~~~

   5V Externos (Opcional)

5V o------,
          |                 /             T2  PNP      d13  r7 10
0V o--,   |                /               BC 177     |\ |  _____
      |   |      ,-------o/   o--*------. E      C .--| >+-[_____]--------,
    __+__ |      |               |       \        /   |/ |                |
    \\\\\ |    __|__ Batera     |         \    /                         |
          |      -   22.5V       |       ---------                        |
.......   |      |               |   _____   |   _____                    |
       :  |    __+__             +--[_____]--*--[_____]--,                |
   D2  :  |    \\\\\                r6 150k     r5 15k   |                |
4 o-------|---------------------------*------------------|-------------,  |
       :  |                           |   r3 220k       / C            |  |
   Ack :  |                           |   _____      |/    T1 - NPN    |  |
10 o------|--------.                  '--[_____]-*---|      BC107      |  |
       :  |        |                      _____  |   |\                |  |
       : ,-,      ,-,                 +--[_____]-'      \ E            |  |
       : | |r2    | |r1               |  r4 390k         |             |  |
       : | |220   | |22k            __+__              __+__           |  |
       : |_|      |_|               \\\\\              \\\\\           |  |
       :  |  |\ |  |                                                   |  |
       :  *--| >+--|----------------*----------------------------------|--*
       :  |  |/ |  |          ,-----|-----------------------------,    |  |
       :  |  d1    |          |     |   ,----------,----------,   |    |  |
       :  |        |          |     *---|-*(8) Fus.| Rst (4)*-|---'    |  |
       :  |        |          |     |   |----------|----------|        |  |
   D0  :  |        |          |   ,-|---|-*(7) I/O | Clk (3)*-|---,    |  |
2 o-------|--------|----------'   | |   |----------|----------|   |    |  |
       :  |        |              | '---|-*(6) Vpp | R/W (2)*-|---|----'  |
  Busy :  |        |              |     |----------|----------|   |       |
11 o------|--------|--------------' ,---|-*(5) Gnd | 5V  (1)* |   |       |
       :  |        |                |   '----------'--------|-'   |       |
   D1  :  |        |              __+__    Conector chip    |     |       |
3 o-------|--------|--------,     \\\\\                     |     |       |
       :  |        |        '-------------------------------|-----'       |
  Str  :  |  |\ |  |                                        |             |
1 o-------*--| >+--*----*----*----*----*--------------------'             |
       :   d2|/ |  |d3  |d4  |d5  |d6  |d7                                |
       :          -+-  -+-  -+-  -+-  -+-                                 |
       :          /_\  /_\  /_\  /_\  /_\                                 |
   D3  :           |    |    |    |    |   |\ | d8                        |
5 o----------------*----|----|----|----|---| >+-------*-------------------'
       :                |    |    |    |   |/ |       |
       :                |    |    |    |              |
   D4  :                |    |    |    |   |\ | d9    |
6 o---------------------*----|----|----|---| >+-------*
       :                     |    |    |   |/ |       |
       :                     |    |    |              |
   D5  :                     |    |    |   |\ | d10   |
7 o--------------------------*----|----|---| >+-------*
       :                          |    |   |/ |       |
       :                          |    |              |
   D6  :                          |    |   |\ | d11   |
8 o-------------------------------*----|---| >+-------*
       :                               |   |/ |       |
       :                               |              |
   D7  :                               |   |\ | d12   |
9 o------------------------------------*---| >+-------'
       :                                   |/ |
       :
       :
25 o------.
       :  |
.......:  |                                 d1 a d13: 1N4148
        __+__
        \\\\\

Puerto Centronics


     3.2 - Lector 2:
           ~~~~~~~~~

                                                           Zener 3.3V
              2x1N4001         ________           /    150ohms
           |\ |     |\ |      |        |         /    _____  | /|        (6)
o----,  ,--+ >+--*--+ >+--*---+  7824  +----*--o/  o-|_____|-+< +-*----o Vpp
     |  |  |/ |  |  |/ |  |   |________|    |                | \| |
     )||(  220uF |  220uF |        |      ===== 0.22uF           _+_
220V )||(    25V | +  40V | +      |        |                    / \  1N4148
     )||(      =====    =====    __+__    __+__                 '-+-'
 ~   )||(        | -      | -    \\\\\    \\\\\                  ,+,
     |  |   ___  |        |                                      | | 12ohms
o----'  '--o   o-*      __+__                                    | |
        presencia|      \\\\\  ________                          '+'   12ohms
         tarjeta |  |\ |      |        |                          |   _____    (1)
                 '--+ >+------+  7805  +------*-------------------*--|_____|-o Vcc
                    |/ |      |________|      |                   |
                   1N4001          |         _+_                  |
                                   |         \ / --->            ,+,
                                 __+__       -+-  --->           | |
                                 \\\\\        |                  | | 4.7kohms
                                             ,+,                 '+'
                                             | |                  |            (7)
                                             | | 680ohms          *----------o I/O
                                             '+'                  |
                                              |         Busy (11) o
                                              |                                (4)
                                            __+__         D0 (2)  o-----*----o Raz
                                            \\\\\                       |
                                                              4.7nF   =====
                                                                        |
                                                                      __+__
                                                                      \\\\\    (3)
                                                          D1 (3)  o----------o Clk

                                                                               (2)
                                                          D2 (4)  o----------o  W


                                                         Gnd (25) o
                                                                  |
                                                                  | fusible    (8)
                                                                  *--~~~~~---o Fus
                                                                __+__
                                                                \\\\\


IV) El programa:
    ============

    El siguiente programa permite la lectura de las tarjetas de
microchip usando un PC, si se usa el lector 1 descrito anteriormente.

--------------- cortar aqu (comienzo)
(*****************************************************************************)
(*                            T E L E C A R D . PAS                          *)
(*****************************************************************************)
(* Este programa recoge el contenido de la memoria de las tarjetas de        *)
(*                         128 o 256 bits.                                   *)
(*****************************************************************************)
(*                                                                           *)
(*  Escrito por Stephane BAUSSON (1993, 1994, 1995)                          *)
(*                                                                           *)
(*    4, Rue de Grand                                                        *)
(*    F-88630 CHERMISEY                                                      *)
(*    Francia                                                                *)
(*---------------------------------------------------------------------------*)
(* Versin 2.03 (Ultima revisin: 18-05-1995)                                *)
(*---------------------------------------------------------------------------*)
(* Esquema del lector:                                                         *)
(*                                                                           *)
(*                     5V                                                    *)
(*    Puerto           |     ,-------------+-------------,                   *)
(*  Centronics         '-----|   1         |         5   |------,            *)
(*           R/W | RST       +-------\     |     /-------+      |            *)
(*   Pin 4  -->--------------|   2    +----+    +    6   |      |            *)
(*           Reloj           +--------|         |--------+      |            *)
(*   Pin 3  -->--------------|   3    +----+----+    7   |---,  |            *)
(*           RAZ | RFU       +-------/     |     \-------+   |  |            *)
(*   Pin 2  -->--------------|   4         |         8   |   |  |            *)
(*                           '-------------+-------------'   |  |            *)
(*           I/O                                             |  |            *)
(*   Pin 15 --<----------------------------------------------'  |            *)
(*           Masa                                               |            *)
(*   Pin 25 ----------------------------------------------------'            *)
(*                                                                           *)
(*****************************************************************************)

USES crt,dos;                (* Unidades includas *)

CONST port_address=$378;     (* Selecciona puerto de impresora 1 *)

TYPE string8=string[8];
     string2=string[2];

VAR reg         : registers;
    i,j         : integer;
    Data        : array[1..32] of byte;
    Bin         : string;
    car         : char;
    byte_number : integer;
    displaying  : char;
    saving      : boolean;
    SavingFile  : TEXT;
    FileName    : string[30];

{-----------------------------------------------------------------------------}
{ PROCEDURE Send(b:byte);                                                     }
{                                                                             }
{       - Enva un byte al puerto de impresora seleccionado.                  }
{-----------------------------------------------------------------------------}

PROCEDURE Send(b:byte);

  BEGIN port[port_address]:=b;
  END;

{----------------------------------------------------------------------------}
{ FUNCTION Get:byte;                                                          }
{                                                                             }
{       - Recoge un byte del registro de status del puerto de impresora       }
{         seleccionado.                                                       }
{-----------------------------------------------------------------------------}

FUNCTION Get:byte;

  BEGIN get:=port[port_address+1];
  END;

{-----------------------------------------------------------------------------}
{ FUNCTION dec2hexa_one(decimal_value):hexa_character_representation;         }
{                                                                             }
{       - Convierte un decimal de 4 bits a hexadecimal.                       }
{-----------------------------------------------------------------------------}

FUNCTION dec2hexa(value:byte):char;

  BEGIN case value of
          0..9   : dec2hexa:=chr(value+$30);
          10..15 : dec2hexa:=chr(value+$37);
        END;
  END;

{-----------------------------------------------------------------------------}
{ FUNCTION d2h(decimal_byte):string2;                                         }
{                                                                             }
{       - Convierte un byte decimal a su representacin hexadecimal.          }
{-----------------------------------------------------------------------------}

FUNCTION d2h(value:byte):string2;

  BEGIN d2h:=dec2hexa(value div $10) + dec2hexa(value and $0F);
  END;

{-----------------------------------------------------------------------------}
{ FUNCTION Binary(byte):string8;                                              }
{                                                                             }
{       - Convierte un byte a su representacin binaria.                      }
{-----------------------------------------------------------------------------}

FUNCTION Binary( b : byte):string8;

  VAR weigth : byte;
      s      : string8;

  BEGIN weigth:=$80;
        s:='';
        while (weigth > 0) do
        BEGIN if ((b and weigth) = weigth) then s:=s+'1'
              else s:=s+'0';
              weigth:=weigth div $02;
        END;
        Binary:=s;
  END;

{-----------------------------------------------------------------------------}

FUNCTION Units:byte;

  VAR  u, i, j : integer;
       s       : string8;

  BEGIN u:=0;
        i:=13;
        while (Data[i] = $FF) do
        BEGIN u:=u+8;
              i:=i+1;
        END;

        s:=Binary(Data[i]);
        for j:=1 to 8 do if s[j]='1' then inc(u);
        units:=u;
  END;

{-----------------------------------------------------------------------------}

FUNCTION BitCount( Data : integer ):integer;

  VAR    i : integer;

  BEGIN i:=0;
        while ((Data and $01)=$01) do
        BEGIN Data:=Data div 2;
              inc(i);
        END;
        BitCount:=i;
  END;

{-----------------------------------------------------------------------------}

FUNCTION Five_Stage_Octal_Count:LongInt;

  BEGIN Five_Stage_Octal_Count:=
           4096*BitCount(Data[9])+512*BitCount(Data[10])+64*BitCount(Data[11])
           +8*BitCount(Data[12])+BitCount(Data[13]);
  END;

{-----------------------------------------------------------------------------}

FUNCTION Four_Stage_Octal_Count:LongInt;

  BEGIN Four_Stage_Octal_Count:=
            512*BitCount(Data[9])+64*BitCount(Data[10])+8*BitCount(Data[11])
            +BitCount(Data[12]);
  END;

{-----------------------------------------------------------------------------}

FUNCTION Spanish_Units( units:word ) : word;

  VAR init : word;
      long : word;
      step : word;
      value: word;

  BEGIN case units of
             $148A: BEGIN init:=107; long:=100; step:=10;
                    END;
             $2504: BEGIN init:=127; long:=40; step:=20;
                    END;
             $2506: BEGIN init:=107; long:=60; step:=20;
                    END;
        END;

        value:=0;
        i:=init;

        while (Bin[i]='0') and (i < init+long) do
        BEGIN inc(i);
              value:=value+5;
        END;

        i:=init+long;

        while (Bin[i]='0') and (i < 256) do
        BEGIN inc(i);
              value:=value+step;
        END;

        Spanish_Units:=value;
  END;

{-----------------------------------------------------------------------------}

function checksum:byte;

  var i, sum : byte;

  begin sum:=0;
        for i:=9 to 96 do if bin[i]='1' then inc(sum);
        CheckSum:=Sum;
  end;

{-----------------------------------------------------------------------------}

PROCEDURE Card_Type;

  VAR s : string;
      u : word;

  BEGIN case Data[2] of

         (*--------------------*)
         (* Tarjetas francesas *)
         (*--------------------*)
         $03, $04, $05 :
           BEGIN write('Telecard / Francia / ');
                 case Data[12] of
                   $13: write('120u / ',130 unidades,'u restantes');
                   $06: write('50u / ',60 unidades,'u restantes');
                   $05: write('40u / ',50 unidades,'u restantes');
                 END;
           END;

         (*------------------*)
         (* Tarjetas rumanas *)
         (*------------------*)
         $2B:write('Telecard / Rumana / ',Five_Stage_Octal_Count,' Unidades restantes');

         (*-------------------*)
         (* Tarjetas alemanas *)
         (*-------------------*)
         $2F, $6F:
         BEGIN
               write('Telecard / Alemania / ',Five_Stage_Octal_Count,
                     ' Pfennigs restantes');
               write(' / fabricante: ');
               case data[4] of
                 $2A:write('Solaic');
                 $4A:write('ODS');
                 $8A:write('G+D');
                 $CA:write('Gemplus');
                 else write('desconocido');
               end;
(*               write(' ',data[5],' ',data[6],' ',data[7],' ',data[8]);*)
         END;

         (*---------------------*)
         (* Tarjetas holandesas *)
         (*---------------------*)
         $37:write('Telecard / Holanda / ',Five_Stage_Octal_Count,
                   ' Unidades restantes');

         (*------------------*)
         (* Tarjetas griegas *)
         (*------------------*)
         $3B:write('Telecard / Grecia / ', Four_Stage_Octal_Count div 2,'u restantes');

         $83:BEGIN write('Telecard / ');
                   case Data[12] of
                     $1E: write('Suecia');
                     $22: write('Espaa');
                     $30: write('Noruega');
                     $33: write('Andorra');
                     $39: write('Luxemburgo');
                     $3C: write('Irlanda');
                     $47: write('Portugal');
                     $55: write('Repblica Checa');
                     $5F: write('Gabn');
                     $65: write('Finlandia');
                   END;

                   case Data[12] of
                        $1E,$30,$33,$39,$3C,$47,$55,$5F,$65:
                        BEGIN write(' / ');
                              case ((Data[3] and $0F)*$100+Data[4]) of
                                   $012: write('10u / ',12-unidades);
                                   $024: write('22u / ',24-unidades);
                                   $027: write('25u / ',27-unidades);
                                   $032: write('30u / ',32-unidades);
                                   $052: write('50u / ',52-unidades);
                                   $067: write('65u / ',67-unidades);
                                   $070: write('70u / ',72-unidades);
                                   $077: write('75u / ',77-unidades);
                                   $102: write('100u / ',102-unidades);
                                   $152: write('150u /  ',152-unidades);
                              END;
                              write('u restantes');
                              write(' / chk:',d2h(216-CheckSum));
                              case data[5] of
                                $00:write(' / Schlumberger');
                                $40:write(' / Gemplus');
                              end;
                        END;

                        (*--------------------*)
                        (* Tarjetas espaolas *)
                        (*--------------------*)
                        $22:
                        BEGIN u:=Data[9]*$100+Data[10];
                              case u of
                                   $148A: write(' 1000 pesetas');
                                   $2504: write(' 2000 pesetas');
                                   $2506: write(' 2100 pesetas');
                              END;
                              write(' / ',Spanish_Units(u),'u restantes');
                              write(' / ');
                              case data[5] of
                                $30:write('C');
                                $90:write('B');
                              end;
                              write(' ',data[6]*$10000+data[7]*$100+data[8]);
                              write(' / chk:',d2h(216-checksum));
                        END;

                   END; (* case Data[12] *)
             END; (* $83 *)
        END; (* case Data[2] *)
  END;

{-----------------------------------------------------------------------------}

PROCEDURE waiting;

  BEGIN send($00);
        write('Inserte una tarjeta en el lector y pulse una tecla ...');
        repeat until keypressed;
        gotoxy(1, wherey);
        clreol;
  END;

{-----------------------------------------------------------------------------}

PROCEDURE Full_Displaying;

  BEGIN writeln('Contenido de la memoria:');
        for i:=1 to 80 do write('-');
        for i:=1 to (byte_number div 6 + 1) do
        BEGIN for j:=1 to 6 do
                if j+6*(i-1) <= byte_number then write(binary(Data[j+6*(i-1)]):9)
                else write('         ');
              write('    ');
              for j:=1 to 6 do
              if j+6*(i-1) <= byte_number then write(d2h(Data[j+6*(i-1)]),' ');
              writeln;
        END;
        for i:=1 to 80 do write('-');
        Card_Type;
        writeln;

        if saving then
        BEGIN writeln(SavingFile,'Contenido de la memoria:');
              for i:=1 to 80 do write(SavingFile,'-');
              for i:=1 to (byte_number div 6 + 1) do
              BEGIN for j:=1 to 6 do
                    if j+6*(i-1) <= byte_number then write(SavingFile,binary(Data[j+6*(i-1)]):9)
                    else write(SavingFile,'         ');
                    write(SavingFile,'    ');
                    for j:=1 to 6 do
                    if j+6*(i-1) <= byte_number then write(SavingFile,d2h(Data[j+6*(i-1)]),' ');
                    writeln(SavingFile);
              END;
              for i:=1 to 80 do write(SavingFile,'-');
              writeln(SavingFile);
        END;
  END;

{-----------------------------------------------------------------------------}

PROCEDURE Short_Displaying;

  VAR j : integer;

  BEGIN for j:=1 to byte_number do
        BEGIN write(d2h(Data[j]),' ');
              if saving then write(SavingFile,d2h(Data[j]),' ');
        END;
        writeln;
        if saving then writeln(SavingFile);
  END;

{-----------------------------------------------------------------------------}

PROCEDURE Reading;

  VAR i, j  : integer;
      Value : byte;

  BEGIN (*---------------------------------------------------*)
        (* R/W est alto para las tarjetas de 256 bits: d2=1 *)
        (* Activar Reset para las tarjetas de 256 bits: d0=0 *)
        (* Activar Reset para las tarjetas de 128 bits: d2=1 *)
        (* La seal Reloj est alta: d1=1                    *)
        (*---------------------------------------------------*)

        Send($FE);

        (*------------------------------------------------------*)
        (* R/W est bajo para las tarjetas de 256 bits: d2=0    *)
        (* Desactivar Reset para las tarjetas de 256 bits: d0=0 *)
        (* Desactivar Reset para las tarjetas de 128 bits: d2=0 *)
        (* La seal Reloj est baja: d1=0                       *)
        (*------------------------------------------------------*)

        Send($F9);

        for i:=1 to byte_number do
        BEGIN Value:=0;
              for j:=1 to 8 do
              BEGIN Value:=Value*$02 + ((get and $08) div $08);

                    send($FB);   (* Activar CLK *)
                    send($F9);   (* Inhibir CLK *)

                    {delay(1);}  (* Hacer una pausa si no funciona *)

              END;
              Data[i]:=Value;
        END;

        Bin:='';
        for i:=1 to byte_number do Bin:=Bin+Binary(Data[i]);

        case displaying of
          'F':Full_Displaying;
          'S':Short_Displaying;
        END;
  END;

{-----------------------------------------------------------------------------}

PROCEDURE writting;

  VAR i,n:integer;
      car:char;

  BEGIN write('Qu bit quiere grabar a "1"? ');
        readln(n);

        waiting;
        car:=readkey;

        send($FA);
        send($F8);
        for i:=1 to n do
        BEGIN send($F9);
              if i=n then
              BEGIN send($FD);
                    delay(20);
                    send($FF);
                    delay(20);
              END;
              send($FB);
        END;
        reading;
  END;

{-----------------------------------------------------------------------------}

PROCEDURE initialize;

  VAR i : integer;

  BEGIN byte_number:=32;
        displaying:='F';
        saving:=false;
        clrscr;
        writeln(' 1 - Mostrar una tarjeta de 256 bits');
        writeln(' 2 - Mostrar una tarjeta de 128 bits');
        writeln(' F - Mostrar en formato completo');
        window(41,1,80,25);
        writeln(' S  - Mostrar en formato abreviado');
        writeln(' F2 - Grabar en un archivo');
        writeln(' Q  - Salir del programa');
        window(1,4,80,25);
        for i:=1 to 80 do write('=');
        window(1,5,80,25);
  END;

{=============================================================================}

BEGIN initialize;
      repeat waiting;
             car:=upcase(readkey);
             case car of
              'W':writting;
              'Q':;
              '1':byte_number:=32;
              '2':byte_number:=16;
              'F','S':displaying:=car;
              #00: BEGIN car:=readkey;
                         if car=#60 then
                         BEGIN if saving then close(SavingFile);
                               saving:=true;
                               write('Enter the saving filename: ');
                               readln(FileName);
                               assign(SavingFile,FileName);
                               rewrite(SavingFile);
                         END;
                   END;
              else reading;
             END;
      until car='Q';
      if saving then close(SavingFIle);
END.
--------------- cut here (end)


Reeditado por www.tecnicoselectronicos.com