Un programmateur de carte à puce 2 Kbit avec interface PC

Avez-vous déjà entendu parler de l'argent virtuel ? Oui, bien sûr. C'est cette carte que l'on vous a remise à votre club de tennis, contre espèces sonnantes et trébuchantes, et qui vous permet d'ouvrir la porte de votre cours ou de la salle de douche. Vous pouvez également l'utiliser au bar ou au restaurant du club, jusqu'à ce que l'on vous demande un petit règlement pour la recharger. Le projet décrit dans ces lignes est un système doté d'une interface RS232-C destiné à la configuration et la lecture de cartes à puce 2 Kbit. Il trouvera son emploi dans l'initialisation et le rechargement de crédit ou d'unités d'accès sur des cartes destinées à être utilisées dans des appareils automatiques mis à disposition d'un public autorisé tels que, porte-monnaie électronique,
distributeur de boissons, contrôle d'accès, villages de vacance, camping, hôtels, etc.
Les utilisations possibles sont innombrables !


Ces premiers mois de mise en place de l’EURO entraînent beaucoup de tracas pour celui qui doit désormais voyager avec une calculatrice en poche du fait du double étiquetage des prix, ainsi que des soucis de conversion que cela entraîne.
Consommateurs et commerçants sont, à ce titre, logés à la même enseigne.
Dans ces conditions, parler d’argent ou de systèmes de paiement, peut passer pour une provocation du genre : « comme si la pagaille semée par la télévision ne suffisait pas, il faut maintenant que les revues s’y mettent ! ».
En revanche, pour celui qui gère des points de distribution automatique tournés vers le grand public, cela peut constituer une bonne occasion de passer, non pas du Franc à la monnaie unique, mais des systèmes qui utilisent le paiement comptant à ceux qui fonctionnent à crédit ou en prépaiement.

Pourquoi ?
Simplement parce que l’utilisation de cartes magnétiques rechargeables évite de devoir se déplacer avec des espèces en poche, de rester « le bec dans l’eau » parce qu’il manque quelques Francs pour payer tel ou tel achat, ou encore de perdre du temps à la banque ou à trouver un distributeur pour retirer de l’argent liquide.
Par ailleurs, dans cette phase transitoire vers l’unification européenne, ces cartes à puces permettent d’éviter d’effectuer toute conversion de prix pour chercher à savoir combien d’Euros ou combien de Francs il faut débourser pour tel ou tel achat.
Ce type de carte à puce est donc une solution à toutes ces préoccupations qui nous obsèdent, pas tant les jeunes, dont la tête est pleine de chiffres et de calculs divers et pour s’en convaincre il n’y a qu’à voir la facilité avec laquelle ils se familiarisent avec l’ordinateur, mais plutôt la génération plus « mûre » habituée à calculer l’argent qu’elle réussissait à mettre de côté chaque mois à partir de son salaire.

La carte à puce 2 Kbit


Le programmateur/lecteur présenté dans cet article est dédié à la carte à puce équipée du chip Siemens SLE4442 d’une capacité de 2 Kbit. A cette capacité utilisée pour les données (mémoire principale) s'ajoutent deux autres petites zones de mémoire qui permettent de constituer également d’autres niveaux de protection.
Les 2 048 bits sont répartis en cellules (octet) de 8 bits, soit 256 zones dont les 32 premières constituent la mémoire de protection. Celle-ci peut être protégée en écriture octet par octet, simplement en activant ou en désactivant le bit correspondant de la protection mémoire.
Cette dernière zone est une PROM. Par conséquent, quand un de ses 32 bits est écrit, aucune modification sur ce bit n'est plus possible. A chacun des 32 bits de la mémoire de protection correspond un des 32 premiers octets de la mémoire principale.
Il est donc évident que la protection est permanente si on protège l’un des 32 premiers octets. Ainsi, une fois que les données ont été inscrites et que le bit de la protection mémoire correspondant a été mis au 0 logique, on ne peut plus ni les effacer, ni en écrire de nouveaux. Voilà pour le premier degré de protection en ce qui concerne les octets de 0 à 31.
Le circuit SLE4442 permet aussi d’effectuer une protection en écriture des octets 32 à 255, simplement grâce à une logique (logique de sécurité) qui requiert l’entrée d’un code pour pouvoir modifier une ou plusieurs zones.
On notera toutefois qu’il y a une différence importante entre les deux protections. Une fois protégée, la première partie de la mémoire principale devient une PROM ce qui empêche toute réécriture. Bien entendu la configuration s’effectue octet par octet. Par contre, entre le 32ème et le 255ème octet, la protection n’est effective que si l’écriture est conditionnée par l’introduction d’un code, dit PSC (Programmable Security Code), programmable lui aussi, et situé dans la mémoire de sécurité qui fait elle-même partie de la logique de sécurité évoquée auparavant.
Pour ces protections, on utilise 4 octets dont 3 constituent le PSC et 1 octet pour le compteur d’erreur, soit un total de 32 bits en tout. Par ailleurs, il est bien clair que la mémoire principale peut toujours être lue sans aucune opération supplémentaire. Pour pouvoir en modifier le contenu, il faut l’accord de la logique de protection. Cet accord peut être obtenu grâce à la comparaison du PSC, ou bien, en envoyant à la carte un code à 3 octets qui sera ensuite comparé au code présent dans la mémoire de sécurité. Si les deux codes sont identiques, on obtient alors l’accès à l’écriture, tant que la carte est alimentée.
A chaque comparaison, le compteur d’erreur positionne un de ses 4 bits à zéro. Etant donné que les 3 autres bits sont au niveau haut (1), il est évident que le compteur d’erreur se met à zéro après trois tentatives. Si cela arrive, il n’est alors plus possible d’écrire sur la carte. Donc, la première chose à faire après une comparaison du PSC, est de rétablir le compteur d’erreur en reportant tous ses bits à 1.
Enfin, à propos de la mémoire de sécurité, il va de soi que l’octet d’allocation 00 est le compteur d’erreur lui-même.
Cette zone peut toujours être lue mais aussi écrite, étant entendu que le fait d’écrire équivaut à porter à 0 un bit qui était auparavant au 1 logique. En réduisant la valeur on réduit donc les tentatives restantes. Par contre, pour le rétablissement, il est nécessaire de passer de la comparaison à la validation du PSC. A ce propos, nous rappelons que ce dernier est mémorisé dans les zones 01, 02, 03 qui peuvent, par ailleurs, être modifiées après une seule comparaison avec le résultat positif de ce même code de sécurité programmable.

Figure 1 : Fonctions de la puce Siemens SLE4442.

Figure 2 : Schéma de principe de la puce Siemens SLE4442.

Le système
Faisons donc connaissance avec un système dont les applications sont très nombreuses, puisqu’il permet d’effectuer la reconnaissance et le rechargement d’une carte à puce de 2 Kbit, directement depuis notre ordinateur personnel. C’est en quelque sorte un circuit de lecture/écriture générique, qui peut être reliée à un port série RS232-C. Ce circuit fonctionne grâce à un petit programme en Qbasic sous MS-DOS, Windows 3.x, ou encore Windows 95, 98 et NT.
Ce projet, aux utilisations multiples ainsi que nous l’avons déjà dit, est particulièrement adapté pour des systèmes automatiques de paiement à crédit, des distributeurs automatiques, les tourniquets d’accès à des stands, mais aussi pour les bibliothèques, les cinémas, les gymnases, les réfectoires, etc. Son principal avantage est de pouvoir être utilisé comme unité principale pour la gestion depuis un bureau ou depuis le siège de l’entreprise qui gère les services en question.
En intégrant le programme en QBasic au sein d’un programme personnalisé, il est également possible pour un employé, de connaître, par exemple, l’état d’une carte à puce considérée comme défectueuse par un client, de connaître le crédit restant ou encore de procéder au rechargement ou à l’attribution d’une nouvelle carte.
Ce système est donc bien sûr en mesure de réaliser toutes les opérations annexes un peu laborieuses.
Sur un ordre de l’ordinateur, un relais de sortie est activé pour une durée qui peut être programmée à l’avance. Ce relais peut servir pour activer des distributeurs de boissons, des dispositifs électromécaniques divers, ou encore pour simuler l’introduction de jetons dans des machines initialement conçues pour fonctionner avec de la monnaie.
Le circuit, ainsi doté de fonctions multiples, peut travailler soit comme lecteur de jetons mais est aussi capable de programmer et de charger un crédit dans une carte.



Etude du schéma électrique
Après cette nécessaire introduction, nous pouvons regarder comment est structurée le circuit, ceci grâce au schéma électrique.
Comme on peut noter que le dispositif n'utilise que trois circuits intégrés.
Nous y trouvons un microcontrôleur, type PIC16C56 programmé avec des routines génériques de communication série, ainsi qu’avec une autre routine pour la conversion des chaînes de données sur 8 bits, temporisées de façon adéquate.
Le microcontrôleur interprète les ordres provenant du PC, ainsi que les réponses de la carte à puce. Le circuit intégré U2 (MAX232) assure la transformation des niveaux logiques TTL + ou –5 volts au niveau RS232-C + ou –10 volts alors que le temporisateur U5, activé par le micro, est utilisé pour déterminer le temps pendant lequel le relais de sortie doit rester collé.
L’alimentation du circuit, de 12 à 15 volts cc, est appliquée sur les points +V et –V (respectivement positif et négatif). La tension, après la diode de protection D1, alimente directement la bobine du relais RL1 et le circuit du lecteur de carte à puce. On notera également la présence d’un classique régulateur intégré 7805 (U1), qui permet de fournir les 5 volts nécessaires au bon fonctionnement des circuits logiques U2, U3 et U5.
U4, quant à lui, est utilisé pour fournir le +5 V à la carte à puce dès qu’elle est introduite dans le lecteur et jusqu’au moment où elle sera retirée. U4 est alimenté par le transistor T3 piloté par le contact spécial du lecteur, qui est, en l’absence de carte, normalement fermé (son ouverture permet la saturation de T3 qui alimente le régulateur U4).

Figure 3 : Schéma électrique de l'interface de programmation de carte à puce.

Figure 4 : Plan d'implantation des composants de l'interface.

Figure 5 : Circuit imprimé échelle 1/1 de la platine de lecteur/enregistreur.

Liste des composants
R1 : 15 kΩ
R2 : 47 kΩ
R3 : 47 kΩ
R4 : Trimmer 470 kΩ
miniature
R5 : 4,7 kΩ
R6 : 47 kΩ
R7 : 47 kΩ
R8 : 470 Ω
R9 : 470 Ω
R10 : 10 kΩ
R11 : 10 kΩ
R12 : 33 kΩ
R13 : 33 kΩ
R14 : 10 kΩ
R15 : 47 Ω
R16 : 1 kΩ
R17 : 1 kΩ
R18 : 1 kΩ
C1 : 100 nF multicouche
C2 : 220 μF 25 V électrolytique rad.
C3 : 100 nF multicouche
C4 : 47 μF 25 V électrolytique rad.
C5 : 10 μF 25 V électrolytique rad.
C6 : 22 pF céramique
C7 : 22 pF céramique
C8 : 10 μF 25 V électrolytique rad.
C9 : 10 μF 25 V électrolytique rad.
C10 : 10 μF 25 V électrolytique rad.
C11 : 10 μF 25 V électrolytique rad.
C12 : 100 nF multicouche
C13 : 470 μF 25 V électrolytique rad.
D1 : Diode 1N4004
D2 : Diode 1N4148
D3 : Diode 1N4004
LD1 : LED verte 5 mm
LD2 : LED rouge 5 mm
RL1 : Relais 12 V min. 1 contact
U1 : Régulateur LM7805
U2 : Circuit intégré MAX232
U3 : Microcontrôleur PIC16HS56 (MF269)
U4 : Régulateur 78L05
U5 : Circuit intégré NE555
T1 : Transistor NPN BC547B
T2 : Transistor NPN BC547B
T3 : Transistor PNP BC557B
Q1 : Quartz 8 MHz

Divers :
- Bornier 2 pôles
- Bornier 3 pôles
- Support ci 4 + 4 broches
- Support ci 8 + 8 broches
- Support ci 9 + 9 broches
- Connecteur sub-d 9 broches femelle
- Connecteur 5 + 5 broches
- Circuit imprimé réf. S269
Sauf indication contraire, toutes les résistances sont des 1/4 W à 5 %.

Le montage de notre prototype terminé
La carte magnétique dispose d’un connecteur pour circuit imprimé de 10 broches type HE10 2 x 5 broches auquel nous devrons relier la carte d’interface avec un câble en nappe adéquat. Le circuit dispose également d’un connecteur femelle DB9 pour permettre la liaison au port série de l’ordinateur, d’un bornier à vis à 3 pôles pour les contacts du relais ainsi que d’un bornier à vis à deux pôles pour l’alimentation. Comme nous pouvons le voir, le système ne comporte que trois circuits intégrés : le microcontrôleur, auquel est dévolu le travail de convertir les ordres provenant du PC pour commander la carte et la réponse de la carte à puce en caractères ASCII, un MAX232, pour transformer les niveaux TTL en niveaux RS232 et vice-versa, et le temporisateur NE555, commandé par le microcontrôleur pour déterminer le temps de collage du relais.

Figure 6 : Plan d'implantation de la carte lecteur/enregistreur.

Figure 7 : Circuit imprimé échelle 1/1 de la platine interface PC-lecteur/enregistreur.

La carte lecteur/enregistreur de notre prototype
Pratiquement aucun composant mais un soin particulier pour le montage du lecteur/enregistreur.

Liste des composants
- Lecteur/enregistreur AMPHENOL
- Connecteur 5 + 5 broches
- Câble plat 10 conducteurs
- Circuit imprimé réf. S237


Notre programmateur est réalisé sur deux circuits imprimés distincts. L’un porte toute l’électronique, l’autre, uniquement le lecteur/enregistreur de carte à puce Amphenol et le connecteur 10 broches pour le câble plat de raccordement interface-lecteur/enregistreur.

Ce qui se passe dans le système
Nous avons dit que notre système est un lecteur/enregistreur de cartes à puce qui permet de lire, bien sûr, mais aussi d’écrire les données d’utilisation introduites depuis le clavier de l’ordinateur.
Cette opération est effectuée grâce à la routine en Qbasic, qui sert, en règle générale, à traiter toutes les opérations possibles telles qu'écriture, lecture, utilisation de la protection mémoire, substitution du PSC, etc.
Plus qu’une longue description, nous vous proposons de vous reporter sur la fenêtre de commande qui peut être visualisée en lançant le petit programme 2KBIT.BAS et dans lequel vous trouverez la liste de toutes les fonctions qu’il est possible d’effectuer. Rappelez-vous que certaines de ces fonctions nécessitent la comparaison du « code de sécurité programmable ». Veillez donc à introduire le bon code, car après 3 tentatives erronées la carte à puce devient inutilisable.
Notez que si on ne passe pas par la comparaison évoquée ci-dessus, le programme visualise des données au hasard. Par exemple, si l’on désire modifier l’état de la mémoire, il faudra donc passer par le PSC mais sans le comparer. L’opération semble se dérouler normalement mais n’aboutit pas correctement. En effet, si on contrôle la situation aussitôt après, aucune zone ne semble avoir changé.
Il va de soi que notre système doit nécessairement utiliser la carte à puce de 2 Kbit basée sur le circuit SLE4442 de Siemens, déjà configuré avec un PSC à FFFFFF.
N’essayez pas d’utiliser d’autres cartes compatibles, mais pourvues d’un Programme Security Code différent à moins de l’ignorer. Dans ce cas, le programme que nous avons mis au point exécute les comparaisons sans prévenir et, de ce fait, après 3 tentatives infructueuses, la carte à puce devient définitivement inutilisable.
Par ailleurs, n’oubliez pas que pour chaque comparaison du PSC, il faut avant tout mettre à zéro le compteur d’erreur sans quoi, même si l’opération a été menée à bien, après 3 essais la carte est perdue. Cette dernière opération est automatiquement exécutée par le programme.

Voici la copie d’écran de notre programme de gestion des cartes à puce de 2 Kbit. Le software est réalisé en QBasic et permet de gérer les 3 zones de mémoire utilisées dans la puce.

De l'interface au lecteur
Passons maintenant à l’analyse du dispositif en partant de l’interface et en allant vers le lecteur de carte à puce et les lignes de communications. Pour cette liaison nous avons utilisé les lignes RB2, RB4 et RB6 du microcontrôleur U3. Ces liaisons correspondent respectivement aux broches 8, 10 et 12. Nous pouvons ainsi gérer les canaux entrée/sortie des données. Les signaux d’horloge et le reset sont directement reliés aux contacts du lecteur qui sont connectés sur les points 1 à 8 du circuit imprimé, et aisément repérables grâce à leur marquage Memory Card (carte à mémoire, carte à puce) sur le schéma.
Pour ce qui concerne le signal d’horloge, il est issu de la broche 10 et est généré à l’intérieur du PIC16C56 par un temporisateur programmable interne. Ce signal sert à la temporisation des opérations lecture/écriture.
La broche 12 est également utilisée comme une sortie, et génère les impulsions de reset sur ordre du programme, ou bien encore en fonction des instructions en provenance de l’ordinateur.
Enfin, la broche 8 est initialisée comme entrée/sortie à collecteur ouvert. A ce titre, elle dispose de la résistance R11 de pull-up (destinée à maintenir un niveau haut) et sert, évidemment, de ligne de données série pour charger et lire les informations contenues dans la mémoire. Tous les niveaux sont de type TTL.
Le programme de gestion du microcontrôleur est conçu de telle sorte qu’il puisse reconnaître l’état du contact NF de présence de la carte magnétique dans le lecteur. Au repos, les points 1 et 2 sont fermés et, de ce fait, la jonction base/émetteur du transistor PNP est bloquée, le collecteur est donc au zéro logique.
Quand on insère une carte à puce, le contact s’ouvre et le transistor, dont la base est alimentée par la résistance R14, est saturé, la tension d’alimentation de 12 volts rejoint le diviseur de tension R12/R13 qui permet de l’abaisser à 4 ou 5 volts. La broche 18 de U3 reçoit alors un niveau 1, et le microcontrôleur exécute les opérations éventuellement demandées par le port série.
Il est clair que si rien n’est commandé depuis le panneau de contrôle du programme en Qbasic sur le PC, la carte reste au repos et le PIC16C56 attend l’arrivée des données sur le canal RX (broche 6).
Veillez à ce que le transistor T3 alimente bien la broche 18 du microcontrôleur ainsi que le régulateur intégré U4 qui est un 78L05. Grâce à la résistance de protection R15, ce régulateur fournit les 5 volts au point 3 de manière à alimenter les circuits logiques de la carte insérée dans le lecteur. De son côté, R15 permet d’éviter les courtscircuits ou les dommages causés soit par l’introduction par erreur d’une carte à puce non compatible, soit par la présence de contacts dont la disposition serait différente.
Le temporisateur, un classique NE555 désigné par U5, sert à donner une temporisation au relais RL1. Son entrée (broche 2), est commandée grâce à un transistor qui fait office d’inverseur pour le signal issu de la broche 13 du microcontrôleur désignée, quant à elle, comme sortie.
Quand l’ordre arrive en provenance de l’ordinateur (T = activation du relais), la ligne de contrôle RB7 passe au niveau haut, le collecteur de T2 passe à zéro volt pour un court instant et fournit donc un niveau bas à la broche 2 de U5 connectée comme monostable.
Ce dernier se déclenche et met sa propre sortie, broche 3, au niveau 1 durant la temporisation déterminée par R3, R4 et C4. Cette durée sera également déterminée par la formule t = (R3 + R4) x C4 qui est exprimée en secondes si les résistances sont en kilohm, et le condensateur en mF (1 millifarad = 1 000 microfarads).
Le temps d’activation du relais peut aller de 2 secondes (potentiomètre complètement fermé) à 25 secondes (potentiomètre au maximum).
Enfin, la broche 17 du PIC16C56 commande deux diodes électroluminescentes, l’une verte et l’autre rouge. La première, LD2, s’allume lorsque la broche est au niveau logique haut, alors que la seconde, LD1, s’allumera avec le niveau logique zéro. Habituellement, l’état des deux niveaux dépend des données en provenance de l’ordinateur, puisque la carte se limite à gérer la liaison de la carte à puce et de l’interface avec le PC.

Vue sur le prototype du programmateur de carte à puce, interface et lecteur/enregistreur.



Le programme en QBasic
Passons maintenant à la description du programme Basic 2KBIT.BAS disponible sous MS-DOS ou sous Windows 3x1, 95/98 et NT.
Après l’avoir lancé, le programme fait apparaître une fenêtre d’introduction, (programme de contrôle pour Cartes à puce 2 Kbit, Futura Elettronica…) et la demande « appuyer sur une touche pour continuer ». Ceci fait, le panneau de commande s’affiche, et nous trouvons une liste de toutes les opérations exécutables avec un résumé de leurs fonctions. Une lettre est assignée à chacune de ces opérations.

Le listing du programme
Vous trouverez, dans les pages suivantes, le listing complet du programme 2KBIT.BAS à écrire au moyen de l'Editor de MS-DOS. Recopiez, ligne par ligne, les instructions, puis contrôlez attentivement et éliminez les éventuelles erreurs de syntaxe ou d'orthographe.
Pour finir, vous devez enregistrer le programme (Fichier, Enregistrer sous...) sous un nom approprié comme, par exemple, 2KBIT.BAS.
Notez que, par défaut, le programme utilise le port COM2, car généralement le COM1 est utilisé par la souris. Toutefois, si pour diverses raisons, COM2 est également occupé (modem interne ou autres périphériques) vous ne devez pas l'utiliser pour notre application. Dans ce cas, vous devez rediriger vos périphériques afin de le laisser disponible, ou bien, et c'est encore le plus simple, modifier, dans notre programme, la ligne 30.
Pour ce faire, il vous suffira de changer com1 en com2, com3 ou com4. Ne modifiez aucun autre paramètre de la liaison série.
Si la frappe de la totalité du programme vous décourage, il est disponible sur disquette, réf. SFW269.

Voyons-les dans l’ordre
En appuyant sur « A », l’écran affiche « Réponse au Reset » et « Manufacturer Code » qui est le code de fabrication de la carte magnétique, lisible sans aucune procédure de protection.
Le « B » permet de lire un octet de la mémoire principale (256 octets). L’ordinateur demande l’entrée de l’adresse en format hexadécimal entre 00 et FF.
Par exemple 0A correspond à l’adresse de la zone 10.
L’affichage à l’écran donne la valeur sous forme de deux chiffres hexadécimaux qui résument les 8 bits de l’octet demandé. Avec 8 bits ont peut coder de 0 à 255 avec des chiffres hexadécimaux.
Par conséquent si on prend FF, qui correspond à l’octet 255, son contenu est également de type 11111111.
Avec la commande « C » on peut lire plus d’octets à partir de la zone spécifiée.
A l’écran il est demandé d’introduire à la suite l’un de l’autre, la zone de départ et la quantité d’octets à visualiser, bien entendu sous le format hexadécimal habituel. Par exemple, si l’on désire connaître l’état de 4 octets en commençant par celui dont l’adresse est 0A, on tape 0A04. Les deux premiers caractères sont l’adresse, les deux autres correspondent au nombre d’octets demandés, c’est-à-dire 4 dans notre exemple.
Avec la lettre « D », on accède à la lecture complète de la mémoire principale (Dump Main Memory) de 00 à FF.
L’écran montre quelques lignes contenant, d’en haut à gauche à en bas à droite, tous les octets, toujours en format hexadécimal. Notez que pour mieux identifier chaque portion, les chiffres sont affichés en couleur deux par deux.
Ce sont en tout, 2 x 256 paires en format hexadécimal de type 00 0D FF 0F qui doivent apparaître à l’écran.
La commande « E » permet d’écrire un certain nombre d’octets dans la mémoire principale. A l’écran il est alors demandé d’indiquer l’adresse de départ ainsi que la quantité de zones demandées. Pour cela, rappelez-vous que le format requis est toujours de deux chiffres hexadécimaux pour l’adresse, et de deux chiffres pour le nombre d’octets. De plus, souvenezvous que le fait d’écrire revient à porter tous les bits au 0 logique. Par exemple si l’on veut exécuter E à partir de l’adresse 00 pour 1 octet, les 8 bits correspondants deviennent 00000000. On peut le vérifier facilement si l’on effectue la lecture par « C » en spécifiant 00 comme départ, et 01 comme nombre d’octets à lire. Mais la chose la plus importante, c’est de ne pas oublier que l’opération « E » fait partie de celles qui réclament l’introduction et la comparaison du code de sécurité programmable (PSC) sous peine d’entraver le lancement de la commande « J ». Car, même si le programme autorise l’opération, en réalité l’écriture ne s’effectue pas. Ceci vaut pour toutes les opérations qui réclament une opération du PSC.
La lettre « F » autorise le Dump (listage) de la mémoire de protection, ce qui permet d’en consulter le contenu, c’est la PROM de 32 bits, (un pour chacun des octets de la mémoire principale), et qui spécifie quels octets doivent êtres en permanence protégés en écriture. La lecture visible sur l’écran de l’ordinateur, est présentée au format hexadécimal composé de 4 groupes. Chacun d’entre eux, de 00 à FF, résume la valeur d’un bloc de 8 bits.
Le fait de connaître l’état de la mémoire de protection, permet de savoir quelles zones (octets) de la mémoire principale, parmi les 32 octets susceptibles d’être protégés, ont déjà été configurées comme adresse en lecture uniquement.
Cela est très utile pour savoir, par exemple, pourquoi on ne parvient pas à écrire dans aucune des cellules, ou quand il est impossible d’identifier d’éventuels dommages sur une carte à puce.
Passons maintenant à la lettre « G » avec laquelle il est possible d’écrire 1 bit dans la mémoire de protection.
L’écran réclame l’introduction de son adresse au format hexadécimal, toujours à deux chiffres. Puis, après que vous ayez confirmé avec ENTER, l’ordinateur envoie l’ordre à la fiche de programmation/lecture ou bien à la mémoire de la carte à puce. Rappelezvous qu’une fois que vous avez écrit une donnée, vous ne pouvez plus l’annuler.
Par conséquent, l’octet correspondant à la mémoire de sécurité, parmi les 32 premiers bits de la mémoire principale n’est, à ce moment, accessible qu’en lecture seulement.
Prenez donc toutes les précautions nécessaires avant d’utiliser le bouton « G ».
La touche « H » sert à connaître l’état de la mémoire de sécurité. Juste après avoir lancé cette commande, l’écran fait apparaître la situation au format hexadécimal en 4 groupes de 2 chiffres. Parmi ceux-ci les 3 premiers à droite représentent tous les demioctet de 8 bits (par ex. 00001111 10101010) qui contiennent le PSC.
Typiquement FF FF FF pour les cartes à puce préconisées. En pratique, chaque groupe FF exprime 8 chiffres binaires au format 00000000. Le quatrième en partant de la gauche est en fait le bit du compteur d’erreur. Toutefois, nous observons qu’il sert seulement de bit de poids faible. En fait, le compteur d’erreur est effectivement de 3 bits. Ainsi, il peut rentrer entier dans un demi-octet de 4 bits et être constitué depuis une position hexadécimale.
Celle plus significative, est par contre inutilisée. Veillez à ce qu’une lecture de la Security Memory de type 07 FF FF FF indique que le PSC est bien le FF FF FF, pendant que le compteur d’erreur est remis à zéro pour disposer des 3 essais possibles. 07 exprime, quant à lui, le numéro binaire 0000 0111, et par conséquent, les 3 bits du compteur sont au niveau haut. Après une première comparaison, la situation devient 0000 0011 (03 hex.), puis deux 0000 0001 (01 hexadécimal) puis enfin 0000 0000 (00 hex.) à la fin des 3 tentatives.
La commande « I » sert à écrire ou à modifier le PSC et le compteur d’erreur.
Cette opération réclame, auparavant, que soit effectuée la comparaison du PSC, car dans le cas contraire, même si l’ordinateur exécute l’opération, la carte à puce ignorera la commande. Il est toutefois possible de procéder à l’écriture du compteur d’erreur sans passer par la comparaison du PSC, étant entendu que cela équivaut à remettre à zéro un bit ou bien à réduire la valeur et le nombre de tentatives disponibles. Pour le rétablissement de tous les bits à 1 il faut, par contre, obligatoirement passer par la comparaison évoquée auparavant.
Avec la commande « I », l’écran réclame l’introduction de l’adresse de départ à deux chiffres ainsi que les données. Ceci, bien évidemment, pour un maximum de 4 octets. L’adresse de départ peut être de 00 à 04 car audelà il ne s’agit plus de la mémoire de protection. Prenons un exemple et imaginons, en partant du défaut, enlever une tentative au compteur d’erreurs.
La zone concernée est la zone 00, qui s’affiche 00 en tant qu'adresse de départ. Pour les données, il faut appliquer une valeur hexadécimale inférieure à 07, soit 03 pour 2 bits au 1 logique et qui équivaut à 0000 0011.
Puis, il faut répéter les numéros du PSC. Inutile, bien sûr, de les réécrire s’ils ne sont pas modifiés. Faire ENTER depuis le clavier pour que l’ordinateur exécute l’ordre commandant la platine.
Quant à l’opération « J », il s’agit de la comparaison du PSC qui est exécutée pour accéder aux fonctions protégées que sont « E », « G », « I » (uniquement limité au rétablissement du compteur d’erreur et à la modification du PSC luimême) et « K » que nous verrons plus tard. Une fois le code comparé, on obtient l’accès à toutes les procédures, tant que l’on ne retire pas la carte à puce du lecteur. Après avoir appuyé sur la touche « J » du clavier, la comparaison consiste à l’introduction du PSC (après que l’affichage à l’écran nous en ait fait la demande). Appuyer alors sur ENTER. Si le résultat de la communication série est positif, le message ACK (accusé de réception) apparaît.
Dans le cas contraire on voit s’afficher NACK (non accusé de réception).
Attention : ces messages indiquent seulement le résultat de l’opération d’échange des données entre le PC et notre platine, et non pas le résultat de la commande en elle-même. Le compteur d’erreur est décrémenté d’une unité puisqu’un bit est mis à zéro, et par conséquent, la première chose à faire est de mettre le compteur d’erreur à zéro ou bien de le réinitialiser en passant par la commande « I ». Notre programme exécute donc automatiquement la commande « I » après chaque comparaison du PSC.
Avec la lettre « K » il est possible de changer le PSC actuel en écrivant le nouveau, lorsque l’ordinateur le demande, avec un format à 6 chiffres hexadécimaux tous attachés comme par exemple 0F0F0F0F. Chaque chiffre est un demi-octet de 4 bits, dont deux composent un octet de 8 bits de la mémoire de sécurité.
C'est par la commande « S » que nous rentrons dans la gestion de la carte et de ses périphériques. Elle permet de demander au lecteur s’il y a une carte à puce en place ou non. La réponse sera 0 pour l’absence de la carte et 1 pour la présence. Si on englobe la routine 2KBIT.BAS dans un programme plus complexe, la demande peut alors être transmise automatiquement, par exemple en boucle, afin de vérifier la présence d’une carte et de lancer, toujours par exemple, une phase de rechargement. Il s’agit, bien entendu, d’une simple suggestion, puisqu’avec un peu d’imagination on peut tout faire! La touche « T » permet de déclencher le monostable du circuit. Il détermine une ligne, depuis la prise série RS232-C qui est la broche 3 du connecteur, rejoint la sortie du convertisseur MAX232 (pin 9) ainsi que l’input des données du microcontrôleur U3 (RB0).
Ce dernier identifie le signal et produit une brève impulsion au niveau 1 logique sur la broche 13 de U3. Le transistor T2 passe un instant en saturation, entraînant la mise à zéro de la broche 2 du NE555 en forçant ainsi sa sortie au niveau haut. Il active, par conséquent, le transistor T1 qui commande le collage du relais RL1, pour un temps imposé par le trimmer R4.
Temporisation qui peut varier de 2 à 25 secondes. Si l’opération a été menée à bien, la réponse reçue sera ACK. En cas d’échec, NACK s’affichera.
La touche « U » entraîne l’allumage de la LED rouge LD1. Le programme génère un ordre de manière à donner l'ordre au microcontrôleur de mettre sa propre broche 17 au niveau bas, ce qui permet l’allumage de la LED LD1.
Si l’opération a été menée à bien, l’écran affichera ACK et NACK en cas d’échec. L’ordre est stable, ce qui veut dire qu’une fois l’instruction envoyée, la LED restera allumée.
La touche « V » est identique à « U », mais concerne la LED verte LD2 avec les mêmes considérations que pour LD1.
Enfin, « e » en minuscule, correspond à la demande d’identification du lecteur.
Par exemple, si on introduit un code sur le PIC de la carte, il peut ser vir à le coupler à un programme déterminé. Lors de la frappe de la lettre « e » l’écran affiche le code mémorisé dans le microcontrôleur. Cette fonction demeure optionnelle.
La touche « 0 » (zéro) est la commande d’abandon de procédure. Après avoir appuyé sur cette lettre, l’ordinateur vous demandera d’appuyer sur n’importe quelle autre touche pour sortir du programme.
Avant de passer aux instructions pour le montage, nous terminons en rappelant que chaque procédure est déclenchée par une lettre bien précise. Des affichages écran bien utiles guident l’utilisateur, et toute procédure s’achève par l’envoi au clavier d’instructions réclamées au préalable par l’ordinateur. Pour la saisie des données et des adresses de mémoire, les valeurs doivent toujours être hexadécimales, chaque chiffre étant entre 0 et F et sans aucun espace. Par exemple, pour la zone 0A et les données FF et 0E, il faudra saisir 0AFF0E puisque le programme sait les reconnaître et les séparer sans aucune aide.

REM *************************************************************
REM ***** SMART-CARD MANAGER *****
REM ***** CARD: 2 Kbit FILE: 2KBIT.BAS DATE: 20/06/98 *****
REM ***** (C) 1998 FUTURA ELETTRONICA - *****
REM *************************************************************

1 CLS
2 KEY OFF
3 ON ERROR GOTO 60000
4 COLOR 15: LOCATE 5, 10
5 PRINT «PROGRAMME DE CONTROLE POUR CHIP-CARD 2Kbit»;
7 COLOR 12: LOCATE 7, 10
9 PRINT «FUTURA ELETTRONICA SNC - RESCALDINA (MI)»;
11 COLOR 13: LOCATE 9, 10
13 PRINT «PRESSEZ UNE TOUCHE POUR CONTINUER»;
15 A$ = INKEY$
17 IF A$ = «» GOTO 15
20 DEFINT C, I, R
30 OPEN «com1:9600,E,7,1,CD,DS,CS» FOR RANDOM AS #1
35 GOSUB 17000
40 STX$ = CHR$(2): ETX$ = CHR$(3): ENQ$ = CHR$(5): ACK$ = CHR$(6): NAK$ = CHR$(21)
RESET$ = «A»: REM REPONSE AU RESET
RDMM1$ = «B»: REM Read 1 byte MAIN MEMORY (localisation a0 a1)
RDMMN$ = «C»: REM Read n bytes MAIN MEMORY (de a0 a1)
RDMMA$ = «D»: REM dump MAIN MEMORY (256 bytes)
WRMM$ = «E»: REM Write 1...4 bytes MAIN MEMORY (de a0 a1)
RDPMA$ = «F»: REM dump PROTECTION MEMORY (32 bits)
WRPM$ = «G»: REM ecriture 1 bit PROTECTION MEMORY
RDSM$ = «H»: REM dump SECURITY MEMORY (32 bits)
WRSM$ = «I»: REM ecriture 1...4 bytes SECURITY MEMORY (de a0 a1)
CMPSC$ = «J»: REM comparaison PIN
WRPSC$ = «K»: REM ecriture du PSC
STATO$ = «S»: REM demande de STATO (carte présente)
EJECT$ = «T»: REM commande activation relais (temporisé)
BUSY$ = «U»: REM commande eclairement LED ROUGE
READY$ = «V»: REM commande eclairement LED VERTE
IDENTY$ = «e»: REM demande identification lecteur 
REM NOTA: les donnees d0, d1, ... dn sont des caracteres ASCII 30H-3FH
70 COLOR 14: LOCATE 2, 3, 0: PRINT «SELECTIONNER LA FONCTION DEMANDEE:»;
71 COLOR 11
72 LOCATE 4, 3, 0: PRINT «A - REPONSE AU RESET: READ MANUFACTURER CODE»;
73 LOCATE 6, 3, 0: PRINT «B - READ 1 BYTE MAIN MEMORY: INSERER ADRESSE DE DEBUT EN HEXA. DE 00 A FF»;
74 LOCATE 7, 3, 0: PRINT «C - READ n BYTES MAIN MEMORY:INSERER ADRESSE DE DEBUT ET NOMBRE DE BYTES»;
75 LOCATE 8, 3, 0: PRINT «D - DUMP MAIN MEMORY (256 bytes: d0...dn, adresse de 00 a FF)»;
76 LOCATE 9, 3, 0: PRINT «E - WRITE n BYTES IN MAIN MEMORY (PROTEGE PAR PSC)»;
79 LOCATE 11, 3, 0: PRINT «F - DUMP PROTECTION MEMORY (PROM de 32 bit): protection permanente»;
80 LOCATE 12, 3, 0: PRINT «MAIN MEMORY»;
81 LOCATE 13, 3, 0: PRINT «G - WRITE 1 BIT ON PROT. MEMORY»;
82 LOCATE 14, 3, 0: PRINT «H - DUMP SECURITY MEMORY (32 bits: d0...dn, EC - PSC)»;
83 LOCATE 15, 3, 0: PRINT «I - WRITE n BYTES SECURITY MEMORY»;
84 LOCATE 16, 3, 0: PRINT «J - COMPARAISON PSC (formé par: d0 d1 d2 d3 d4 d5, d‚faut FFFFFF)»;
85 LOCATE 17, 3, 0: PRINT «K - WRITE PSC (forme par: d0 d1 d2 d3 d4 d5, sont disponibles de 0 a F)»;
90 LOCATE 19, 3, 0: PRINT «S - DEMANDE ETAT: 0 = carte absente, 1 = carte presente»;
91 LOCATE 20, 3, 0: PRINT «T - ACTIVATION RELAIS pour temps impose par le trimmer»;
92 LOCATE 21, 3, 0: PRINT «U - ALLUME LED ROUGE»;
93 LOCATE 22, 3, 0: PRINT «V - ALLUME LED VERTE»;
94 LOCATE 23, 3, 0: PRINT «e - DEMANDE IDENTIFICATION»;
110 COLOR 13: LOCATE 24, 3, 0: PRINT «0 - EXIT»;
125 COLOR 15: LOCATE 25, 3, 0: PRINT «QUELLE FONCTIONS ?»;
130 LOCATE 25, 24, 0: PRINT « «; : LOCATE 25, 20, 1
135 KB$ = INKEY$
140 IF KB$ = «» GOTO 135
141 IF KB$ = «e» GOTO 12000
145 IF KB$ > CHR$(&H60) AND KB$ < CHR$(&H7B) THEN KB$ = CHR$(ASC(KB$) - 32)
150 COLOR 12: LOCATE 23, 20: PRINT KB$;
160 IF KB$ = «A» GOTO 1000
161 IF KB$ = «B» GOTO 1500
162 IF KB$ = «C» GOTO 2000
163 IF KB$ = «D» GOTO 2500
166 IF KB$ = «E» GOTO 3000
167 IF KB$ = «F» GOTO 4500
168 IF KB$ = «G» GOTO 5000
169 IF KB$ = «H» GOTO 5500
170 IF KB$ = «I» GOTO 6000
171 IF KB$ = «J» GOTO 6500
172 IF KB$ = «K» GOTO 7000
178 IF KB$ = «S» GOTO 10000
179 IF KB$ = «T» GOTO 10500
180 IF KB$ = «U» GOTO 11000
181 IF KB$ = «V» GOTO 11500
200 IF KB$ = «0» THEN END
300 GOSUB 17000
310 GOTO 40
‘ A - reponse au RESET
1000 DT$ = STX$ + RESET$ + ETX$
GOSUB 20000
GOTO 300
‘ B - LECTURE 1 byte MAIN MEMORY
1500 ST$ = «INSERRER ADRESSE DE DEBUT EN HEXA. ( 00 - FF )»:
GOSUB 70000
IF LEN(STT$) = 0 THEN GOTO 300
IF LEN(STT$) > 2 THEN STT$ = LEFT$(STT$, 3)
DT$ = STX$ + RDMM1$ + STT$ + ETX$
GOSUB 20000
GOTO 300
‘ C - lecture n bytes MAIN MEMORY
2000 ST$ = «INSERRER L’ADDRESSE DE DEBUT ( 00 - FF ) ET LE NOMBRE
DE BYTES ( 00 - FF)»: GOSUB 70000
IF LEN(STT$) = 0 THEN GOTO 300
IF LEN(STT$) > 4 THEN STT$ = LEFT$(STT$, 5)
DT$ = STX$ + RDMMN$ + STT$ + ETX$
PRINT DT$;
GOSUB 20000
GOTO 300
‘ D - DUMP INTERA MAIN MEMORY
2500 DT$ = STX$ + RDMMA$ + ETX$
GOSUB 20000
GOTO 300
‘ E - ECRITURE n BYTES MAIN MEMORY
3000 ST$ = «INSERRER ADRESSE DE DEBUT ( 00 - FF ) ET DONNEE (MAX
4 BYTES 00-FF)»: GOSUB 70000
IF LEN(STT$) = 0 THEN GOTO 300
IF LEN(STT$) < 4 THEN GOTO 3000
IF LEN(STT$) > 10 THEN STT$ = LEFT$(STT$, 11)
DT$ = STX$ + WRMM$ + STT$ + ETX$
GOSUB 20000
GOTO 300
‘ F - DUMP INTERA PROTECTION MEMORY
4500 DT$ = STX$ + RDPMA$ + ETX$
GOSUB 20000
GOTO 300
‘ G - ECRITURE 1 BIT PROTECTION MEMORY
5000 ST$ = «INSCRIVEZ L’ADRESSE DU BIT (00 - 1F) A ECRIRE ET LA
VALEUR DU BYTE (00-FF)» + CHR$(13) + «A L’ADRESSE CORRESPONDANTE
DANS LA MEMOIRE PRINCIPALE»: GOSUB 70000
IF LEN(STT$) = 0 THEN GOTO 300
IF LEN(STT$) < 4 THEN GOTO 5000
IF LEN(STT$) > 4 THEN STT$ = LEFT$(STT$, 5)
DT$ = STX$ + WRPM$ + STT$ + ETX$
GOSUB 20000
GOTO 300
‘ H - DUMP SECURITY MEMORY
5500 DT$ = STX$ + RDSM$ + ETX$
GOSUB 20000
GOTO 300
‘ I -WRITE n BYTES SECURITY MEMORY
6000 ST$ = «INSCRIVEZ ADRRESSE DE DEBUT ( 00 - 03 ) ET DONNEES
(MAX 4 BYTES 00-FF)»: GOSUB 70000
IF LEN(STT$) = 0 THEN GOTO 300
IF LEN(STT$) < 4 THEN GOTO 6000
IF LEN(STT$) > 10 THEN STT$ = LEFT$(STT$, 11)
DT$ = STX$ + WRSM$ + STT$ + ETX$
GOSUB 20000
GOTO 300
‘ J - COMPARAISON PSC
6500 ST$ = «INSCRIVEZ P.S.C. ( 000000 - FFFFFF )»: GOSUB 70000
IF LEN(STT$) = 0 THEN GOTO 300
IF LEN(STT$) > 6 THEN STT$ = LEFT$(STT$, 7)
DT$ = STX$ + CMPSC$ + STT$ + ETX$
GOSUB 20000
GOTO 300
‘ K -ECRITURE PSC
7000 ST$ = «INSCRIVEZ P.S.C. ( 000000 - FFFFFF )»: GOSUB 70000
IF LEN(STT$) = 0 THEN GOTO 300
IF LEN(STT$) > 6 THEN STT$ = LEFT$(STT$, 7)
DT$ = STX$ + WRPSC$ + STT$ + ETX$
GOSUB 20000
GOTO 300
‘ S - DEMANDE DE STATO
10000 DT$ = STX$ + STATO$ + ETX$
GOSUB 20000
GOTO 300
‘ T - ACTIVATION RELAIS’
10500 DT$ = STX$ + EJECT$ + ETX$
GOSUB 20000
GOTO 300
‘ U - ALLUME LED BUSY
11000 DT$ = STX$ + BUSY$ + ETX$
GOSUB 20000
GOTO 300
‘ V - ALLUME LED READY
11500 DT$ = STX$ + READY$ + ETX$
GOSUB 20000
GOTO 300
‘ e - DEMANDE IDENTIFICATION
12000 DT$ = STX$ + IDENTY$ + ETX$
GOSUB 20000
GOTO 300
17000 CLS : LOCATE 1, 3, 0: COLOR 15
17010 PRINT «PROGRAMME DE CONTROLE POUR CHIP-CARD 2Kbit»; :
RETURN
18000 COLOR 10: LOCATE 18, 2, 0: PRINT «COMMANDE TRANSMISE: «;
COLOR 9
PRINT LEFT$(DT$, 2);
FOR I = 3 TO LEN(DT$) - 1
X$ = MID$(DT$, I, 1)
X = ASC(X$)
IF X < 58 THEN PRINT X$; ELSE PRINT CHR$(X + 7);
NEXT
PRINT RIGHT$(DT$, 1);
RETURN
20000 PRINT #1, DT$;
20050 GOSUB 17000
20100 GOSUB 18000
20300 GOSUB 25000
20400 RETURN
25000 REM ATTENTE ET VISUALISATION REPONSE
25020 COLOR 3: LOCATE 25, 2, 0: PRINT «PRESSEZ UNE TOUCHE POUR CONTINUER «; «»
25050 COLOR 3: LOCATE 20, 2, 0: PRINT «REPONSE RECUE: «: COLOR 14
25055 ANS$ = «»
25060 FOR I = 1 TO 30000
25070 n = LOC(1)
25080 IF n > 0 THEN ANS$ = ANS$ + INPUT$(n, #1): n = 0: I = 1
25090 NEXT
25100 IF LEN(ANS$) = 0 THEN PRINT «AUCUNE REPONSE»: GOTO 26200
25110 IF LEN(ANS$) = 1 THEN GOTO 25440
25115 FLGCOL% = 0
25120 FOR I = 2 TO LEN(ANS$) - 1
25130 X$ = MID$(ANS$, I, 1)
25140 IF ASC(X$) < 48 THEN : COLOR 7: X$ = CHR$(ASC(X$) + 16) ELSE COLOR 14
25150 IF (FLGCOL% AND 2) = 0 THEN COLOR 14 ELSE COLOR 11
25300 IF ASC(X$) < 58 AND ASC(X$) > 47 THEN PRINT CHR$(ASC(X$));
25435 IF ASC(X$) > 57 AND ASC(X$) < 64 THEN PRINT CHR$(ASC(X$) + 7);
25436 IF ASC(X$) > 63 THEN PRINT X$;
25437 FLGCOL% = FLGCOL% + 1 AND 255
25438 GOTO 25490
25440 IF ANS$ = CHR$(6) THEN PRINT «ACK»;
25450 IF ANS$ = CHR$(21) THEN PRINT «NAK»;
25460 IF ANS$ = CHR$(5) THEN PRINT «ENQ»;
25480 IF ANS$ = CHR$(7) THEN PRINT «BEL»;
25490 IF I = 1024 THEN
25500 A$ = INKEY$: IF A$ = «» THEN GOTO 25500
25510 END IF
25520 NEXT
25600 ‘PRINT (LEN(ANS$) - 2) / 2;
26200 I$ = INKEY$: IF I$ = «» THEN GOTO 26200
26250 COLOR 7
26300 RETURN
60000 RESUME NEXT
70000 ST$ = ST$ + « «: COLOR 9: LOCATE 25, 1: PRINT « SPACE>=effacer =annuler»; : COLOR 14
70001 LOCATE 24, 1
70002 FOR I = 1 TO 80
70003 PRINT « «;
70004 NEXT
70005 LOCATE 24, 1: PRINT ST$; : STRN$ = «»
70006 A$ = INKEY$: IF A$ = «» THEN GOTO 70006
70007 IF A$ = CHR$(13) THEN GOTO 70024
70008 IF A$ = CHR$(27) THEN STT$ = «»: RETURN
70009 IF A$ = CHR$(8) THEN
70010 A$ = «»: X$ = «»
70011 FOR G = 1 TO LEN(STRN$) - 1
70012 X$ = X$ + MID$(STRN$, G, 1)
70013 NEXT
70014 LOCATE 24, LEN(ST$) + 1
70015 FOR G = 1 TO LEN(STRN$)
70016 PRINT « «;
70017 NEXT
70018 STRN$ = X$
70019 END IF
70020 LOCATE 24, LEN(ST$) + 1
70021 IF LEN(STRN$) + LEN(ST$) = 80 THEN BEEP: GOTO 70006
70022 STRN$ = STRN$ + A$: PRINT STRN$; : A$ = «»
70023 GOTO 70006
70024 STT$ = «»
70025 FOR I = 1 TO LEN(STRN$)
70026 X$ = MID$(STRN$, I, 1)
70027 IF X$ > CHR$(96) AND X$ < «g» THEN X$ = CHR$(ASC(X$) - 32)
70030 IF X$ < «0» THEN GOTO 70001
70035 IF X$ > «F» THEN GOTO 70001
70040 IF X$ > «@» AND X$ < «G» THEN X = ASC(X$) - 7: X$ = CHR$(X)
70050 STT$ = STT$ + X$
70060 NEXT
70100 RETURN
END

Télécharger le programme sous format txt

Réalisation pratique
Pour construire le lecteur/programmeur de cartes à puce de 2 Kbit, la première chose à faire est de préparer le circuit imprimé, ou plus exactement les deux circuits imprimés, à savoir celui de la carte de base et celui de l’interface.
Pour cela vous trouverez dans cet article le dessin des pistes, côté cuivre, à l’échelle 1/1. Faites-en la photocopie sur du papier calque ou d’acétate de manière à obtenir le film nécessaire à la photogravure.
Après avoir coupé et percé les circuits, vous pouvez passer au montage des composants en commençant par les plus petits c’est-à-dire les résistances et les diodes. Pour ces dernières, veillez à bien respecter les polarités, la cathode étant la bande colorée.
Montez les dip-switchs puis le potentiomètre ajustable horizontal. Puis, c’est au tour des supports pour le microcontrôleur, le MAX232 et le NE555.
Tous doivent être positionnés en veillant à ce que l’encoche-détrompeur soit tournée comme le montre le dessin d’implantation des composants, ceci afin de bénéficier de ce repère lors du montage des circuits intégrés respectifs aux termes de la réalisation.
Continuez en soudant les condensateurs et veillez à respecter la polarité des électrolytiques. Lors du montage des deux diodes électroluminescentes rappelez-vous que LD1 est rouge, LD2 est verte, et que la cathode se trouve du côté du méplat (patte courte).
Pour ce qui concerne le quartz Q1, il n’y a pas de sens de montage particulier.
Les transistors, quant à eux, doivent être montés tournés comme le montre le plan d'implantation des composants.
Le régulateur LM7805 (U1) doit être positionné de telle sorte que sa face métallique soit tournée vers l’extérieur du circuit imprimé. Insérez le pont redresseur PT1 dans les trous prévus à cet effet, positionnez-le comme indiqué sur le plan de montage, puis soudez-le. Le relais doit, quant à lui, être de très petite taille, de type « TT MZ-12V » ou « HM4101F », et n’a qu’une position possible sur le circuit imprimé.
Enfin, n’oubliez pas le connecteur DB9 coudé pour circuit imprimé qui est soudé sur la platine en prenant bien soin de consolider les soudures aux deux clips latéraux de fixation du connecteur.
Pour faciliter les connexions d’alimentation ainsi que celles de la sortie des contacts du relais, il est nécessaire d’utiliser des borniers à vis au pas de 5 mm pour circuit imprimé. Un bornier pour l’alimentation soudé à +V et à la masse, et l’autre sur le OUT (RL1).
Pour ce qui concerne le lecteur de carte à puce, le modèle requis est celui de la marque AMPHENOL comportant un contact normalement fermé, qui s’ouvrira lors de l’introduction d’une carte à puce. Il sera relié à la carte de base au moyen d’un câble plat à 10 conducteurs sur lequel seront sertis deux connecteurs femelles type HE10 2 x 5 broches au pas de 2,54 mm en disposant le repère rouge du câble en nappe vers la broche 1 des connecteurs, aussi bien côté lecteur que côté carte.
Pour effectuer la connexion, vous devez également rajouter deux connecteurs mâles dans les trous prévus pour la liaison du câble en nappe de la carte lecteur à la platine principale.
A ce stade, il ne reste plus qu’à insérer les circuits intégrés dans leur support respectif en faisant attention à bien faire coïncider les encochesdétrompeur correspondantes. Pour l’alimentation, on peut utiliser n’importe quel modèle capable de fournir 200 milliampères sous 12 à 15 volts en courant continu. Le positif sera relié au +V de la carte, et le –V à la masse.
Avant de mettre sous tension, procurez-vous une rallonge pourvue à une extrémité d’une fiche DB25 ou DB9 femelle selon le type de PC utilisé, et à l’autre extrémité d’une fiche DB9 mâle. Pour rendre la liaison opérationnelle, branchez la fiche femelle à la prise série de l’ordinateur, et la fiche mâle au circuit du programmateur/lecteur.
Allumez le PC et chargez la disquette du programme pour lancer le système.
Vous pouvez également transcrire la routine publiée dans ces pages grâce à l’éditeur sous MS-DOS. Du moment qu’il s'agit d’une routine en Qbasic, il suffit de copier le programme 2KBIT.BAS dans le fichier racine. Pour l’activer, il faut simplement lancer QBasic, entrer dans le menu « FICHIER » puis aller dans « OUVRIR », et rentrer le nom 2KBIT.BAS précédé de l’éventuel répertoire (directory) dans la ligne de commande. On accède ainsi au listing, puis en cliquant sur « Lancer » depuis le menu « exécuter » on fait apparaître l’écran de présentation. A cet instant on active l’affichage des opérations en tapant sur n’impor te quelle touche du clavier. Pour abandonner l’exécution du programme et retourner à la routine, il suffit d’appuyer sur la touche 0 (zéro).