PROJET - jonathanm12.free.frjonathanm12.free.fr/RapportdeProjetJMartins.pdf · passer ou pas, tel ou tel accès ... PC sécurité et fera partie intégrante de la base donnée,

Groupe MARTINS Jonathan, SEDRATI Abdelyamine, REBIHA Fahim BTS IRIS

Projet Gestion Accès Sécurisé Immeuble, Année 2005

PROJET

GESTION D'ACCES SECURISES D'UN

BATIMENT


Projet Gestion Accès Sécurisé Immeuble, Année 2005 Page 1 / 90

SOMMAIRE

SOMMAIRE ...........................................................................................................................................................................1

PARTIE COMMUNE.............................................................................................................................................................3 PRESENTATION GENERALE ....................................................................................................................................3 CAHIER DES CHARGES..............................................................................................................................................4

I. L'ENTREE PRINCIPALE .............................................................................................................................4 II. LES ACCES INTERNES ...............................................................................................................................4 III. LE SYSTEME GENERALE...........................................................................................................................4

DESCRIPTION DES OUTILS.......................................................................................................................................5 I. LE DK41..........................................................................................................................................................5

A. Le port série ...............................................................................................................................................................6 B. Le port Ethernet ........................................................................................................................................................6

II. LE DIGICODE ...............................................................................................................................................8 A. Configuration du DK41 avec l’hyper terminal .......................................................................................................8

III. GESTION DE L'AFFICHEUR LCD ..........................................................................................................10 A. Précision et Configuration du DK41.....................................................................................................................10 B. Présentation du bus I²C ..........................................................................................................................................11 C. Brochage du PCF8574............................................................................................................................................14 D. Configuration du PCF8574.....................................................................................................................................14 E. Horloge PCF8583 ....................................................................................................................................................14 F. Configuration du PCF8583.....................................................................................................................................14

IV. LES TAGS ET LECTEURS DE TRANSPONDEURS ...............................................................................15 A. Un transpondeur : comment ça marche ................................................................................................................15 B. Notre système de transpondeurs ............................................................................................................................15

a) Présentation........................................................................................................................................................15 b) Fonctionnement général des lecteurs .................................................................................................................17 c) Description du protocole ....................................................................................................................................18 d) Principales commandes utilisées ........................................................................................................................18

V. LA BASE DE DONNEES PAR EASYPHP 1.6 ...........................................................................................19 VI. LE LOGICIEL BORLAND C++ BUILDER 6.0 .........................................................................................19

DISPOSITION ET FONCTIONNEMENT GENERALE..........................................................................................20

CANDIDAT N°1: MARTINS JONATHAN ........................................................................................................................22 I. PRESENTATION FONCTIONNELLE DE LA PARTIE ..........................................................................22 II. L'IHM DE COMMUNICATION PC / TRANSPONDEUR ........................................................................23

A. Présentation visuelle et générale de l'IHM ............................................................................................................23 B. Principe de fonctionnement ....................................................................................................................................24

a) L'envoi d'une commande.....................................................................................................................................25 b) La réception d'un message..................................................................................................................................26

III. LA BASE DE DONNEES ET L'API MYSQL.............................................................................................29 A. Présentation des tables ............................................................................................................................................29

a) La table 'utilisateurs' ..........................................................................................................................................29 b) La table 'autorisation' .........................................................................................................................................29 c) La table 'tablelog' ...............................................................................................................................................30

B. Principales commandes MySQL utilisées..............................................................................................................31 C. L'API MySQL .........................................................................................................................................................31

a) Présentation de l'API ..........................................................................................................................................31 b) Types de données de l'API ..................................................................................................................................32 c) Les fonctions de l'API .........................................................................................................................................33 d) Code utilisé pour inscription dans la table .........................................................................................................34

IV. L'IHM ADMINISTRATEUR .......................................................................................................................37 A. Présentation visuelle et générale des trois onglets ................................................................................................37 B. Présentation et explication de chaque fonction de l'IHM.....................................................................................38

a) L'onglet "Recherches" ........................................................................................................................................38 b) L'onglet "Configuration" ....................................................................................................................................42 c) L'onglet "Personnalisation"................................................................................................................................44



CANDIDAT N°2 : SEDRATI ABDELYAMINE.................................................................................................................46 I. PRESENTATION FONCTIONNELLE DE LA PARTIE ..........................................................................46

A. Schéma du digicode à l’entrée du bâtiment...........................................................................................................46 B. Description rapide des tâches :...............................................................................................................................47

II. COMMUNICATION AVEC LE DK41 ........................................................................................................49 A. Exemple d’un programme de test ..........................................................................................................................50 B. Programme du digicode ..........................................................................................................................................51

a) Ici nous avons les déclarations des bibliothèques...............................................................................................51 b) Ensuite nous avons l’initialisation du bus I2C....................................................................................................51 c) Nous avons l’initialisation du clavier .................................................................................................................52 d) Traduire les touches du digicode en code ASCII ................................................................................................52 e) Délai de l’ouverture de la porte..........................................................................................................................53

III. DEMONSTRATION DU PROGRAMME ...................................................................................................55 IV. PROGRAMME .............................................................................................................................................56

CANDIDAT N°3 : REBIHA FAHIM ..................................................................................................................................60 I. PRESENTATION FONCTIONNELLE DE LA PARTIE ..........................................................................60 II. APPLICATIONS SUR LE DK41. ................................................................................................................61

A. Dialogue avec l’hyperterminal. ..............................................................................................................................61 B. Paramétrage du chip. ..............................................................................................................................................63

III. COMMUNICATION ENTRE LE DK41 ET L’AFFICHEUR ...................................................................65 A. pcf8574 .....................................................................................................................................................................65 B. pcf8583 .....................................................................................................................................................................69 C. Ecrire sur l’afficheur..............................................................................................................................................74

ANNEXES ............................................................................................................................................................................80



PARTIE COMMUNE

PRESENTATION GENERALE

Raisons du projet :

Conséquence de l'espionnage industrielle, les entreprises ont de plus en plus besoin de garder la confidentialité de leurs données.

Elles trouvent utile de pouvoir filtrer les passages et de pouvoir

garder une trace des allées et venues. But du projet :

Pouvoir surveiller et contrôler les accès à l'entrée extérieure d'un immeuble.

Pouvoir surveiller et gérer les accès internes de l'édifice.

Moyens mis en oeuvre :

Une intelligence embarquée gérant : - un afficheur, - un clavier numérique, - un système de lecteurs de transpondeurs.

Une base de données enregistrant les passages et permettant la gestion des transpondeurs.



CAHIER DES CHARGES

I. L'ENTREE PRINCIPALE

A l'entrée, est placé un digicode (clavier numérique) avec un afficheur LCD. Le code est composé de 4 à 6 caractères numériques. Le code se trouve sur le PC sécurité et l'administrateur peut le changer à tout moment par une interface graphique. Le code entré est comparé au code du PC sécurité par le biais d'une connexion réseau en mode connecté. Le code est crypté pour le transport. La porte est verrouillée par une gâche électrique, un capteur vérifie l'état de la porte. L'interaction avec l'utilisateur se fait par l'afficheur LCD (2 lignes de 16 caractères). La ligne du haut affichera la date (format : " SAM 21 JUN 2005 "). La ligne du bas affichera l'heure (format : " 12:34:56 ") Quand un utilisateur tape un code, on efface la ligne du bas et chaque caractère numérique entré sera remplacé par un astérisque. Si le code est bon, il est affiché " ENTRER " clignotant. S'il est faux, on affiche " MAUVAIS CODE, ENTRER UN NOUVEAU CODE ".

II. LES ACCES INTERNES

Les accès internes sont gérés par un système de lecteurs de transpondeurs et de tags (les transpondeurs). Chaque salarié possède un tag à numéro unique. Chaque tag sera autorisé à passer ou pas, tel ou tel accès, selon une table de discrimination. Cette table se trouvera sur le PC sécurité et fera partie intégrante de la base donnée, sa gestion se fera par une interface graphique. Le transpondeur, par le moyen d'un relais interne, pourra simuler l'ouverture de la porte grâce à une LED.

III. LE SYSTEME GENERALE

Le clavier et l'afficheur seront reliés à une intelligence embarquée, le SC12 intégrée dans le module DK41 de chez BECK, par un bus I2C. Les transpondeurs seront reliés aux DK41 par la liaison série. Le DK41 gère les accès et communique avec le PC sécurité distant, par le port Ethernet. Le PC sécurité sauvegarde toutes les entrées de tous les accès internes dans une base de données journalière. L'administrateur peut, par le biais d'une interface graphique, consulter la base en faisant une recherche et pourra trouver:

les salariés et l'heure précise de passage, connaissant l'accès et le jour. les accès utilisés et l'heure de passage, connaissant le salarié et le jour. le nombre de personnes entrées, connaissant le jour.

L'heure et la date pourront être réglées sur le PC embarqué par l'intermédiaire d'une IHM sur le PC Sécurité.

Répartition des tâches : MARTINS : Communication Transpondeurs / PC Sécurité, PC Sécurité/ Base de données. SEDRATI : Communication DK41 / PC, Digicode / DK41. REBIHA : Communication DK41 / PC, Afficheur / DK41.



DESCRIPTION DES OUTILS

I. LE DK41 Le DK41 est un produit de la société allemande Beck. Beck est un membre du groupe Festo qui travaille notamment dans l'automatisation. Beck est spécialisé dans la conception de PC embarqués. Mais définissons exactement les termes "DK40", "DK41" et "SC12" que nous utiliserons.

Le SC12 est le "cœur" du système. C'est le microcontrôleur qui va permettre de gérer les périphériques que sont l'afficheur LCD, le digicode, l'horloge calendrier, la gâche et le détecteur de la porte ainsi que les lecteurs de transpondeurs. Ce microcontrôleur intègre un microprocesseur 16 bits du type 80186 cadencé à 20 Mhz, 512 Ko de mémoire Flash, 512 Ko de RAM, un watchdog, des possibilités de communication par RS232 et Ethernet 10Base-T.

Mais on ne peut exploiter convenablement le SC12 qu'en l'intégrant dans un module qui relie directement les pattes du microcontrôleur au connectiques normales utilisées. Ce module s'appelle le DK40. C'est un boîtier qui intègre 8 ports d'entrée/sortie avec leurs LEDs de contrôle, 2 ports séries (COM et EXT), 1 prise Ethernet 10base-T, 1 LED programmable, 1 LED de trafic Ethernet et un transformateur 15-30V / 5V.

Le DK41 quant à lui est un kit. C'est l'assemblage d'un SC12 et d'un DK40, ainsi que l'addition de quelques connectiques. Dorénavant on nommera l'intelligence embarqué le DK41.



Sur le DK41 nous avons 3 connectiques. Le premier est le port COM c’est la liaison série que nous branchons sur le port RS232 de notre PC. Le second nous avons le port EXT c’est aussi un port série. Le dernier c’est une prise Ethernet 10base-T.

A. Le port série L'interface série est une interface asynchrone, ce qui signifie que le signal de cette interface n'est pas synchronisé avec celui d'un bus quelconque. C'est à dire que les bits des données sont envoyés les uns après les autres. Un caractère est composé d'un ensemble de bit. C'est généralement une matrice de 8x8 bits codé par une valeur. Cette valeur est comprise entre 0 et 255 et elle est stockée sur 1 octets c'est à dire 8 bits. Chaque caractère est délimité par un signal de début qui est un bit à 0 et par signal de fin standard qui peut correspondre à un ou deux bits de fin, cela permet d'indiquer que le caractère a été envoyé. L'interface asynchrone est orienté caractère, c'est à dire que l'on doit utiliser les signaux de début et de fin pour identifier un caractère. L'inconvénient de ce processus c'est qu'il augmente la duré des transferts de presque 25 %. En effet pour chaque ligne de 8 bits il faut au minimum 2 bits. Le terme "série" viens juste du fait que les bits sont envoyés les uns après les autres sur un seul fil pour l'émission et un autre fil pour la réception, comme pour le téléphone. Il existe de nombreuse carte d'extension permettant d'avoir plusieurs ports séries ou port parallèle.

B. Le port Ethernet Ethernet (aussi connu sous le nom de norme IEEE 802.3) est une technologie de réseau local basé sur le principe suivant :

Toutes les machines du réseau Ethernet sont connectées à une même ligne de communication, constituée de câbles cylindriques.

On distingue différentes variantes de technologies Ethernet suivant le diamètre des câbles utilisés:

10Base-2: Le câble utilisé est un câble coaxial de faible diamètre 10Base-5: Le câble utilisé est un câble coaxial de gros diamètre 10Base-T: Le câble utilisé est une paire torsadée, le débit atteint est d'environ 10Mbps 100Base-TX: Comme 10Base-T mais avec une vitesse de transmission beaucoup plus

importante (100Mbps)

Technologie Type de câble Vitesse Portée10Base-2 Câble coaxial de faible diamètre 10Mb/s 185m 10Base-5 Câble coaxial de gros diamètre (0.4 inch)10Mb/s 500m 10Base-T double paire torsadée 10 Mb/s 100m 100Base-TX double paire torsadée 100 Mb/s 100m 1000Base-SX fibre optique 1000 Mb/s 500m

Ethernet est une technologie de réseau très utilisée car le prix de revient d'un tel réseau n'est pas très élevé.



Tous les ordinateurs d'un réseau Ethernet sont reliés à une même ligne de transmission, et la communication se fait à l'aide d'un protocole appelé CSMA/CD (Carrier Sense Multiple Access with Collision Detect ce qui signifie qu'il s'agit d'un protocole d'accès multiple avec surveillance de porteuse (Carrier Sense) et détection de collision). Avec ce protocole toute machine est autorisée à émettre sur la ligne à n'importe quel moment et sans notion de priorité entre les machines. Cette communication se fait de façon simple:

Chaque machine vérifie qu'il n'y a aucune communication sur la ligne avant d'émettre

Si deux machines émettent simultanément, alors il y a collision (c'est-à-dire que plusieurs trames de données se trouvent sur la ligne au même moment)

Les deux machines interrompent leur communication et attendent un délai aléatoire, puis la première ayant passé ce délai peut alors ré émettre.

Ce principe est basé sur plusieurs contraintes:

Les paquets de données doivent avoir une taille maximale Il doit y avoir un temps d'attente entre deux transmissions

Le temps d'attente varie selon la fréquence des collisions:

Après la première collision une machine attend une unité de temps Après la seconde collision la machine attend deux unités de temps Après la troisième collision la machine attend quatre unités de temps ... avec bien entendu un petit temps supplémentaire aléatoire

L'anneau à jeton (en anglais token ring) est une technologie d'accès au réseau basé sur le principe de la communication au tour à tour, c'est-à-dire que chaque ordinateur du réseau a la possibilité de parler à son tour. C'est un jeton (un paquet de données), circulant en boucle d'un ordinateur à un autre, qui détermine quel ordinateur a le droit d'émettre des informations. Lorsqu'un ordinateur est en possession du jeton il peut émettre pendant un temps déterminé, après lequel il remet le jeton à l'ordinateur suivant.

En réalité les ordinateurs d'un réseau de type "anneau à jeton" ne sont pas disposés en boucle, mais sont reliés à un répartiteur (appelé MAU, Multistation Access Unit) qui va donner successivement "la parole" à chacun d'entre eux.



II. LE DIGICODE La communication avec l’utilisateur se fera par le biais d’un digicode composées de 12 touches. Ce digicode sera placé a l’entrée du bâtiment avec l’afficheur LCD placer soit en dessous soit au dessus du digicode. Voici une photo du digicode :

Le code est composé de 4 à 6 caractères numériques. Le code se trouve sur le PC sécurité et l'administrateur peut le changer à tout moment par une interface graphique. Le code entré est comparé au code du PC sécurité par le biais d'une connexion réseau en mode connecté. Le code est crypté pour le transport. La porte est verrouillée par une gâche électrique, un capteur vérifie l'état de la porte

A. Configuration du DK41 avec l’hyper terminal



Une fois cette configuration effectuer nous obtenons sur l’hyper terminal ceci :

Pour visualiser ce que l’on a dans le DK41 il nous suffit de faire quelques petites manipulations, c’est-à-dire des commande qui ressemble au commande de dos. Le DK41 c’est comme un mini disque dur et grâce a la commande DIR on peut voir tous ce qu’il a dedans comme dans l’application ci dessous.

Si l’on veut savoir l’adresse IP du DK41 il nous suffit de taper IPCFG et on a l’adresse IP du DK41. Ici l’adresse IP est 192.168.200.1



III. GESTION DE L'AFFICHEUR LCD La communication avec l’utilisateur se fera par le biais d’un afficheur LCD de 2 lignes et 16 caractères. Cet afficheur sera placé à l’entrée principale du bâtiment. La gestion de l’afficheur, de type GDM 1602A, se fait par l’intermédiaire du DK41. En effet, un programme sera implanté dans ce dernier afin de donner les instructions relatives à l’événement présent (cf. cahier des charges). Ainsi que par le composant PCF8574, l’échange d’information à travers du bus I²C s’effectuera par ce circuit interface. Enfin un circuit horloge PCF8583, donnant l'heure système est connecté de manière très simple sur le bus. Il est équipé d'un quartz horloger de 32,768 kHz et fournit, sur requête I2C du maître, l’heure. La connexion entre le DK41 et l’afficheur se fait par un bus I²C ( Inter Intregrated Circuit ).

A. Précision et Configuration du DK41 Voici le schéma montrant les organes précédemment cités :

Nous effectuerons les premiers réglages grâce à un émulateur de terminal (Hyper Terminal ) par le biais d’un câble RS232, dont voici la configuration :

Le kit DK41 se compose de : - 2 ports séries (9 et 10) - 1 port Ethernet (8) - 8 E/S numériques (5) - 1 LED de Lien/Traffic (2) - 1 LED de test (1) Les 8 E/S sont complétées de 8 LEDs vertes. (6)



Le DK41 s’alimente entre les bornes + et - avec une tension continue entre 10V et 36V au choix, la LED link/traffic doit clignoter. Ces clignotements s'expliquent par le fait qu'à l'allumage du kit le système va réinitialiser le contrôleur Ethernet ce qui va entraîner l'extinction de la LED.

La connexion réseau Ethernet se fait soit par un câble RJ45 croisé si on veut simplement connecter le DK41 directement sur la carte Ethernet d'un ordinateur ou alors le connecter sur le réseau en le reliant à l'aide d'un câble RJ45 droit à un hub, switch, etc …

B. Présentation du bus I²C Afin d'éviter un câblage dense, une gestion de connexions d'entrées-sorties problématique et pour préserver l'évolutivité de l'ensemble, le DK41 et les périphériques sont organisés autour d'un bus I2C. Le bus I2C permet de faire communiquer entre eux des composants électroniques très divers grâce à seulement trois fils : Un signal de donnée ( SDA ), un signal d'horloge ( SCL ), et un signal de référence électrique ( Masse ). Son protocole est défini par la succession des états que peuvent prendre les signaux SDA et SCL. Il peut être décomposé en plusieurs parties distinctes :

La prise de parole, Condition de départ, Adresse destinataire, Mode lecture/écriture, Acquittement, Donnée en lecture/écriture, Acquittement, Condition d’arrêt.



Comme le montre la figure 1, outre la masse (qui sert de référence de tension) le bus I2C n'est constitué que de deux lignes de transmission : - La ligne SDA (= Serial DAta), qui véhicule toutes les informations (données, adresses, commandes). - La ligne SCL (= Serial CLock), qui sert à transmettre les impulsions d'horloge qui vont rythmer les échanges. Ces deux lignes sont donc communes à tous les périphériques qui partagent un même bus I2C. Etudions de plus prêt l'une de ces lignes (SDA ou SCL, peu importe) ; comme l'indique la figure 2, chaque

entrée/sortie a une structure 'drain ouvert' (c'est l'équivalent MOS d'un 'collecteur ouvert'), celle-ci permet de relier ensemble plusieurs sorties sans risquer de situation de conflit ; il faut alors une résistance de tirage Rt pour fixer le potentiel lorsque tous les transistors sont bloqués ; on peut noter que l'ensemble réalise une fonction logique 'ET' câblée (il faut que toutes les sorties reliées à la ligne soient à '1' pour que la ligne soit à '1') ; on en déduit donc que l'état de repos de la ligne est l'état logique '1', chaque périphérique pouvant 'prendre la ligne' en la mettant à '0'. Lors d'un dialogue entre deux périphériques I2C, les rôles sont bien répartis : - Le premier est le maître ; il initie le dialogue, envoie les commandes, et génère le signal d'horloge sur SCL. - Le second est l'esclave : en fonction des ordres et du signal d'horloge, il envoie ou reçoit des données (octets). Lorsque le bus est inactif, les lignes sont au niveau logique '1'. Lorsque le bus est actif, l'état de repos de la ligne SCL est l'état '0' ; chaque bit lu ou envoyé (sur SDA) est validé par une impulsion positive sur SCL (soit un front montant, suivi d'un front descendant, générés par le 'maître'), comme l'illustre la figure 3 :



En principe, l'état de la ligne SDA ne doit pas changer pendant que SCL est à '1'. Il y a néanmoins deux exceptions, indiquées ci-dessus figure 4 ; les instructions 'START' et 'STOP' qui servent respectivement à initier et à clore le dialogue, se différencient justement par le fait qu'elles se produisent quand SCL est à '1' : - par un front descendant sur SDA, suivi d'un front descendant sur SCL, pour 'START'. - par un front montant sur SCL, puis sur SDA, pour 'STOP'. Les signaux 'START' et 'STOP' sont bien sûr délivrés par le maître.

Exemples de câblages avec le bus I²C :

1. PCF8583 connecté sur le BUS I²C.

2. PCF8574 connecté sur le BUS I²C.



C. Brochage du PCF8574

D. Configuration du PCF8574 L’adresse du composant est réglable, on peut ainsi mettre 8 composants sur le bus. Dans notre cas, l’adresse du PCF8574 est $70. A R=1, on effectuera une lecture du composant et /W=0 on effectuera une écriture. 0 1 1 1 A2 A1 A0 R /W

E. Horloge PCF8583 Ce composant équipé d’un quartz va fournir l’heure, qui sera affichée sur la deuxième ligne de l’afficheur LCD. Une pile de 3V lui sera assignée en cas de coupure de courant, pour ne pas perdre les réglages déjà effectués. Il sera connecté au bus I²C ( cf. PCF8583 connecté sur bus I²C).

F. Configuration du PCF8583 L’adresse du composant est réglable. Dans notre cas, l’adresse du PCF8583 est $A0. 1 0 1 0 0 0 A0 R /W Le bit A0 est réglable directement sur la carte, ce qui permet d’avoir un autre composant sur le bus. A R=1, on effectuera une lecture du composant et /W=0 on effectuera une écriture.

Broche Fonction de la broche Direction A0… A2 Lignes permettant de sélectionner

l’adresse du composant. Ces broches sont reliées soit à la masse soit au +5V. Il y a 8 combinaisons possibles.

Entrée

P0…P7 Lignes d’entrées/sorties Bidirectionnel SDA Ligne de donnée du bus I²C Bidirectionnel SCL Ligne d’horloge du bus I²C Bidirectionnel INT Ligne d’interruption Sortie



IV. LES TAGS ET LECTEURS DE TRANSPONDEURS

A. Un transpondeur : comment ça marche Un système de transpondeurs se décompose en deux éléments nécessaires : le lecteur et le transpondeur a proprement parlé.

Le transpondeur ou tag est composée d'une petite puce programmée pour envoyer un code, avec un processeur simple et une mémoire flash. La puce est reliée à un long fil, l'antenne, que l'on dispose en boucle. L'énergie nécessaire lui provient du champs magnétique crée par le lecteur de transpondeur. Ainsi quand on approche le tag du lecteur, la puce est alimenté et le programme d'envoie du code s'exécute au signal du lecteur. La fréquence standard de communication est de 125Khz. L'avantage de cette technologie est que l’échange de données entre tag et lecteur se fait sans erreurs, cette précision étant contrôlée par des protocoles de transmission capables d’identifier les erreurs. Un autre

avantage est que la lecture peut se faire sans problème si le tag est sale ou s’il est, par exemple, intégré dans un produit ou encore, s’il est emballé. Les distances de lecture dépendent essentiellement de la configuration du système (type de transpondeur, taille de l’antenne du lecteur et conditions ambiantes).

B. Notre système de transpondeurs

a) Présentation

Depuis quelques années les transpondeurs sont devenus l'une des principales méthodes d'identification et de contrôle d'accès. Certains ont un format de porte-clé (tag), d'autres de badges (carte de crédit), et toutes sortes d'objet divers.

Le système mis à notre disposition a la particularité de pouvoir gérer jusqu'à 16 lecteurs, par l'intermédiaire du bus RS485 (adressable de 00 à 15 par des micro-interrupteurs situés sur chaque lecteur). Le groupe de transpondeurs est capable de fonctionner en mode autonome ou bien d'être commandé par le PC. C'est cette deuxième option que nous avons choisis car elle permet d'agir sur les deux relais interne à chaque transpondeur et élargi les possibilités d'utilisation de ce système.



Le schéma de montage est le suivant (servit notamment pour les tests) : (Fig. 1)

Le convertisseur de niveaux logiques RS232/RS485 est branché au PC sur le port série et ensuite les transpondeur, reliés les un autres, sont reliés a ce même convertisseur. Le bus RS485 est possible car les deux prises RJ45 de chaque lecteur sont en parallèle. Ceci signifie que les informations transmises du PC arrivent sur un port et sont directement transmises au second. L'information peut ainsi transiter jusqu'au dernier lecteur, situé physiquement au bout de la chaîne, sans problème. Rappelons les normes RS232 et RS485 :

Caractéristiques RS 232 (V28) RS 485 (V11) Mode de transmission Simple Différentiel Mode de communication Point à Point, Full Duplex Bus, Half Duplex Longueur de câble moyenne 15 m < 1000 m Valeur des tensions

Il est a noté que l'emploi de deux prises RS485 pour chaque transpondeur fait de notre montage un Bus RS485 Full-Duplex, ce qui permet simultanément l'écriture et la lecture. Le PC est alors à même de "dialoguer" avec les transpondeurs.



b) Fonctionnement général des lecteurs Le système se compose d'un PC sur lequel tourne un logiciel de gestion pour un maximum de 16 lecteurs et d'une interface de communication chargé de relier l'ordinateur aux transpondeurs. La logique de fonctionnement peut se résumer ainsi : quand un tag passe près d'un lecteur, son code d'identification est lu puis transmis au PC par le bus. Le logiciel tournant sur l'ordinateur, dès la réception du code, le compare à ceux mémorisés et peut ainsi commander au lecteur en question l'exécution de certaines actions. La gestion de la communication se fait en mode "polling": l'ordinateur va interroger séquentiellement les lecteurs et éventuellement va gérer l'émission d'une commande vers le lecteur. Ceci est logique car, se situant sur le même bus, les lecteurs pourraient émettre en même temps et produire des collisions. De ce fait il peut s'écouler quelques instants entre le moment ou l'on passe le tag et le moment où le PC interroge le lecteur. D’où la présence d'un buffer (tampon), qui garde en mémoire le code transmis par le tag jusqu'à l'interrogation du PC. Voici une figure qui schématise le mode "polling" : (Fig. 2)



c) Description du protocole

Il s'agit d'expliquer les bases des règles d'envoi de requêtes entre PC et lecteurs de transpondeurs. Le tableau suivant montrera clairement comment se décompose une trame en provenance du PC et du lecteur de transpondeur.

Une trame commence toujours par deux caractères de synchronisation (*# ou ST). Ils sont suivis par l'identificateur du lecteur, au format dizaine unité (00 → 15). Vient ensuite la requête à proprement parlée. Enfin, la trame se termine toujours par deux autres caractères en fonction de l'émetteur (90 ou EN). Exemple : -Le PC envoie "*#040190" ("04" pour le lecteur d'adresse 04,"01" pour l'interrogation) -Le lecteur renvoie "ST0401EN" ("01" pour "Rien a signaler").

d) Principales commandes utilisées A noter que les exemples qui suivront seront destinés au lecteur "08" ou en proviendront. Commandes du PC Interrogation : "*# 08 01 90" Action des relais ("01" pour le relais n°1) : "*# 08 02 01 90" Réglage durée d'activation du relais (01<XX<99): "*# 08 03 01 XX 90" (Si XX=00 on passe en mode bistable mais on ne l'utilisera jamais) (XX=01 pour 1 sec., …) Réponses du lecteur Aucun tag passé : "ST 08 01 EN" Un tag passé : ("02" + code du tag) : "ST 08 02 0282101011200 EN" Relais actionné ("01" pour le relais n°1) : "ST 08 03 01 EN" Réglage durée d'activation du relais : "ST 08 03 01 XX EN"

PC *# du (donnée) 90 Lecteur ST du (donnée) EN



V. LA BASE DE DONNEES PAR EASYPHP 1.6

Le système a besoin de pouvoir enregistrer les passages au différents accès contrôlés par un lecteur de transpondeur. Ces enregistrements se feront, suivant le cahier des charges, sur une base de données. Etant donné qu'il ne s'agirait pas d'une lourde base de données, nous avons choisi le logiciel EasyPHP. EasyPHP installe et configure automatiquement un environnement de travail

complet sous Windows permettant de mettre en oeuvre toute la puissance et la souplesse qu'offrent le langage dynamique PHP et son support efficace des bases de données. EasyPHP regroupe un serveur Apache, une base de données MySQL, et le langage PHP que nous n'utiliserons pas. MySQL est un logiciel de traitement de base de données SQL Open Sources. C’est lui qui est véritablement le support de la base, et c’est donc avec lui que l’on devra communiquer. Au lancement d'EasyPHP, le serveur Apache et MySQL sont mis en route. Le système est prêt à enregistrer les passages, ou bien à fournir les réponses aux requêtes de l'utilisateur.

VI. LE LOGICIEL BORLAND C++ BUILDER 6.0

Tous les programmes réalisés par le candidat n°1 ont été réalisés par Borland C++ Builder 6.0, ceux réalisée par les candidats n°2 et n°3 avec Turbo C++. C++ Builder est un environnement graphique permettant le développement rapide et aisé d'applications graphiques.



DISPOSITION ET FONCTIONNEMENT GENERALE En assemblant tous les éléments vus précédemment, on pourrait obtenir le schéma général suivant :



Pour résumer le fonctionnement type du système, voyons les diagrammes UML de Cas d'utilisations et de Séquences : Cas d'utilisations :

Séquences (Externe puis Interne):

Utilisateur Syst. Écran Clavier PC Sécurité tape le code

envoie du code ( par le DK 40 )

vérification code

renvoie autorisationdéblocage porte

Utilisateur Syst. Transpondeur PC Sécurité

passe le tag envoie données

( par le DK40 )

renvoie autorisation

déblocage porte

activation relais

vérification autorisation

Ouvrir la porte

Changer le code

Ouvrir la porte

Consulter passages

Gérer autorisations

Interne

Externe

Gestion Accès

autorise

visualise

effectue

tape code

passe tag Salarié Administrateur

MARTINS Jonathan BTS IRIS


Candidat n°1: MARTINS Jonathan

I. PRESENTATION FONCTIONNELLE DE LA PARTIE Le but de cette partie est de :

concevoir une Interface Homme Machine (IHM) de communication entre le PC et les lecteurs de transpondeur. Celle-ci permettra de mettre en œuvre des tests afin de permettre une intégration aisée dans le DK41.

créer une base de données permettant l'enregistrement des passages, contenant

l'information sur le possesseur du tag et permettant d'effectuer des recherches.

concevoir une IHM destinée à l'administrateur, lui permettant de donner ou retirer les droits d'accès, lui permettant encore de faire des recherches en fonction des critères définis dans le cahier des charges.

La première IHM sert tout d'abord à pouvoir communiquer correctement avec les lecteurs de transpondeurs. Elle permet par ailleurs d'analyser la trame reçue et de savoir isoler les donnée dont on a besoin pour effectuer les enregistrement sur la base de données. Enfin elle sert à savoir communiquer avec la base de données. La deuxième IHM sert surtout réaliser les requêtes sur la base de données et à afficher les résultat d'une façon pratique et attractive. Au jour d’aujourd’hui l’intégration dans le DK41 n’est pas encore été faite, du fait de ne pas avoir reçu le module de communication série de celui-ci. L’étude commence juste et on espère que le système sera complet le jour de l’oral.



II. L'IHM DE COMMUNICATION PC / TRANSPONDEUR

Revoyons les contraintes de cette Interface Homme Machine. Comme il a été vu précédemment, les transpondeurs doivent être géré en mode "polling". Il s'agit donc d'interroger un à un les lecteurs dans un ordre régulier. A la réception d'un message indiquant le passage d'un tag, il faudra relever 4 informations nécessaires à l'inscription dans la base de données :

l'adresse ou nom du lecteur concerné, le code du tag passé, la date de passage, l'heure de passage.

Ces quatre informations seront les quatre champs de la table qui enregistre les passages. Il faut ensuite exécuter une requête sur la base pour savoir si le tag et donc l'utilisateur est autorisé à passer. On affichera alors la réponse à cette requête. Si l'utilisateur est autorisé à passer, alors on actionne un relais qui est réglé sur une durée d'activation d'environ 5 secondes et on inscrit sont passages dans la table.

A. Présentation visuelle et générale de l'IHM L'IHM est une fenêtre simple :

Quand on passe un tag le lecteur envoie par la liaison série une trame. Cette trame est lu puis affiché et traitée afin d'isoler les différentes parties de la trame. Nous verrons une explication détaillée dans la prochaine partie.



Afin de pouvoir communiquer avec le port série efficacement, j'ai réaliser une classe RS232 dont voici le diagramme :

RS 232 # vitesse : int # port : int # taille : int # parite : char # stop_bit : char + Envoi (char *) + Recevoir (char *, char *, char *, char *, char *) + RTS (bool) + DTR (bool)

B. Principe de fonctionnement Le mode "polling" est réalisé par la fonction Timer de C++ Builder. Toutes les 500 ms le programme interroge un nouveau lecteur dans un ordre défini par les valeurs enregistrées dans un tableau de pointeurs vers des chaînes. Ceci permet de pouvoir garder une évolutivité du logiciel. Voici la déclaration de ce tableau : char *Reader[]={"08","12"}; Ce tableau est accompagné d'une variable ( char rd; ) qui va permettre de prendre successivement les valeurs du tableau. Quand rd vaut '0' on accède à la valeur "08", quand rd vaut '1' on accède à la valeur "12"… Ces valeurs sont nécessaires pour pouvoir adresser les commandes au bon lecteur de transpondeurs. Maintenant que l'on connaît les valeurs nécessaire à l'adressage des lecteurs il faut les interroger. La commandes sera alors créer en fonction de la valeur de rd par la fonction sprintf. Cette fonction va concaténer "*#", la valeur d'adressage et "0190" pour former la commande (explication au IV. B. d) de la partie commune). Cette commande est garder en mémoire dans un pointeur nommé Mess et est prête à être envoyée. Voici la déclaration et la concaténation :

char *Mess = new char[10]; sprintf(Mess,"%s""%s""%s","*#",Reader[rd],"0190");



a) L'envoi d'une commande L'envoi va se faire par l'intermédiaire de la classe RS 232, dont voici la déclaration ainsi que celle du constructeur qui initialise la communication avec le port série : //*************************************************************** class rs232 { //Attributs private: HANDLE hCom; //Methodes public: rs232(); void Envoi(char *chaine); void Recevoir(char *CinBuffer, char *CTrspder, char *CTagCod, char *CDate ,char *CHeure); void RTS(bool rts); void DTR(bool dtr); ~rs232(); }; //*************************************************************** rs232::rs232() { DCB dcb; hCom=CreateFile("COM1",GENERIC_READ|GENERIC_WRITE,0,NULL, OPEN_EXISTING,0,NULL); GetCommState(hCom,&dcb); dcb.BaudRate=115200; dcb.ByteSize=8; dcb.Parity=NOPARITY; dcb.StopBits=ONESTOPBIT; dcb.fTXContinueOnXoff=0; SetCommState(hCom,&dcb); }; Le fichier hCom qui va permettre la communication avec le port série est maintenant configuré. Il faut maintenant instancier la classe et créer un objet du type RS232. On instancie alors l'objet TransObjet comme suit : rs232 TransObjet; Maintenant que nous avons notre objet, il nous est possible d'utiliser les méthodes ou fonctions de la classe. Celle qui nous intéresse ici est la méthode Envoi, qui a besoin d'un paramètre (par adresse) : le message à envoyer. Voici la fonction Envoi :

void rs232::Envoi(char *chaine) { unsigned long nBytesWrite; WriteFile(hCom,chaine,8,&nBytesWrite,NULL); };



Pour mettre en œuvre cette fonction, il faut utiliser notre objet, déclaré précédemment, comme suit : TransObjet.Envoi(Mess); La commande contenue dans le pointeur Mess est alors envoyé sur le port série. Le convertisseur RS232/RS485 met à niveaux les signaux qui sont ensuite envoyés sur le bus RS485 ou sont branchés les lecteurs. Le lecteur dont l'adresse correspond à celle du message prend alors le message en compte. Deux cas de figure sont alors possibles. Un tag à été passé devant le lecteur ou pas. Si aucun tag n'a été passé le lecteur répond au PC par un simple message d'acquittement. Si un lecteur a été passé alors il va falloir traiter le message. C'est ce que nous verrons maintenant.

b) La réception d'un message Pour recevoir des données, nous allons utiliser une autre fonction de la classe RS232, la fonction Recevoir. Auparavant il faut déclarer tous les pointeurs nécessaires aux paramètres de cette fonction, car une fois encore nous allons faire un passage de donnée par adresse entre la classe et le programme principale. Le premier pointeur est inBuffer, c'est lui qui aura en mémoire la trame entière. Le second est Trspder qui sert à conserver l'adresse du lecteur dont provient le message. Le troisième, TagCod, garde en mémoire le code interne au tag passé. Les deux derniers, Datepas et Heurepas sont deux pointeurs qui donnent l'heure et la date du passage du tag. Voici la déclaration de tous ces pointeurs :

char *inBuffer=new char[30], *Trspder=new char[9]; char *TagCod=new char[16], *Datepas=new char[11]; char *Heurepas=new char[10];

Nous sommes désormais à même de pouvoir utiliser la méthode Recevoir. Avant de présenter cette fonction, voyons quelques précisions sur celles-ci. La fonction principale utilisée dans cette méthode est la fonction ReadFile qui sert à lire le fichier qui communique avec la liaison série. Or cette fonction est bloquante. Ceci se traduit par une sensation de blocage du PC tant que l'on ne reçoit pas le nombre de bit indiqué dans les paramètres de la fonction. On peut résoudre ce problème par une configuration approprié d'un Timeout. Configuré comme il l'est ci-après, le Timeout permet de "couper" l'attente de la fonction ReadFile au bout de 200 ms. Ainsi, si aucun caractère n'arrive sur le port série durant les prochaines 200 ms le processeur passe a la commande suivante. D'autres part, il est utiliser, pour récupérer l'heure et le jour, trois fonctions systèmes : GetLocalTime, GetTimeFormat et GetDateFormat. Ces deux dernières fonctions permettent de choisir le format d'affichage ou de capture de l'heure et de la date. Il est d'abord nécessaire de déclarer une variable du type SYSTEMTIME et de capter l'heure et la date par la fonction GetLocalTime sur cette variable.



Voici maintenant la fonction Recevoir : void rs232::Recevoir(char *CinBuffer, char *CTrspder, char *CTagCod, char*CDate ,char *CHeure) { char i,j, stop, *nul; char *tmp=new char[2], *reader=new char[7]; reader="READER "; nul=""; unsigned long nBytesRead=0; COMMTIMEOUTS tempo; tempo.ReadIntervalTimeout=MAXWORD; tempo.ReadTotalTimeoutMultiplier=0; tempo.ReadTotalTimeoutConstant=200; tempo.WriteTotalTimeoutMultiplier=0; tempo.WriteTotalTimeoutConstant=0; SetCommTimeouts(hCom,&tempo); SYSTEMTIME st; ReadFile(hCom,CinBuffer,30,&nBytesRead,NULL); CinBuffer[nBytesRead]=*nul; if(nBytesRead > 8) { GetLocalTime(&st); GetTimeFormat(LOCALE_USER_DEFAULT,TIME_FORCE24HOURFORMAT,&st, "HH':'mm':'ss",CHeure,10); GetDateFormat(LOCALE_USER_DEFAULT,NULL,&st,"dd'/'MM'/'yyyy", CDate,25); for(i=2;i<4;i++) tmp[i-2] = *(CinBuffer+i); tmp[2]=*nul; sprintf(CTrspder,"%s""%s",reader,tmp); sprintf(CTagCod,"%s"," "); for(i=6;i<nBytesRead-2;i++) CTagCod[i-6] = *(CinBuffer+i); } else { sprintf(CTrspder,"%s",""); sprintf(CTagCod,"%s",""); sprintf(CDate,"%s",""); sprintf(CHeure,"%s",""); } };

Justifions maintenant les choix des chiffres utilisés pour découper la trame reçue du lecteur de transpondeur.

1. Le numéro du transpondeur se situe toujours sur le deuxième et troisième caractère de la trame, donc sur les bits n° 2 et n° 3 (commence par 0 et non par 1).

2. Le code du tag passé commence toujours au septième caractère, donc à partir du bit

n° 6. Etant donné que les codes n'ont pas tous le même nombre de chiffre, il a fallut utiliser une technique valable pour tous les codes possibles. Ainsi on s'arrête au bit "nBytesRead-2". Le pointeur nBytesRead contient le nombre de bits lus par le dernier ReadFile. On s'arrête donc a 2 bits de la fin de la trame.



Pour mettre en œuvre la méthode Recevoir, il faut utiliser notre objet, déclaré précédemment, comme suit : TransObjet.Recevoir(inBuffer, Trspder, TagCod, Datepas, Heurepas);

On peut recevoir ainsi correctement la trame venant des lecteurs. Il ne reste plus, dans le programme principal, qu'à affecter les valeurs obtenues aux différentes zones prévues à cet effet. Voici le code permettant d'affecter les valeurs aux EditBox correspondantes :

IHM->TrameEdit->Text=inBuffer; IHM->TranspNumEdit->Text=Trspder; IHM->TagCodeEdit->Text=TagCod; sprintf(DatHeur,"%s""%s""%s",Datepas," ",Heurepas); IHM->TimeEdit->Text=DatHeur;

Pour éclaircir ce que nous venons d'expliquer, voyons un "screenshot" de l'IHM en fonctionnement. L' exemple qui suit montre une trame reçue du lecteur d'adresse "08", où on a passé le tag de code "02821010111211". Afin de faciliter la reconnaissance des tag, on a associer un numéro simple à chacun, ici c'est le tag n°1 (Le lien entre codes et numéro se fait par la base de données, décrite dans la prochaine partie).

Maintenant que nous avons tous les renseignements nécessaires et surtout que nous avons réussi à les isoler, nous pouvons les inscrire dans la base donnée. La partie suivante nous présentera les trois tables utilisés et surtout nous expliquera comment il a été possible de communiquer avec une base MySQL, à partir d'un programme en C++.



III. LA BASE DE DONNEES ET L'API MYSQL

A. Présentation des tables

a) La table 'utilisateurs' La table 'utilisateurs' est la table qui permettra de personnaliser le porteur de tag. En l'état actuel des choses il n'est possible que changer le nom mais rien n'empêche d'agrandir le nombre des informations. Il a été créer un champ 'NomUt' qui référence les noms de porteurs de badges, un champ 'NumeroTag' qui affecte à chaque tag un numéro beaucoup plus simple et pratique que leur code interne. Le troisième champ est donc 'CodeTag' qui référence le code interne aux tags. Cette table permet donc de retrouver le code par rapport au numéro ou au nom et vice versa. Voici la table 'utilisateurs' actuelle :

Cette table pourra être modifiable par l'IHM administrateur décrite plus loin dans ce dossier. Au moment de l'écriture de ce rapport, on ne peut modifier que le nom. On peut aussi facilement enregistrer de nouveaux tags grâce à l'IHM.

b) La table 'autorisation' La table 'autorisation' est notre table de discrimination. C'est-à-dire qu'elle va nous permettre de définir les autorisations de passage ou non au différent accès. Il a été choisi de créer un champ par lecteur de transpondeur, ainsi qu'un champ concernant le numéro des tags. Dans la configuration actuelle, nous avons donc un champ 'NumeroTag', un champ 'READER 08' correspondant au premier lecteur et un champ 'READER 12' correspondant au deuxième lecteur. Il est possible d'ajouter des transpondeurs sur le bus pour un maximum de 16. Il suffit, dans ce cas, tout simplement de rajouter un champ avec le nom du transpondeur dans la table. Mais cette option n'est pas encore possible par l'IHM destinée à l'administrateur.



Voici la table 'autorisation' actuelle :

L'administrateur peut autoriser le passage par un 'true' dans le champ correspondant au lecteur. Il le refuse par un 'false'. Ces changements sont simples et très intuitifs dans l'IHM de l'administrateur.

c) La table 'tablelog' La table 'tablelog' est la table qui va enregistrer tous les accès accordés aux utilisateurs. Comme vu précédemment, nous avons pu isoler quatre informations pour remplir les quatre champs de la table que sont 'Transpondeur', 'CodeTag', 'Date' , 'Heure'. Voici ci-dessous un exemple possible de liste de passages autorisés. En effet, quand un accès est refusé on n'enregistre pas les données.



B. Principales commandes MySQL utilisées

• SELECT

Cette commande est la commande de base des requêtes MySQL. Elle est destinée à extraire des données d'une base en utilisant certains paramètres. Format d'utilisation :

SELECT champ(s) ou * FROM nom_de_table [WHERE conditions]

• UPDATE

Cette commande est utile à la modification de données dans une table. Format d'utilisation :

UPDATE nom_de_table SET champ = valeur [WHERE conditions]

• INSERT

Cette commande sert à l'insertion de données dans une table. Format d'utilisation :

INSERT INTO nom_de_table (champ(s)) VALUES (valeur(s))

C. L'API MySQL Nous avons à disposition l'IHM qui permet de récupérer les données et nous avons la base de données. Mais il manque le principal. Comment communiquer avec une base MySQL avec un programme en langage C ?

a) Présentation de l'API Après plusieurs semaines de recherches en utilisant des sockets personnels (ne fonctionnant jamais à cause d’un manque de connaissance sur le protocole à utiliser pour communiquer avec la base), nous avons réussi à mettre en œuvre l'API MySQL C. Le terme API (pour Application Programming Interface) désigne un langage ou un format de message utilisé par un programme applicatif pour communiquer avec un système d'exploitation ou un autre programme, comme c'est le cas ici, un système de gestion de base de données. Techniquement, les API consistent en des appels de fonctions, de structures, accompagnés de certains paramètres à communiquer à l'extérieur de l'applicatif. L'API MySQL permet donc de communiquer avec une base MySQL comme la notre. Mais pour cela il est d'abord nécessaire que cette API soit compatible avec le projet C++Builder. Voici les étapes nécessaires pour pouvoir compiler un programme utilisant l'API MySQL :

1. Tout d'abord, il faut télécharger le fichier .dll nommé libmySQL.dll, que l'on trouve sur le site officiel de MySQL (http://www.mysql.com/). Avec le package téléchargé, on trouve aussi plusieurs fichiers .h indispensable au bon fonctionnement du tout.



2. Il faut ensuite utiliser une fonction de Borland, en utilisant un programme nommé implib.exe. On ouvre une console et on tape la commande :

implib libmySQL.lib libMySQL.dll

Cette commande crée un fichier .lib à partir d'un fichier .dll. Le nouveau fichier doit être associé au projet. Cette action est indispensable pour pouvoir compiler sans erreurs.

3. Ensuite, il faut modifier le fichier mysql.h, fournit dans le package précédemment téléchargé. A la ligne 34, il faut remplacer

"#ifdef __LCC__" par

"#if ( defined(__LCC__) || defined (__WIN__) )".

4. Il faut maintenant ajouter à chaque fichier utilisant l'API les deux lignes suivantes au niveaux des "#include" :

#define __WIN__ #include "mysql.h"

b) Types de données de l'API Les types de données sont celles utilisées dans les deux IHM.

• MYSQL

Cette structure représente un gestionnaire de connexion à la base de données. Elle est utilisée dans la plupart des fonctions MySQL.

• MYSQL_RES

Cette structure représente le résultat d'une requête qui retourne des lignes (SELECT, SHOW, DESCRIBE, EXPLAIN).

• MYSQL_ROW

C'est une représentation sûre pour les types d'une ligne de données. Elle est actuellement implémentée en tant que tableau de chaîne à octets comptés. Les lignes sont obtenues en appelant mysql_fetch_row().



• MYSQL_FIELD

Cette structure contient des informations à propos du champ, tel que son nom, son type, et sa taille. On peut obtenir une structure MYSQL_FIELD pour chaque champ en appelant plusieurs fois mysql_fetch_field(). Les valeurs des champs ne font pas partie de la structure; elles sont contenues dans une structure MYSQL_ROW.

c) Les fonctions de l'API Voici un tableau résumant les principales fonctions de l'API MySQL. Fonction Description mysql_close() Ferme une connexion au serveur. mysql_error() Retourne le message d'erreur de la dernière fonction MySQL appelée. mysql_fetch_field() Retourne le type du champ suivant dans la table. mysql_fetch_fields() Retourne un tableau avec toutes les structures de champs. mysql_fetch_lengths() Retourne la longueur de toutes les colonnes dans la ligne suivante. mysql_fetch_row() Récupère la ligne suivante dans le jeu de résultats.

mysql_field_count() Retourne le nombre de colonnes dans le résultat pour la requête la plus récente.

mysql_free_result() Libère la mémoire utilisée par un jeu de résultats. mysql_init() Récupère ou initialise une structure MYSQL. mysql_num_fields() Retourne le nombre de colonnes dans un jeu de résultats. mysql_num_rows() Retourne le nombre de lignes dans le jeu de résultats.

mysql_query() Exécute une requête SQL spécifiée en tant que chaîne terminée par un caractère nul.

mysql_real_connect() Connecte à un serveur MySQL. mysql_select_db() Sélectionne une base de données. mysql_shutdown() Termine le serveur de base de données. mysql_store_result() Récupère le jeu de résultats complet dans le client. mysql_use_result() Initialise une récupération ligne par ligne des résultats. mysql_commit() Valide une transaction (nouveau en 4.1). mysql_rollback() Annule une transaction (nouveau en 4.1). mysql_more_results() Vérifie si il n'y a plus de résultats (nouveau en 4.1).

mysql_next_result() Retourne/initie le prochain résultat dans une commande multi-requête (nouveau en 4.1).

Pour se connecter au serveur, il faut appeler mysql_init() pour initialiser un gestionnaire de connexion, puis appeler mysql_real_connect() avec ce gestionnaire (avec d'autres informations tel que l'hôte, l'utilisateur et le mot de passe). Lorsque l'on n'a plus besoin de la connexion, il faut appeler mysql_close() pour la clore. Tant qu'une connexion est active, on peut envoyer des requêtes SQL au serveur à l'aide de mysql_query().Pour les requêtes SELECT, on peut récupérer les lignes sélectionnées dans un jeu de résultat.



Il y a deux façons pour un client de gérer les jeux de résultats. Une méthode consiste à récupérer le jeu de résultat en entier et en une seule fois en appelant mysql_store_result(). Cette fonction obtient toutes les lignes retournées par la requête et les stocke dans le client. La seconde méthode consiste à initialiser une récupération ligne par ligne du jeu de résultats en appelant mysql_use_result(). Cette fonction initie la récupération, mais ne récupère actuellement aucune ligne à partir du serveur. On préférera la première solution. On accède aux lignes en appelant mysql_fetch_row().Les informations à propos de la taille des données dans chaque ligne est disponible en appelant mysql_fetch_lengths(). Après avoir fini de traiter le jeu de résultats, il faut utiliser mysql_free_result() pour libérer la mémoire utilisée. La fonction mysql_store_result() permet d'obtenir des informations à propos des champs qui constituent le jeu de résultat (le nombre de champs, leurs noms et types, etc.). On accède aux informations du champ séquentiellement dans une ligne en appelant plusieurs fois mysql_fetch_field(). On peut aussi obtenir en une seule fois les informations sur les champs en appelant mysql_fetch_fields(). Pour détecter les erreurs, MySQL fournit un accès aux informations des erreurs via la fonctions mysql_error(). Elle retourne le code de l'erreur et le message pour la dernière fonction invoquée qui aurait pu réussir ou échouer, permettant ainsi de déterminer les erreurs et leurs causes.

d) Code utilisé pour inscription dans la table La déclaration des variables nécessaires à la connexion et à l'enregistrement des résultats de requêtes:

MYSQL *mySQL; MYSQL_RES *myRES; MYSQL_ROW myROW; AnsiString aStr="", autor="";

La connection, primordiale, a besoin de l'adresse du serveur MySQL, d'un nom d'utilisateur, d'un mot de passe, et du nom de la base :

mySQL = mysql_init(NULL); if(!mysql_real_connect(mySQL,"127.0.0.1","root","","GestionTranspondeur", 0, NULL, 0)) { Label1->Caption="La connection a échouée"; } else { Label1->Caption="La connection a réussi"; }



La création d'une requête par concaténation de plusieurs "morceaux" :

Reket1="SELECT `"; Reket2="SELECT `NumeroTag` FROM ùtilisateurs` WHERE CodeTag = "; sprintf(Reket,"%s""%s",Reket2,TagCod); Reket2=Reket;

Exécution de la première requête :

//Recherche du numéro de Tag en fonction du Code if (!mysql_query(mySQL, Reket2)) {

myRES = mysql_store_result(mySQL); if (myRES) { myROW = mysql_fetch_row(myRES); if (myROW){ aStr = myROW[0]; TagNumEdit->Text=aStr; } } mysql_free_result(myRES);

}

Création et exécution de la deuxième requête :

//Création d'une requête dans Reket sprintf(Reket,"%s""%s""%s""%s",Reket1,Trspder,"` FROM àutorisation` WHERE Numerotag = ",aStr); //Recherche d'autorisation en fonction du numéro de Tag if (!mysql_query(mySQL, Reket)) { myRES = mysql_store_result(mySQL); if (myRES) { myROW = mysql_fetch_row(myRES); if(myROW){ aStr = myROW[0]; AutorisationEdit->Text=aStr; autor=aStr; } } mysql_free_result(myRES); }

Ces deux précédentes requêtes nous ont permis de vérifier si le tag est autorisé à passer l'accès demandé. La première sert à connaître le numéro du tag en fonction de son code interne. Le numéro nous est utile pour effectuer la deuxième requête qui est la recherche d'autorisation a proprement parlé. Nous sommes désormais en mesure d'inscrire les données dans la table et d'activer le relais commandant la porte, si le passage est autorisé bien sûr.



Création et exécution de la requête d'inscription, activation relais, fermeture connexion : //Création d'une requête dans Reket Reket1="INSERT INTO `tablelog` (`Transpondeur`,`CodeTag`,`Date`,`Heure`) VALUES ('"; sprintf(Reket,"%s""%s""%s""%s""%s""%s""%s""%s""%s",Reket1,Trspder,"','", TagCod,"','",Datepas,"','",Heurepas,"')"); //Inscription dans la BDD puis déblocage de la porte if (autor=="true") {!mysql_query(mySQL,Reket); sprintf(Mess,"%s""%s""%s","*#",Reader[rd],"020190"); TransObjet.Envoi(Mess); TransObjet.Recevoir(inBuffer,Trspder,TagCod,Datepas,Heurepas); } mysql_close(mySQL);

Les relais sont configurés sur une durée d'activation de 5s. Quand on envoie la commande d'activation, il est indispensable de lire le port. On n'attend aucune information mais le lecteur nous renvoie un message d'acquittement et il est nécessaire de décharger le port série pour pouvoir lire le lecteur suivant. Voyons maintenant en détail, les possibilités de l'IHM Administrateur en matière de recherches et de personnalisation.



IV. L'IHM ADMINISTRATEUR

A. Présentation visuelle et générale des trois onglets Le premier onglet s'intitule "Recherches". C'est par lui que l'administrateur pourra effectuer ses recherches en fonction des critères vus dans le cahier des charges. Il pourra trier les résultats en fonction de chaque catégorie, dans l'ordre décroissant ou croissant.

Le deuxième onglet nommé "Configuration" est utile à la configuration du système. Il permet d'ajouter et de retirer logiciellement les lecteurs de transpondeurs. On peut aussi ajouter de nouveaux tags dans le système.



Le troisième et dernier onglet qui a pour titre "Personnalisation" sert à renommer le porteur d'un tag. Il sert aussi surtout a affecter les autorisations aux différents lecteur et donc aux différents accès.

Voyons maintenant en détail comment fonctionne chaque partie de cette IHM et expliquons quelques morceaux choisis du code source.

B. Présentation et explication de chaque fonction de l'IHM

a) L'onglet "Recherches" Dans cet onglet, il faut tout d'abord choisir une recherche soit par Accès soit par Salarié. Pour une recherche par Accès, une liste déroulante propose tous les lecteurs présents sur la base de donnée :



Pour une recherche par Salarié, une liste déroulante propose tous les utilisateurs enregistrés sur la base de données :

Il faut ensuite préciser la date du jour recherché :

Il ne reste plus qu' à cliquer sur le bouton "Lancer la recherche" et le résultat de la recherche s'affiche sur la gauche (ici, recherche sur Accès READER 08, le 30/03/2005):



Voici le code utilisé pour la recherche et l'affichage, après avoir pris en compte les différents critères : //Recherche des passages en fonction des paramètres if (!mysql_query(mySQL, Reket)) { myRES = mysql_store_result(mySQL); if (myRES) { if (myRES->row_count < 1){ for(int i=0;i<=3;i++){ StringGrid1->Cells[i][1]=""; } ShowMessage("Recherche sans résultat !"); } for(unsigned int i = 0; i < myRES->row_count; i++) { myROW = mysql_fetch_row(myRES); for(unsigned int j = 0; j < mysql_num_fields(myRES); j++) { aStr = myROW[j]; if(j==1){ sprintf(Reket,"%s""%s""%s","SELECT NomUt FROM ùtilisateurs` WHERE CodeTag = '",aStr,"'"); //Recherche du nom utilisateur en fonction du code du Tag if (!mysql_query(mySQL, Reket)) { myRES2 = mysql_store_result(mySQL); if (myRES2) { myROW2 = mysql_fetch_row(myRES2); if(myROW2){ aStr = myROW2[0]; } mysql_free_result(myRES2); } } } StringGrid1->Cells[j][i+1]=aStr; } //Les trois lignes suivantes sont d'ordre purement graphiques if(i>0) StringGrid1->RowCount++; if(StringGrid1->RowCount > 7) StringGrid1->Width=298; else StringGrid1->Width=281; } mysql_free_result(myRES); } }

Si la base de données ne trouve aucun résultat, un message apparaît et avertit l'administrateur qu'aucune occurrence n'existe. Il est possible, pour des raisons pratiques, de trier les données contenues dans le tableau de résultat. Une liste déroulante permet de choisir le champ de tri :



Voici le résultat pour un tri par Salarié dans l'ordre croissant :

Il est possible d'inverser le tri pour un tri décroissant en cochant la case "Inversé" :

Voici le code utilisé pour trier les informations contenues dans le tableau (la méthode de tri employé est la méthode simple de "tri par bulles") :

if(CheckBox17->Checked==false) { for(int i = 1; i < StringGrid1->RowCount - 1; i++) { for(int j=i+1; j < StringGrid1->RowCount; j++) { if(StringGrid1->Cells[Col][i] > StringGrid1->Cells[Col][j]) { StringGrid2->Rows[0]=StringGrid1->Rows[i]; StringGrid1->Rows[i]=StringGrid1->Rows[j]; StringGrid1->Rows[j]=StringGrid2->Rows[0]; } } } } else { for(int i = 1; i < StringGrid1->RowCount - 1; i++) { for(int j=i+1; j < StringGrid1->RowCount; j++) { if(StringGrid1->Cells[Col][i] < StringGrid1->Cells[Col][j]) { StringGrid2->Rows[0]=StringGrid1->Rows[i]; StringGrid1->Rows[i]=StringGrid1->Rows[j]; StringGrid1->Rows[j]=StringGrid2->Rows[0]; } } } } }



b) L'onglet "Configuration" Pour ajouter logiciellement un lecteur de transpondeur il faut débloquer les cases à cocher, par un clic sur "Débloquer" :

Il est alors possible de cocher ou décocher les lecteurs voulus, ce qui a pour effet, on le verra plus loin, de restreindre le choix des autorisations aux uniques lecteurs présents. On n'oubliera pas de cliquer sur "Bloquer" afin que les nouveaux paramètres soient pris en compte :

Cet onglet nous permet aussi d'ajouter de nouveaux utilisateurs. Il suffit de remplir les trois champs prévus à cet effet, que sont le nom de l'utilisateur, le numéro de son tag et le code interne de son tag:



Un message apparaît une fois que l'on a cliqué sur le bouton "Ajouter". Celui-ci a pour but de confirmer l'inscription mais aussi et surtout de prévenir l'administrateur qu'il faut qu'il règle les autorisations. En effet, par défaut, les inscriptions sont réglées sur "false"; l'utilisateur n'a accès nul part.

Voici une partie du code utilisée où l'on voit les requêtes SQL ainsi que l"affichage du message : if (Edit4->Text != "" && Edit5->Text != "" && Edit6->Text != "") { //Création d'une requête dans Reket Reket1="INSERT INTO ùtilisateurs` (`NomUt`,`NumeroTag`,`CodeTag`) VALUES ('"; sprintf(Reket,"%s""%s""%s""%s""%s""%s""%s",Reket1,Edit4->Text, "','",Edit5->Text,"','",Edit6->Text,"')"); mysql_query(mySQL,Reket); Reket1="INSERT INTO àutorisation` (`NumeroTag`,`READER 08`, `READER 12`) VALUES ('"; sprintf(Reket,"%s""%s""%s",Reket1,Edit5->Text,"','false','false')"); mysql_query(mySQL,Reket); ShowMessage("Ajout de "+ Edit4->Text +" ; "+ Edit5->Text +" ; "+ Edit6->Text + "\n\nPensez à régler les autorisations !!"); } else { MessageBox(NULL,"Il manque un ou plusieurs champ(s)","Erreur", MB_ICONERROR ); }

Il est à noter qu'a la suite d'un ajout d'utilisateur, l'application est automatiquement mise à jour. Par exemple dans l'onglet "Recherches", le nouveau salarié est disponible dans la liste :



c) L'onglet "Personnalisation" Pour renommer le porteur d'un tag, il faut tout d'abord choisir le tag à renommer dans la liste déroulante (on note qu'ici le nouvel utilisateur ajouté précédemment est accessible) :

Une fois le champ "Nouveau nom" rempli (l'ancien se remplit automatiquement), on clique sur le bouton "Confirmer". Un message apparaît pour prévenir l'administrateur que le changement est enregistré, la base de données mise à jour :

En sélectionnant un tag, il est aussi possible de modifier les droits d'accès du porteur associé en cochant ou décochant de simples cases. Continuons l'exemple d'un nouvel utilisateur dont il faut régler les droits (aucun par défaut) :



Les cases sont accessibles ou pas en fonction des lecteurs configurés comme étant présents dans l'onglet précédent.

Une fois les réglages finis, un message confirme les changements sur la base de données :

Voici une partie du code qui sert à l'inscription dans la table : b[8].enabled=CheckBox9->Enabled; b[8].caption=CheckBox9->Caption; b[8].checked=LowerCase(BoolToStr(CheckBox9->Checked, true)); b[12].enabled=CheckBox13->Enabled; b[12].caption=CheckBox13->Caption; b[12].checked=LowerCase(BoolToStr(CheckBox13->Checked, true)); mySQL = mysql_init(NULL); if(!mysql_real_connect(mySQL,"127.0.0.1","root","","GestionTranspondeur", 0, NULL, 0)) { MessageBox(NULL,"La connection à la base de donnée MySQL a échouée.\n\n Vérifiez si EasyPHP est en cours de fonctionnement.","Erreur de connection",MB_ICONERROR); } if(b[8].enabled == true){ sprintf(Reket,"%s""%s""%s""%s""%s""%s""%s", "UPDATE autorisation SET `", b[8].caption, "` = '", b[8].checked, "' WHERE NumeroTag='", ComboBox3->Text, "'"); if (!mysql_query(mySQL, Reket)){ } } if(b[12].enabled == true){ sprintf(Reket,"%s""%s""%s""%s""%s""%s""%s", "UPDATE autorisation SET `", b[12].caption,"` = '",b[12].checked,"' WHERE NumeroTag='",ComboBox3->Text,"'"); if (!mysql_query(mySQL, Reket)){ } ShowMessage(Label10->Caption + " :\t" + b[8].caption + " -> " + b[8].checked + "\n\t\t" + b[12].caption + " -> " + b[12].checked); } mysql_close(mySQL);

SEDRATI Abdelyamine BTS IRIS


Candidat n°2 : SEDRATI Abdelyamine

I. PRESENTATION FONCTIONNELLE DE LA PARTIE

Le but de cette partie est de :

- Création d’un code qui sera composé de 4 à 6 caractères maximum. Ce digicode se trouvera à l’entrée du bâtiment ou à l’intérieur, ce code sera crypté et pourra être changé a tous moment de la journée s’il y a des fraudes ou si des intrus entre dans le bâtiment. Ce code pourra être changer par l’administrateur seul.

A. Schéma du digicode à l’entrée du bâtiment

La liaison BUS I2c assurera la transmission des données entre le PC et le digicode qui sera relié en permanence sur le PC sécurité.



B. Description rapide des tâches :

Tâche 1 : Tous d’abords nous devons communiquer avec le DK41

Tâche 2 : Création du code en fonction du DK41 Tâche 3 : Cryptage du code sur le port Ethernet. C’est-à-dire faut que le code s’affiche soit en étoile soit d’autre caractères.

Tâche 4 : Afin de garantir le bon fonctionnement du projet, il convient de mettre en commun et réadapter les différentes tâches. Ici, la tâche 3 est fondamentale puisqu’elle permet de crypté le code pour toutes personne entrant dans ce bâtiment, ainsi il faudra que le projet puisse répondre correctement aux diverses exigences du cahier des charges.



Mise en œuvres des constituants du lot



II. COMMUNICATION AVEC LE DK41

Tous d’abords pour communiquer avec le DK41 il nous faut l’hyper terminal. Voici comment faut-il configurer l’hyper terminal.

Ensuite pour communiquer avec le DK41 il faut faire un programme avec TURBO C++ puis prendre le point EXE et le mettre dans le DK41. Pour pouvoir mettre le point Exe dans le DK41, nous avons besoin du FTP. Nous avons besoin de l’adresse IP du DK41 pour cela nous devons taper la commande IPCFG et là nous avons son adresse IP. Ensuite, nous lançons le FTP puis nous faisons un copier coller du pont EXE dans le FTP puis sur l’hyper terminal nous lançons le point EXE et nous teston le programme.

-Lancer l’hyper terminal donné un nom pour se connecter. -Ensuite on se met sur le port COM1 pas le COM2. -Puis on choisit la vitesse de connexion ici c 19200 Bauds. Nous avons la connexion avec l’hyper terminal



A. Exemple d’un programme de test Voici un programme :

#include <stdio.h> int main() { printf("Hello, world\n"); return 0;

}

Ce programme doit affiché « Hello, world » sur l’hyper terminal



B. Programme du digicode

a) Ici nous avons les déclarations des bibliothèques #define i2c_tast 0x4C // Adr: PCF8574 Tor 6, clavier #define i2c_lcd 0x4E // Adr: PCF8574 Tor 7, LCD

#define OFF 0 // LED mettre en circuit #define ON 1 // LED mettre hors circuit #include <stdio.h> #include <dos.h>

b) Ensuite nous avons l’initialisation du bus I2C

void i2c_init(void) { inregs.h.ah = 0x80; int86(0xAA,&inregs,&outregs);} void i2c_release(void) { inregs.h.ah = 0x84; inregs.h.al = 0; int86(0xAA,&inregs,&outregs);} int i2c_scan( int start_addr, int end_addr) { inregs.h.ah = 0x81; inregs.h.al = start_addr; inregs.h.cl = end_addr; int86(0xAA,&inregs,&outregs); return (outregs.h.al);} int i2c_transmit(char slave, char c) { inregs.h.ah = 0x82; inregs.h.al = slave & 0xFE; inregs.h.cl = c; int86(0xAA,&inregs,&outregs);



if(outregs.x.flags & 0x01){ return (int)outregs.h.al & 0x00FF; } return(0);} int i2c_receive (char slave, char* c, char lastchar) { inregs.h.ah = 0x82; inregs.h.al = slave | 0x01; if(lastchar)inregs.h.cl = 1; // plusieurs signes prendre else inregs.h.cl = 0; // seulement un signe prendre int86(0xAA,&inregs,&outregs); if(outregs.x.flags&0x01){ *c = 0; return (int)outregs.h.al & 0x00FF; } *c = (char)outregs.h.ch; return(0);} void api_sleep(int ms) { inregs.x.ax = 0x0900; inregs.x.bx = ms; int86(0xAC, &inregs, &outregs);}

c) Nous avons l’initialisation du clavier void TastInit(void) { i2c_transmit(i2c_tast, 0xFF); }

d) Traduire les touches du digicode en code ASCII char ScanToAscii (char scan) { switch (scan){ case 0x37: return('1'); case 0x57: return('2'); case 0x67: return('3'); case 0x3B: return('4'); case 0x5B: return('5'); case 0x6B: return('6'); case 0x3D: return('7'); case 0x5D: return('8'); case 0x6D: return('9'); case 0x3E: return('E'); case 0x5E: return('0'); case 0x6E: return('C'); } return(0);}



e) Délai de l’ouverture de la porte

Int ScanTast(void) { static char LastHit=0; char c=0, t=0, h=0, z[]={0x3F,0x5F,0x6F,0x00}, n=0; led(OFF); i2c_receive (i2c_tast,&c,0); // lire un statut i2c_release (); do{ i2c_transmit(i2c_tast,(c&0x8F)|z[n]); // placer la ligne i2c_release(); i2c_receive (i2c_tast,&t,0); // lire un statut i2c_release (); t=t&0x7F; if((t&0x0F)==0x0F) n++; // pas de pression sur la touche else { // une pression sur la touche.. if (t==LastHit){ // .. comme auparavant api_sleep(30); continue; }



else{ // .. à nouveau led(ON); api_sleep(10); i2c_receive (i2c_tast,&h,0); i2c_release(); h=h&0x7F; if (h==t) { LastHit=h; return(ScanToAscii(h)); } } } } while(z[n]!=0); api_sleep(30); LastHit=0; return(0); }

Au début de ce programme, nous déclarons les bibliothèques puis nous initialisons le BUS I2C. Une fois cela effectuer nous initialisons le clavier avec le BUS I2C ensuite traduisons les touche du clavier en code ASCII. Et puis nous faisons un délai pour l’ouverture de la porte si aucune touche n’est appuyée, il y a une LED qui s’allume pour dire qu’il n’y a rien de pressé. Ici c’est un délai de 10 ms et si le code est bon et que la personne na pas ouvert la porte il y a un délai de 30ms après c’est 30ms la porte se referme automatiquement et la personne devra refaire le code pour pouvoir entrée dans bâtiment.



III. DEMONSTRATION DU PROGRAMME



IV. PROGRAMME

#define i2c_tast 0x4C // Adr: PCF8574 Tor 6, clavier #define i2c_lcd 0x4E // Adr: PCF8574 Tor 7, LCD #define OFF 0 // LED mettre en circuit #define ON 1 // LED mettre hors circuit #include <stdio.h> #include <dos.h> void i2c_init(void) { inregs.h.ah = 0x80; int86(0xAA,&inregs,&outregs); } void i2c_release(void) { inregs.h.ah = 0x84; inregs.h.al = 0; int86(0xAA,&inregs,&outregs); } int i2c_scan( int start_addr, int end_addr) { inregs.h.ah = 0x81; inregs.h.al = start_addr; inregs.h.cl = end_addr; int86(0xAA,&inregs,&outregs); return (outregs.h.al); }



int i2c_transmit(char slave, char c) { inregs.h.ah = 0x82; inregs.h.al = slave & 0xFE; inregs.h.cl = c; int86(0xAA,&inregs,&outregs); if(outregs.x.flags & 0x01){ return (int)outregs.h.al & 0x00FF; } return(0); } int i2c_receive (char slave, char* c, char lastchar) { inregs.h.ah = 0x82; inregs.h.al = slave | 0x01; if(lastchar)inregs.h.cl = 1; // plusieurs signes prendre else inregs.h.cl = 0; // seulement un signe prendre int86(0xAA,&inregs,&outregs); if(outregs.x.flags&0x01){ *c = 0; return (int)outregs.h.al & 0x00FF; } *c = (char)outregs.h.ch; return(0); } void api_sleep(int ms) { inregs.x.ax = 0x0900; inregs.x.bx = ms; int86(0xAC, &inregs, &outregs); } void TastInit(void) { i2c_transmit(i2c_tast, 0xFF); }



char ScanToAscii (char scan) { switch (scan){ case 0x37: return('1'); case 0x57: return('2'); case 0x67: return('3'); case 0x3B: return('4'); case 0x5B: return('5'); case 0x6B: return('6'); case 0x3D: return('7'); case 0x5D: return('8'); case 0x6D: return('9'); case 0x3E: return('E'); case 0x5E: return('0'); case 0x6E: return('C'); } return(0); } int ScanTast(void) { static char LastHit=0; char c=0, t=0, h=0, z[]={0x3F,0x5F,0x6F,0x00}, n=0; led(OFF); i2c_receive (i2c_tast,&c,0); // lire un statut i2c_release (); do{ i2c_transmit(i2c_tast,(c&0x8F)|z[n]); // placer la ligne i2c_release(); i2c_receive (i2c_tast,&t,0); // lire un statut i2c_release (); t=t&0x7F; if((t&0x0F)==0x0F) n++; // pas de pression sur la touche else { // une pression sur la touche.. if (t==LastHit){ // .. comme auparavant api_sleep(30); continue; }



else{ // .. à nouveau led(ON); api_sleep(10); i2c_receive (i2c_tast,&h,0); i2c_release(); h=h&0x7F; if (h==t) { LastHit=h; return(ScanToAscii(h)); } } } } while(z[n]!=0); api_sleep(30); LastHit=0; return(0); }

REBIHA Fahim BTS IRIS


Candidat n°3 : REBIHA Fahim

I. PRESENTATION FONCTIONNELLE DE LA PARTIE Le but de cette partie consiste à réaliser un module logiciel permettant une communication entre le DK41 et l’afficheur ainsi que l’horloge/calendrier. Cette partie se déroulera en plusieurs étapes, à savoir :

la conception d’une IHM sur le PC sécurité de réglage, par intranet, de la date et de l’heure du module externe « horloge/calendrier » ( pcf8583 ), la fabrication d’un programme permettant de faire communiquer le DK41

avec l’interface P I/O pcf8574, pour une gestion de l’afficheur, par le biais du bus I²C, la fabrication d’un programme permettant de faire communiquer le DK41

avec le pcf8583, par le biais du bus I²C.

Les tests des programmes réalisés seront effectués, dans un premier temps, avec l’hyperterminal . Il s’agit de réaliser quelques tests sur le DK41.



II. APPLICATIONS SUR LE DK41. Dans un premier temps, il nous est demandé de comprendre le fonctionnement de notre PC embarqué. Ce PC embarqué, DK41, est l’association du microcontrôleur SC12 et le module d’adaptation DK40. Ensemble, ils géreront les périphériques que sont l'afficheur LCD, le digicode, l'horloge calendrier, la gâche et le détecteur de la porte ainsi que les lecteurs de transpondeurs, par le biais de port série ( bus I²C ), port Ethernet 10base-T pour le serveur ftp que nous utiliserons. La communication entre l’hyperterminal et le DK41 se fait par liaison série RS232.

A. Dialogue avec l’hyperterminal. Afin d’avoir une première approche avec le système, j’ai crée un simple programme sous TC .

#include<stdio.h> #include<string.h> #pragma –1 \\ permet la communication avec le 80186 du DK41. Void main (void) { printf(« Projet afficheur 2005 ») ; }

Une fois ce programme compilé, je transfert l’exécutable dans le serveur ftp du DK41, par le biais du réseau. Et je peux ensuite l’exécuter depuis l’hyperterminal. Les commandes RTOS sont simples d’utilisation.



Voici un tableau des commandes RTOS les plus utiles : • DEL nom de fichier Effacer un ou plusieurs fichiers ( DEL TEST.EXE ou DEL *.DAT )

• DIR nom de fichier Afficher le contenu d'un répertoire ( DIR HTTP ou DIR *.EXE )

• TYPE fichier Afficher le contenu d'un fichier dans la console ( TYPE CHIP.INI )

• COPY fichier 1 fichier 2 Copier un fichier, on donne le nom du fichier source et de destination

• REN fichier 1 fichier 2 Renommer un fichier, on donne l'ancien nom suivi du nouveau

• MD répertoire Créer un répertoire ( Make Directory ) ex: MD TEST

• CD répertoire Changer de répertoire ( CD TEST )

• RD répertoire Effacer un répertoire ( RD TEST )

• IP adresse Définir l'adresse IP du chip et désactive le DHCP

• NETMASK masque Définir le masque de sous réseau ( désactive également le DHCP )

• GATEWAY adresse Définir l'adresse de la passerelle ( ces 3 infos sont stockées dans CHIP.INI )

• DHCP 0/1 Activer / Désactiver le client DHCP

• IPETH Redémarrer l'interface Ethernet sans avoir à redémarrer tout le système

• TCPIPMEM Afficher la quantité de mémoire utilisée par TCPIP

• FTP 0/1 Activer / Désactiver le serveur FTP ( info stockée dans CHIP.INI )

• IPCFG Afficher la configuration IP

• REBOOT Redémarrer le système

• MEM Afficher les informations concernant la mémoire

• CGISTAT Lister tous les CGI qui sont exécutés

• CLOSETELNET Clore une session Telnet

• WEBSTAT Afficher les paramètres du serveur Web

• PING Tester la connexion avec la commande ICMP ping

• TASKS Lister toutes les tâches qui sont actives

• HELP Afficher toutes les commandes console disponibles

(la liste complète peut être trouvée sur le site de Beck http://www.bcl-online.de/download/documentation/api/api102B/command.htm)



En exécutant ce programme, il apparaît tout simplement dans la fenêtre de l’hyperterminal :

B. Paramétrage du chip. Le chip utilise essentiellement 2 fichiers de configuration: CHIP.INI ( le plus important ) et AUTOEXEC.BAT. Le fichier CHIP.INI comprend toute la configuration proprement dite c'est à dire que c'est dans ce fichier que l'on définit la configuration IP, si on active ou désactive les serveurs Web ou FTP etc ...



Voici notre CHIP.INI : [IP] ADDRESS=192.168.0.166 NETMASK=255.0.0.0 DHCP=0 [TELNET] ENABLE=1 [WEB] ENABLE=1 MAINPAGE=INDEX.HTM DRIVE=0 ROOTDIR=\HTTP\ HTTPPORT=80 [FTP] ENABLE=1 CMDPORT=21 L'ensemble des paramètres qui peuvent figurer dans le fichier CHIP.INI est expliqué sur le site de Beck: http://www.bcl-online.de/download/documentation/api/api102B/config.htm Le fichier AUTOEXEC.BAT peut contenir des commandes ou des programmes à exécuter lors du démarrage du système. L’approche du système étant réalisée, je peux m’intéresser à l’étude de la communication entre le DK41 et l’afficheur via le bus I²C et le circuit interface qu’est le pcf8574.

L’adresse IP est 192.168.0.166 avec un masque de sous réseau de 255.0.0.0 et le client DHCP est désactivé.

Le serveur Telnet est activé.

Le serveur Web est activé, la page principale est le fichier INDEX.HTM, le serveur utilise le port 80.

Le serveur FTP est activé et il utilise le port 21.



III. COMMUNICATION ENTRE LE DK41 ET L’AFFICHEUR Pour créer cette communication, nous utiliserons le logiciel Borland C++ Builder. On utilisera la même méthode pour transférer l’exécutable dans le PC embarqué, à savoir via ftp.

A. pcf8574

Pour dialoguer avec l’afficheur, le DK41 nécessite d’une interface. Dans notre cas de figure, il s’agit du pcf8574A . Ce composant, connecté sur le bus I²C, peut avoir des adresses différentes. Celles-ci sont réglables directement sur la carte, via les jumpers des bits A0 A1 A2. Sur cette carte, l’adresse du composant est $70. Les bits A0 A1 A2 étant tous les trois à 0. 0 1 1 1 A2 A1 A0 R /W

Groupe 1 Groupe 2

Les bits du groupe 1 sont invariables et dépendent de la classe du composant ( pcf8574 ou pcf8574 A ). Ceux du groupe 2 permettent de différencier les différents composants sur un même bus. En effet, on peut mettre jusqu’à 8 fois ce composant sur le bus I²C. Un programme a été mis au point pour détecter la présence de composants, ainsi que leur adresse, sur le bus I²C. Voici l’initialisation du bus I²C qui sera la même pour tous les programmes :

void i2c_init() { inregs.h.ah = 0x80; int86(0xAA,&inregs,&outregs); }



Voici les fonctions principales fournit par le constructeur :

#include <stdio.h> #include <dos.h> static union REGS inregs; static union REGS outregs; // Fonctions API du bus I²C // ----------------------------- void i2c_init() { inregs.h.ah = 0x80; int86(0xAA,&inregs,&outregs); } void i2c_release(void) { inregs.h.ah = 0x84; inregs.h.al = 0; int86(0xAA,&inregs,&outregs); } int i2c_scan(int debut, int fin) { inregs.h.ah = 0x81; inregs.h.al = debut & 0x00FF; inregs.h.cl = fin & 0x00FF; int86(0xAA,&inregs,&outregs); return (int)outregs.h.al & 0x00FF; }



Voici le programme principal :

void main (void) { int debut=0x00, fin =0xFF, resultat, n=0; printf("\n\n"); printf(" I2C_scan\n"); printf(" --------\n"); i2c_init(); while(1) { resultat = i2c_scan(debut, fin); if (resultat == -1) { printf(" Erreur sur le bus\n"); break;} if (resultat == 0) { printf(" keine (weiteren) Bauteine gefunden\n"); break;} else { printf(" Baustein %d, Adresse %Xh\n",++n,resultat); debut = resultat+2;} } i2c_release(); printf(" ---------------------------------------\n"); printf(" I2C_scan \n"); }

Une fois exécuté, ce programme permet de trouver tous les composants présents sur le bus I²C, notamment le pcf8574. Ce programme détectera chaque adresse de chaque composant. L’interface avec se fait toujours par le biais de l’hyperterminal.



Avec le pcf8574 connecté sur le bus ayant pour adresse $70, voici ce qu’on obtient à l’écran :

Et ainsi nous pouvons obtenir toutes les adresses des composants.



B. pcf8583 Ce composant est notre circuit dit « horloge/calendrier ». C’est ici que sera sollicité l’heure ainsi que la date qui seront affichées sur le LCD. Ce composant sera également connecté au bus I²C (cf. partie commune III. B. pour les schémas de câblages ). Dans la même optique du composant pcf8574, son adresse est détectable par le programme précédent. Cette dernière est également réglable. 1 0 1 0 0 0 A0 R /W L’adresse du pcf8583 présent sur la carte est $A0, le bit A0 étant réglable. La présence de ce circuit est très importante, étant donné que le cahier des charges impose de connaître l’heure et la date de passages à l’entrée principale. Il nous faut donc impérativement mettre au point un programme qui permettra de lire les informations contenues dans le circuit afin de les restituer sur l’afficheur de manière ordonnée. Le bus I²C étant présent, il nécessite d’être initialiser. Donc on retrouve le même programme d’initialisation à chaque fois, vu précédemment. Voici la déclaration des variables :

#include <stdlib.h> #include <stdio.h> #include <bios.h> // Adresse du pcf 8583 #define I2C_uhr 0xA0 static union REGS inregs; static union REGS outregs; // Variables unsigned int jahr; unsigned char monat, tag, tagnr; unsigned char stunde, minute, sekunde; char *wotag[]= {"So","Mo","Di","Mi","Do","Fr","Sa","So"};



Voici l’initialisation du bus :

void I2C_init () { inregs.h.ah = 0x80; // SoftINT AAh, Fonction 80h int86(0xAA,&inregs,&outregs); } void I2C_release (void) { inregs.h.ah = 0x84; // SoftINT AAh, Fonction 84h inregs.h.al = 0; int86(0xAA,&inregs,&outregs); } int I2C_scan (unsigned char start_addr, unsigned char end_addr) { inregs.h.ah = 0x81; // SoftINT AAh, Fonction 81h inregs.h.al = start_addr; inregs.h.cl = end_addr; int86(0xAA,&inregs,&outregs); return outregs.h.al; } int I2C_transmit(unsigned char slave, char c) { inregs.h.ah = 0x82; // SoftINT AAh, Fonction 82h inregs.h.al = slave & 0xFE; inregs.h.cl = c; int86(0xAA,&inregs,&outregs); if(outregs.x.flags&0x01){ return (int)outregs.h.al & 0x00FF; } return(0); }



Voici les fonctions d’initialisation de la date (datum) et de l’heure ( zeit ).

void holedatum(void) { inregs.h.ah = 0x2A; // SoftINT 21h, Funktion 2Ah int86(0x21,&inregs,&outregs); jahr =outregs.x.cx; // année 4 Chiffres monat =outregs.h.dh; // mois 1-12 tag =outregs.h.dl; // jours 1-31 tagnr =outregs.h.al; // jour férié, 0-dimanche } void setzedatum(void) { inregs.h.ah =0x2B; // SoftINT 21h, Funktion 2Bh inregs.x.cx =jahr; // année 4 Stellen inregs.h.dh =monat; // mois 1-12 inregs.h.dl =tag; // jours 1-31 inregs.h.al =tagnr; // jour férié, 0-dimanche int86(0x21,&inregs,&outregs); } void holezeit(void) { inregs.h.ah = 0x2C; // SoftINT 21h, Funktion 2Ch int86(0x21,&inregs,&outregs); stunde =outregs.h.ch; // heures 1-23 minute =outregs.h.cl; // Minutes 0-59 sekunde =outregs.h.dh; // secondes 0-59 } void setzezeit (void) { inregs.h.ah = 0x2D; // SoftINT 21h, Funktion 2Dh inregs.h.ch =stunde; // heures 1-23 inregs.h.cl=minute; // Minutes 0-59 inregs.h.dh=sekunde; // Secondes 0-59 int86(0x21,&inregs,&outregs); }




void main (void) { const char LANG=10; char buffer[LANG+1] = ""; setStdio(2); holedatum(); printf("\nDate: %s %0.2d:%0.2d:%0.4d",wotag[tagnr], tag, monat, jahr); printf("\b\b\b\b\b\b\b\b\b\b"); // date obtenue et réglée stringin (buffer, 10); if (datetovar(buffer,':')) setzedatum(); holedatum(); printf("\rDate: %s %0.2d:%0.2d:%0.4d", wotag[tagnr], tag, monat, jahr); holezeit(); printf("\nHeure: %0.2d:%0.2d:%0.2d", stunde, minute, sekunde); printf("\b\b\b\b\b\b\b\b"); // heure obtenue et réglée stringin (buffer, 8); if (timetovar(buffer,':')){ setzezeit(); I2C_init(); // I2C-Bus initialisation if(I2C_scan(0xA0, 0xA0)==0xA0){ // Test I2C_release(); I2C_transmit(I2C_uhr,0x00); I2C_transmit(I2C_uhr,0x80); I2C_transmit(I2C_uhr,0x99); holedatum(); holezeit(); I2C_transmit(I2C_uhr,(char)DEZtoBCD(sekunde)); I2C_transmit(I2C_uhr,(char)DEZtoBCD(minute)); I2C_transmit(I2C_uhr,(char)(DEZtoBCD(stunde)&0x003F)); I2C_transmit(I2C_uhr,(char)((jahr%4)<<6)+(DEZtoBCD(tag)&0x003F)); I2C_transmit(I2C_uhr,(char)(tagnr<<5)+(DEZtoBCD(monat)&0x001F)); I2C_release(); I2C_transmit(I2C_uhr,0x00); I2C_transmit(I2C_uhr,0x04);



I2C_release(); I2C_transmit(I2C_uhr,0x10); I2C_transmit(I2C_uhr,jahr>>8); I2C_transmit(I2C_uhr,jahr&0x00FF); I2C_release(); } } holezeit(); printf("\rHeure: %0.2d:%0.2d:%0.2d", stunde, minute, sekunde); setStdio(3); }

Voici ce que l’on obtient dans la fenêtre de l’hyperterminal :

La date et l’heure sont malheureusement réglées par le biais de l’hyperterminal, en déplaçant le curseur à l’endroit souhaité afin de parvenir au réglage. Les informations entrées sont gardées en mémoire par le composant. Si l’on re-exécute le programme, sans coupé la première connexion avec l’hyperterminal, il sera affiché l’heure à laquelle le programme a été lancé. Dans le cas contraire, les informations seront erronées et relatives au composant. Une étude plus approfondie aurait permit de résoudre ces inconvénients.



C. Ecrire sur l’afficheur Ayant dialogué avec l’hyperterminal, on peut maintenant s’intéresser à la communication entre le DK41 et l’afficheur. Il nous faut donc, comme pour les autres applications, créer un programme qui permettra cette liaison. Voici les déclarations et bibliothèques :

#define i2c_lcd 0x70 // Adresse du PCF8574A d'après la doc \\technique (groupe 1 (0111=0x70)) dialogue avecc le LCD) #include <stdio.h> #include <dos.h> static union REGS inregs; static union REGS outregs;



Voici l’initialisation du bus I²C : La fonction api_sleep :

void api_sleep(int ms) { inregs.x.ax = 0x0900; inregs.x.bx = ms; int86(0xAC, &inregs, &outregs); }

void i2c_init(void) { inregs.h.ah = 0x80; int86(0xAA,&inregs,&outregs); } void i2c_release(void) { inregs.h.ah = 0x84; inregs.h.al = 0; int86(0xAA,&inregs,&outregs); } int i2c_scan( int start_addr, int end_addr) { inregs.h.ah = 0x81; inregs.h.al = start_addr; inregs.h.cl = end_addr; int86(0xAA,&inregs,&outregs); return (outregs.h.al); } int i2c_transmit(char slave, char c) { inregs.h.ah = 0x82; inregs.h.al = slave & 0xFE; inregs.h.cl = c; int86(0xAA,&inregs,&outregs); if(outregs.x.flags & 0x01){ return (int)outregs.h.al & 0x00FF; } return(0); }



void lcd_init (void); // initialisation du LCD void cmdout (char c); // envoie la consigne void chrout (char c); // envoie les données void stringout(char *c); // envoie une chaîne de caractères sur un port série

La fonction lcd_init :

void lcd_init (void) { api_sleep(15); // envoie de RS=0, R/W=0, D7=0, D6=0, D5=1, D4=1 i2c_transmit(i2c_lcd,0x03); // -RS -RW -E 0 0 1 1 E=0 i2c_transmit(i2c_lcd,0x13); // -RS -RW E 0 0 1 1 E=1 i2c_transmit(i2c_lcd,0x03); // -RS -RW -E 0 0 1 1 E=0 i2c_release(); api_sleep(5); // envoie le même bite durant 100µs i2c_transmit(i2c_lcd,0x03); // -RS -RW -E 0 0 1 1 E=0 i2c_transmit(i2c_lcd,0x13); // -RS -RW E 0 0 1 1 E=1 i2c_transmit(i2c_lcd,0x03); // -RS -RW -E 0 0 1 1 E=0 i2c_release(); api_sleep(1); i2c_transmit(i2c_lcd,0x03); // -RS -RW -E 0 0 1 1 E=0 i2c_transmit(i2c_lcd,0x13); // -RS -RW E 0 0 1 1 E=1 i2c_transmit(i2c_lcd,0x03); // -RS -RW -E 0 0 1 1 E=0 i2c_transmit(i2c_lcd,0x02); // -RS -RW -E 0 0 1 0 E=0 i2c_transmit(i2c_lcd,0x12); // -RS -RW E 0 0 1 0 E=1 i2c_transmit(i2c_lcd,0x02); // -RS -RW -E 0 0 1 0 E=0 cmdout(0x28); cmdout(0x0F); // Displ.on, Curs.on, Blink.on cmdout(0x01); // efface l'écran api_sleep(5); } // atente de 5ms



La fonction cmdout :

void cmdout (char c) { int hb=c>>4, lb=c&0x0F; // DatenByte zerlegen // High HalbByte senden i2c_transmit(i2c_lcd,0x00+hb); // -RS -RW -E h h h h i2c_transmit(i2c_lcd,0x10+hb); // -RS -RW E h h h h i2c_transmit(i2c_lcd,0x00+hb); // -RS -RW -E h h h h // Low Halbbyte senden i2c_transmit(i2c_lcd,0x00+lb); // -RS -RW -E l l l l i2c_transmit(i2c_lcd,0x10+lb); // -RS -RW E l l l l i2c_transmit(i2c_lcd,0x00+lb); // -RS -RW -E l l l l i2c_release(); }

La fonction chrout

void chrout (char c) { int hb=c>>4,lb=c&0x0F; // DatenByte zerlegt // High HalbByte senden i2c_transmit(i2c_lcd,0x40+hb); // RS -RW -E h h h h i2c_transmit(i2c_lcd,0x50+hb); // RS -RW E h h h h i2c_transmit(i2c_lcd,0x40+hb); // RS -RW -E h h h h // Low HalbByte senden i2c_transmit(i2c_lcd,0x40+lb); // RS -RW -E l l l l i2c_transmit(i2c_lcd,0x50+lb); // RS -RW E l l l l i2c_transmit(i2c_lcd,0x40+lb); // RS -RW -E l l l l i2c_release(); }



La fonction stringout :

void stringout (char *c) { int n=0, hb=0, lb=0; while (c[n]!=0){ hb=c[n]>>4; lb=c[n]&0x0F; // DatenByte zerlegen // High HalbByte senden i2c_transmit(i2c_lcd,0x40+hb); // RS -RW -E h h h h i2c_transmit(i2c_lcd,0x50+hb); // RS -RW E h h h h i2c_transmit(i2c_lcd,0x40+hb); // RS -RW -E h h h h // Low HalbByte senden i2c_transmit(i2c_lcd,0x40+lb); // RS -RW -E l l l l i2c_transmit(i2c_lcd,0x50+lb); // RS -RW E l l l l i2c_transmit(i2c_lcd,0x40+lb); // RS -RW -E l l l l n++; } i2c_release(); }


void main (void) { // I2C-Bus initialisation i2c_init(); // Test 8574-LCD if(i2c_scan(i2c_lcd, i2c_lcd)!=i2c_lcd){ i2c_release(); printf ("LCD non trouvé"); return; } // LCD initialisation lcd_init(); // on affichera sur le LCD stringout(" Projet Afficheur"\n); stringout(" Rebiha Fahim "); // I2C-Bus relâché i2c_release(); }



Une fois ce programme mis en place, il permettra d’afficher dans un premier temps sur la première ligne de l’afficheur : « Projet Afficheur ». Dans un programme plus élaboré, on pourra faire intervenir la date et l’heure présentes dans le pcf8583 pour l’introduire dans l’afficheur, afin de répondre réellement aux attentes du cahier des charges.



ANNEXES DK41 Allocation des pattes du @Chip SC12

pin description pin description

PIO7 / RXD0 VCC

PIO8 / TXD0 I2CCLK / DRQ1 / INT6 / PIO0

PIO9 / ENRX0# / CTS0 I2CDAT / DRQ0 / INT5 / PIO1

PIO10 / RTR0 / RTS0 A2 / PCS6# / PIO2

PIO11 / TXD1 A1 / PCS5# / TMRIN1 / TMROUT1 / PIO3

PIO12 / INT3 / RXD1 A0 / PCS1# / TMRIN0 / PIO4

PIO13 / INT0 / TMROUT0 RTS1# / PCS3# / INT4 / PIO5

AD0 CTS1# / PCS2# / INT2 / PIO6

AD1 ALE / PCS0#

AD2 WR#

AD3 RD#

AD4 TPRX-

AD5 TPRX+

AD6 TPTX-

AD7 TPTX+

GND RESET# / NMI / LINK LED



Caractéristiques techniques:

Processeur 80186 cadencé à 20MHz (16 Bit CPU)

Mémoire 512 Ko de RAM, 515 Ko de mémoire Flash

Système d'exploitation RTOS avec un système de fichier basé sur une mémoire Flash

Transferts (mise à jour)

Téléchargement de programmes via le port série ou par le réseau ethernet

Protocoles supportés

TCP/IP, PPP, HTTP, FTP, Telnet, POP3, SMTP et DHCP

Ports de communication

Ethernet 10BaseT 2 ports série rapides avec TTL-RS232 RXD, TXD, CTS, RTS Bus I²C, Watchdog

Autre caractéristiques

2 Timer externes et 2 Timer internes br> Détection de coupures de courant (NMI) avec conservation de données AD-bus multiplexé compatible Intel® 14 bornes d'E/S programmables Boîtier DIL32 - 22 x 44 x 9,5mm (profondeur x longueur x hauteur)



Le system peut être mis à jour en flashant le BIOS via le port série.

Il existe plusieurs version du BIOS (6 exactement) intégrant plus ou moins de fonctionnalités, ce qui permet d'économiser de la mémoire si on n'utilise pas toutes les fonctionnalités du chip.

Voilà un tableau récapitulatif des différentes versions du BIOS qui sont proposées officiellement par le constructeur. On peut les télécharger a l'adresse suivante:

http://www.bcl-online.de/mdownload/download.asp?id=20&status=en_download

Tiny Small Medium Large

RTOS-Kernel x x x x

Serial x x x x

RTOS-Filesystem x x x x

Ext Disk x x

XMODEM-Protocol x x x x

TCPIP-Ethernetdriver x x x

Ethernet Packet-Interface x x x x

TCP-IP x x x

I2C x x x x

Hardware API x x x x

CFG server x x x

Webserver x

FTP Server x x

Telnet Server x x

PPP only with Medium & Large

PPP client & server x x



L'IPC@CHIP possède 512 ko de RAM et 512 ko de mémoire Flash, le tableau ci-dessous montres la quantité de mémoire disponible avec les différentes versions de BIOS version 1.02 Beta (dernière version disponible en avril 2002)

Available RAM(kBytes) Available Flash memory(kBytes)

Tiny 451 388

Small 354 281

Medium 348 250

Medium_PPP 343 198

Large 322 227

Large_PPP 317 175

BUS I²C

SON PROTOCOLE Le protocole de ce bus va être décrit dans sa version 2.1, même s'il n’a pas subi de changement significatif depuis sa version initiale (mode high-speed uniquement). Ce protocole est défini par la succession des états que peuvent prendre les signaux SDA et SCL. Ce protocole est relativement simple et puissant à la fois. Il peut être décomposé en plusieurs parties distinctes :

1 La prise de parole.

2 Condition de départ

3 Adresse destinataire

4 Mode Lecture/Ecriture

5 Acquittement

6 Donnée en Lecture/Ecriture

7 Acquittement

8 Condition d’arrêt



Exemple d’une trame sur le bus I²C

En fait, il est possible de décomposer cette trame en deux parties, les bits de A6 à ACK peuvent être vus comme la première partie et ceux de D7 à ACK comme la seconde. Ces deux parties n’étant que la mise en place de l’adresse destinataire et de la donnée transmise ou reçue.

La prise de parole

Avant d’initier un dialogue sur le bus, chaque composant doit s’assurer que le bus est libre. Pour ce faire, le composant maître vérifie que les lignes SDA et SCL sont au repos (état haut) et ce pendant une durée de 4,7µs, temps constructeur désigné par THD ;STA

Condition de départ

Toujours présente, la condition de "Start" est définit par un changement de la ligne de donnée alors même qu’elle n’a pas été validée par l’horloge. La condition pour initier ce départ étant l’état ‘1’ sur les lignes SDA et SCL. La condition de "Start" a lieu lors du passage de la ligne de donnée à ‘0’ alors même que l’horloge reste à ‘1’.

Condition de Start

Adresse du destinataire

Il s’agit ici du morceau de trame qui comporte les plus grandes traces de l’histoire du bus I²C. Dans sa forme primitive, le CBUS, ancêtre de ce bus, imposait une adresse sur 7 bits. Afin de garantir cette compatibilité CBUS, il a fallu adapter l’adresse 10 bits des nouvelles versions du Bus I²C avec son histoire.

Adressage sur 7 bits



On peut voir sur le schéma ci-dessus que l’adressage se fait du bit le plus fort vers le bit le plus faible, le huitième bit sera décrit dans la section suivante. L'établissement d'une adresse sur 10 bits s’effectue en deux temps : Dans un premier temps, on envoie un octet comprenant les 2 bits de poids fort de l’adresse. Le quartet premier ne doit comporter que des 1 et le second quartet commence par un 0 les deux bits représentant les deux bits de poids fort de l’adressage sur 10 bits, le dernier étant celui de Lecture/Ecriture. Le maître doit maintenant attendre le bit de validation (Acknowledgement), il peut être donné par plusieurs composants à la fois, tous ceux commençant par cette adresse. La seconde partie de l’adresse sera donc transmise une fois l’accusé reçu.

Adressage sur 10 bits

Il existe plusieurs variantes de cette méthode d’adressage car, notamment sur les mémoires, il faut effectuer un adressage interne du composant, cette seconde adresse étant transmise après l’accusé de la première adresse. Afin de répondre à certaines fonctions du bus, il est nécessaire d’avoir des adresses spécifiques permettant des opérations particulières. Si l’adresse est à 0 et le bit de Lecture/Ecriture à 0, il s’agit d’un appel général ou plus communément appelé BroadCast. Si l’adresse est à 0 et le bit de lecture écriture à 1, il s’agit d’un "octet de départ", il peut être envoyé avant le transfert réel afin de palier aux problèmes des composants les plus lents, notamment ceux simulant le protocole de manière logiciel.

Liste de différents modules :

ADRESSE ESCLAVE

Bit R/W Description Donnée Description

0000 000 0 Appel Général

0000 0110

RESET, remet tout les registres dans leurs états initiaux (mise sous tension), les circuits qui le permettent rechargent leur adresse esclave

0000 0010

Les composants qui le permettent rechargent leur adresse esclave

0000 0100

Les composants, définissant leur adresse esclave de manière matériel, réinitialisent leur adresse.

0000 0000 Interdit



xxxx xxx1

Cette commande joue le rôle d’interruption, x peut être l’adresse du composant qui a généré l’interruption.

0000 000 1 Octet de départ 0000 001 X Adresse CBUS 0000 010 X Format de bus différents

0000 011 X Réservé pour utilisation future

0000 1XX X Réservé pour utilisation future

1111 1XX X Réservé pour utilisation future

1111 0XX 1 Adresses d’esclave à dix bits

Mode Lecture/Ecriture

Plus communément appelé R/W, il s’agit du huitième bit du premier octet. Il sera toujours mis en bit de poids le plus faible de l’octet de l’adresse. Son utilité réside dans le faite d’indiquer à l’esclave appelé, s'il s’agit d’une lecture ou d’une écriture qui sera effectuée.

Acquittement

Effectué par l’esclave, ce bit permet de signaler au maître qu’il existe bien un composant à l’adresse indiquée. Son utilisation est un peu spéciale et est possible que par la technologie électronique mise en œuvre dans le concept du bus I²C. Le maître doit maintenir la ligne SDA à l’état haut, l’esclave mettra à bas la ligne SDA, il ne reste donc plus qu’au maître de lire l’état de la ligne SDA. Il n’existe pas de normalisation du délai après lequel l’esclave sera considéré comme inexistant.

Exemple d'acquittement



Légende SCL Horloge du bus SDAM Niveaux imposés par le maître SDAE Niveaux imposés par l’esclave SDAR Niveaux résultant sur le bus

Donnée en Lecture/Ecriture

Il s’agit de la deuxième partie de la trame ; elle contient les données circulant sur le bus. S’il s’agit d’une lecture, le maître met à ‘1’ le niveau du SDA et l’esclave se charge de descendre à ‘0’ ce niveau pour former l’octet résultant d’une lecture, chaque bits étant bien entendu délimité par l’horloge SCL.

Exemple d’une lecture


S’il s’agit d’une écriture, le niveau du SDA va être contrôlé par le maître, l’esclave écoutant en appliquant un niveau haut sur le bus.



Exemple d’une écriture


Dans le cas où les données seraient plus importantes en lecture ou en écriture, la seconde partie de la trame (Donnée + Ack) est répétée autant de fois que nécessaire.

Exemple d’écriture de plusieurs octets

Acquittement

Il s’agit de nouveau d’un accusé de réception, mais de la donnée cette fois-ci. Cependant, selon s’il s’agit d’une écriture ou d’une lecture, le niveau de ce bit varie. En effet, lors d’une lecture, ce bit est à ‘1’ car l’esclave n’a pas à accuser le fait qu’il ait fini d’envoyer ces données. Lors d’une écriture, l’esclave met à ‘0’ le niveau du bus, donnant ainsi un accusé de réception de la donnée. Ceci est une notion importante faisant la spécificité de cet acquittement par rapport à celui de l’adresse.

Condition d’arrêt

La condition de "Stop" est à l’inverse de la condition de "Start". La réalisation de cette condition sous-entend au préalable que les lignes SDA et SCL soient au niveau ‘0’. Cette condition remplie, la ligne SDA passe au niveau ‘1’, puis c’est au tour de la ligne SCL de passer



au niveau ‘1’. Un fois ce signal donné, tous les composants sont dans un état de veille et ne réagiront qu’à la prochaine condition de "Start".

Condition de Stop

LA GESTION DES CONFLITS

La structure même du bus I²C ayant été conçue pour accueillir plusieurs maîtres, se pose alors le problème de la prise de parole.

Comme il a été vu précédemment, chaque maître test le bus pendant une période de 4,7 µs avant de l’utiliser.

Cependant, il n’est pas impossible que deux maîtres prennent la parole en même temps.

Si cela ne pose pas de problème au niveau électronique (collecteur ouvert), il faut quand même pouvoir détecter cette collision afin d’éviter toutes corruptions de données.

La solution réside dans le fait que chaque composant doit relire ce qu’il a envoyé et comparer.

Lors d’un conflit potentiel, trois cas se présentent :

1 Les deux maîtres parlent tous deux de façon identique, il n’y a donc aucun problème, mais ce cas ne se présente que très rarement.

2 Un des maîtres impose un ‘0’ sur le bus alors que l’autre maître impose un ‘1’, la résultante en sera 0, le maître premier ne pourra pas alors détecter le conflit, les données résultantes du bus seront correctes pour lui.

3 Un des maîtres impose un ‘1’ sur le bus alors que l’autre maître impose un ‘0’, la résultante étant ‘0’, les données du bus lui paraîtrons corrompu, il devra donc cesser sa discussion sur le bus.

Exemple d’un conflit



Le maître qui doit s’arrêter après détection de la collision n’est pas forcément celui qui a commencé en second, il s’agit avant tout du maître qui a envoyé un ‘1’ en premier alors que le second a envoyé un ‘0’.

La communication du maître ayant été perturbée s’arrête, l’autre maître peut quant à lui continuer sans problèmes à transmettre ces données.

La donnée ‘1’ s’effaçant devant la donnée ‘0’, cette différence lors d’un conflit, fait apparaître des priorités sur le bus.

C’est ainsi que l’on peut dire que si deux maîtres prennent la parole en même temps, leur adresse va faire la différence.

Les adresses les plus basses seront donc prioritaires. La puissance de transfert de ce bus réside donc dans le fait qu’un maître qui entre en collision avec un autre continuera ou laissera l’autre maître terminer sa trame, contrairement à d’autres protocoles où les deux maîtres se seraient arrêtés pour reprendre après. Quelques Adresses Utiles :

Adresse Nom Fonction A6 A5 A4 A3 A2 A1 A0

... Adresse de communication générale 0 0 0 0 0 0 0

... Adresses Réservées 0 0 0 0 X X X

... Octet de poids fort en adressage 10 bits 1 1 1 1 1 A9 A8

PCF8574 Port d'E/S 8bits 0 1 0 0 A2 A1 A0 PCF8574A Port d'E/S 8bits 0 1 1 1 A2 A1 A0

PCF8583 Horloge / Calendrier avec RAM statique 1 0 1 0 0 0 A0

Documents

PROJET - jonathanm12.free.frjonathanm12.free.fr/RapportdeProjetJMartins.pdf · passer ou pas, tel ou tel accès ... PC sécurité et fera partie intégrante de la base donnée,