Dernière mise à jour le 28/12/2020
Présentation
Dans cet article, nous allons étudier le fonctionnement du debugger I2C de proteus, et nous ferons des essais sur un expender de ports 8 bits type PCF8574A ainsi qu’un essais sur une EEPROM 24C08B livrée sur la platine EasyPicV7.
Ces 2 composants fonctionne sous le protocole I2C, et nous pouvons dire aussi que d’une manière générale la lecture et l’écriture sur des EEPROMs est réalisé en I2C. Nous verrons comment on pilote ces 2 composants via leurs adresses, comment écrire dans leurs registres (adresse interne) pour stocker ces valeurs.
Une EEPPROM permet de stocker non pas des logiciels mais des données et il s’agit d’une mémoire non volatile, c’est-à-dire que cette mémoire s’efface électriquement (par logiciel ou reprogrammation) et non pas sur une coupure générale de l’alimentation et c’est bien tout son avantage , car elle garde en mémoire les données enregistrées. On l’utilise dans des appareils photos, dans des voitures, etc..etc…
Le faite de stocker des données, celle-ci sont accessibles via l’EPPROM.
Présentation debugger I2C Proteus (ISIS)
Nous allons étudier le fonctionnement du débugger I2C de Proteus afin de savoir comment l’utiliser pour simuler des montages électroniques.
Tout d’abord, il est représenté sous cette forme et comporte 3 pattes qui sont :
SDA = La broche SDA est une ligne de données bidirectionnelle pour le bus I2C.
SCL = La broche SCL est une broche bidirectionnelle qui est connectée à la ligne d’horloge du bus I2C.
TRIG = La broche TRIG est une entrée qui entraîne le placement des séquences mémorisées successives dans la file d’attente de sortie. (Nous nous attarderons pas sur cette broche dans l’explication).
Le bus I2C, utilise une transmission de données sur 11 bits qui comprend :
- 1 bit de start nommé « S »
- 8 bits de données « 00000010b » ou « 0x02 » (en HEX)
- 1 bit d’acquittement « N » (ACK)
- 1 bit de stop nommé « P »
Au total nous avons bien nos 11 bits consécutifs.
Remarques : il est possible d’envoyer des données sur 10 bits plutôt que 7 bits et cela ne change rien aux principes de fonctionnement. (Nous verrons aussi ces différents cas un peu plus loin).
Le debugger I2C permet de faciliter grandement nos montages choses afin de pouvoir tester nos montages électronique via la liaison I2C en peu de temps !
ATTENTION !! Avant toute chose, il est fortement conseillé de configurer toutes les résistances en mode « DIGITAL » et d’utiliser l’alimentation « POWER » 
cas contraire le montage en simulation ne fonctionnera pas comme attendu !
Le principe de fonctionnement I2C est le suivant ou nous avons :
1 bit de start
Le bit start lui permet de donner le départ en disant « attention à tous des données sont envoyées sur la trame I2C ». Il commence par la lettre « S ».
7 bits de données
Ensuite nous avons les 7 bits de données avec le bit de poids faible (bit 0) qui correspond soit à la lecture représenté par R = Read (état haut) ou en écriture représenté par W = Write (état bas). Ceci est très important car en fonction si nous sommes lecture ou en écriture nous allons écrire sur l’esclave ou bien lire les données de l’esclave (nous verrons tous ceci un peu plus loin).
1 bit d’acquittement (ACK)
Ce bit est généré automatiquement via l’appareil. ces données sont séparé par la lettre « N » via le debugger I2C.
1 bit de stop
Ce dernier bit quant à lui précise qu’il s’agit la fin de transmission des données et il se termine par la lettre « P ».
Comment ça marche ?!
Avant toute chose il faut déjà avoir bien le protocole en tête et voir comment les données sont envoyées sur le bus I2C. Reprenons la figure ci-dessus, les 2 lignes correspondent aux 2 fils – SDA et SCL (L’horloge).
SCL est l’horloge représenté par des rectangles noirs, la fréquence peut varier en fonction des composants électroniques. En effet certains peuvent fonctionne sur 100Khz ou bien d’autre sur 400Khz. Le fonctionnement ne change pas c’est juste la vitesse de transmission qui va plus ou moins vite !
SDA ce sont les données qui seront transmisses sur le BUS I2C sur chaque coups d’horloges. C’est l’horloge qui va cadencer les fronts montant pour l’envoie des données I2C.
Bit de start (en bleu)
La couleur bleu correspond au bit de start, à ce moment l’horloge retombe à l’état logique bas « 0 » pour commencer à cadencé les données
Adresse
Le protocole I2C, a une particularité, car les 9 premiers bits correspondent à l’adresse, et ensuite va suivre les données. Le premier « paquet » correspond à l’adresse physique du composants avec lequel nous désirons communiquer / dialoguer soit en écriture soit en lecture.
Sur les 7 bits (bit 0 à bit 7), si nous désirons écrire sur ce composant, dans ce cas le bit représenté de couleur verte qui correspond au bit de poids le plus faible (bit 0) sera à l’état logique bas « 0 », et en mode lecture il sera à l’état logique haut « 1 ».
Ensuite (bit 1 à bit 7) nous écrivons l’adresse du composants sur lequel nous désirons réaliser quelque chose (Lecture/Ecriture). Et pour finir, derrière s’enchaîne un bit d’acquittement (couleur orange) qui lui est généré automatiquement. Ce bit d’acquittement peut ou ne peut être généré la encore une fois tout dépend du matériel utilisé (on le verra dans l’exemple 1 qui va suivre).
Données
Nous écrivons les données
Bit de stop
Fin de l’envoie de la trame I2C sur le composant.Bon arrêtons les explications et passons à la pratique !!!
Exemple 1 – PCF8574A – Mode Ecriture
Dans cet exemple nous allons utiliser le PCF8574A qui est un expender de port 8 bits.Le principe est le suivant, nous allons lui envoyer des trames I2C sur ses broches SDA et SCL afin de pouvoir allumer les 8 leds qui refléteront les données envoyées sur le BUS I2C. Nous verrons en détails le principe.
1 – Analyse du composant PCF8574A + réglage fréquence debugger I2C
Le PCF8574A peut être alimenté entre 2.5V et 6V maxi, et nous l’alimenterons en 5V. La fréquence d’utilisation pour le PCF8574A est de 100Khz maxi.
Ainsi nous pouvons désormais commencer à configurer le debugger I2C sur 100Khz soit 100000 Hz comme ceci :
2 – Réglage adresse du composant PCF8574A
Comme nous l’avons vu précédemment, pour pouvoir communiquer avec le PCF8574A, il faut connaître son adresse. C’est comme dans la réalité lorsque le facteur veut vous envoyer du courrier il lui faut votre adresse.
La fiche technique du PCF8574A indique ceci :
J’ai décidé de choisir la 1er ligne, ou le constructeur stipule qui les broches A0/A1/A2 doivent être reliées à la masse. Dans cette configuration, j’ai décidé de régler arbitrairement l’adresse sur 0111000 ce qui donne 38h en hexadécimal, c’est cette adresse que nous recherchons du PCF8574A (comme vous pouvez le constater on retrouve en hexadécimal 38h à l’extrémité du tableau ci-dessus.)
– En mode lecture l’envoi sera de 01110001 ce qui donne 71h en hexadécimal;
– En mode écriture l’envoi sera de 01110000 ce qui donne 70h en hexadécimal;
(Même chose ces valeurs sont aussi situées dans le tableau du constructeur du PCF8574A)
Avant d’aller plus loin commençons par réaliser le schéma électronique :
En ce qui concerne l’alimentation du bargraph, chaque leds consomme environ 10mA pour une tension directe de 1,8V la résistance à ajouter en série sera donc de R = (5 – 1,8)/0.010 = 320 Ohms. Soit 8 résistances de 330 Ohms ferons bien l’affaire !
Les résistances R1 et R2 sont obligatoires car celle-ci sont ici pour faire ce qu’on appelle le PULL-UP (résistances de tirages) sur le bus I2C. Encore une fois ces résistances peuvent varier en fonction de la fréquence utilisé (100Khz ou 400Hz ou …) et en fonction aussi de la longueur de la liaison I2C (en règle général la communication I2C se fait sur des petites longueurs, je ne rentrerais pas dans les détails sur l’explication car ce n’est pas le but de cet article).
Revenons à nos moutons ! Nous avons à présent réalisé :
1/ La configuration du debugger I2C à 100Khz.
2/ Câblé A0/A1/A2 à la masse pour obtenir l’adresse 0111000 ce qui donne 38h en hexadécimal.
3/ Calculer les valeurs des résistances R3 à R10 pour la protection des leds du baragraph.
Il ne reste plus qu’à passer sur la transmissions des données I2C et de voir ensemble en détails le bit de start , bit d’acquittement etc.. etc..
3 – Communication I2C – Maître/Esclave
Le maître correspond dans notre montage au débugger I2C c’est lui qui va être le chef d’orchestre et qui va décider si nous désirons réaliser une lecture ou une écriture. L’esclave, quant à lui concerne le PCD8574A c’est lui qui va se soumettre à ce que demande le maitre et d’exécuter les consignes du maître.
En mode écriture vous trouvez ci-dessous le protocole I2C du fonctionnement du PCF8574A.
Dans le 1er « paquet » on y retrouve l’adresse de l’esclave « slave adresse » qui celle-ci a été configurée précédemment (38h) puis le bit de poids le plus faible (bit 0 = R/W) à l’état logique bas « 0 » donc en écriture !
Lorsque l’adresse va être reconnu par l’esclave, celui-ci va générer un bit d’acquittement afin d’informer le maître comme quoi l’adresse reçu correspond à l’esclave et qu’il est prêt à exécuter les consignes que le maitre va lui donner.
Une fois le bit d’acquittement généré par l’esclave, le maître va donc écrire afin de transmettre à l’esclave les :
data1 = données 1 concerne la 2ème « paquet »,
data2 = données 2 concerne la 3ème « paquet ».
data3 = etc.. etc..
Côté debugger ISIS regardons ça de plus prêt
La syntaxe pour écrire ce genre de protocole n’est pas du tout compliquée il suffit de respecter le principe ainsi que majuscule comme ceci :
{SEQUENCE000=S 0x70 N 0x38 N P} en HEXA
Peut s’écrire aussi:
{SEQUENCE000=S 01110000b N 00111000b N P} en BINAIRE
Il est vrai que la 2ème écriture en mode binaire permet de mieux voir les bits
Côté débugger cela donne :
Nous avons ici écrit notre première trame I2C, ne reste plus qu’à lancer proteus pour voir le comportement.
Si vous regardez bien les leds qui sont allumées correspondent aux données (Data1 figure un peu plus haute) que nous avons envoyé sous la forme 00111000b.
Nouvelle séquence avec – 01010101b
Je vais modifier l’envoi tout en gardant la même adresse avec le bit0 en écriture ce qui donne côté adresse (inchangé) 01110000b + Data1 = 01010101b et nous devrions voir une leds sur 2 allumées.
Côté debugger ISIS cela nous donne une 2ème séquences soit:
{SEQUENCE001=S 01110000b N 01010101b N P}.
Essayons ça pour voir!
Exemple 2 – PCF8574A – Mode Lecture
Nous avons vu précédemment comment écrire sur le PCF8574A, regardons maintenant comment lire les données. (revenir au paragraphe 2 – Réglage adresse du composant PCF8574A pour relire la fiche technique du constructeur pour ceux qui se retrouve directement ici)
1 – Communication I2C – Maître/Esclave
Le maître correspond dans notre montage toujours au débugger I2C ,et cette fois-ci le chef d’orchestre va interroger l’esclave en passant le bit0 à l’état logique 1 (Lecture). L’esclave, quant à lui concerne le PCD8574A c’est lui qui va donc envoyer ses données au maître.
En mode lecture vous trouvez ci-dessous le protocole I2C du fonctionnement du PCF8574A.
Dans le 1er « paquet » on y retrouve l’adresse de l’esclave « slave adresse » qui celle-ci a été configurée précédemment (38h) puis le bit de poids le plus faible (bit 0 = R/W) à l’état logique haut « 1 » donc en lecture !
Lorsque l’adresse va être reconnu par l’esclave, celui-ci va générer un bit d’acquittement afin d’informer le maître comme quoi l’adresse reçu correspond à l’esclave et qu’il est prêt à exécuter les consignes que le maitre va lui donner.
Une fois le bit d’acquittement généré par l’esclave, ce dernier va transmettre au maître ses données:
Lecture 0x05 – 0000101b
Le montage electronique consiste à mettre sur l’esclave des siwtchs qui seront manipulé afin de modifier les données. nous allons mettre les siwtchs de sorte à obtenir le chiffre 5 en hexadecimal soit 0x05 donne 00000101b (en binaire) le schéma electronique devient donc ceci:
Côté debugger, il faut donc lire les données de l’esclave PCF8574A pour cela il suffit de faire appel à son adresse et en mode lecture comme ceci, (sans oublier le bit0 à l’état logique haut “1” – {SEQUENCE002=S 01110001b N P} ainsi nous obtenons:
regardons maintenant côté simulation ce que cela nous donne
Lecture 0x07 – 0000111b
Observer bien je vais changer les switchs en les passant à 0x07 en hexa soit 0000111b
EEPROM – 24C08B (sur platine EasyPic V7) – Mode Ecriture
Sur ma platine EasyPicV7, j’ai une EEPROM type 24C08 livrée avec, et qui a la particulartié d’avoir 8K bytes de mémoire non volatile. L’alimentation du 24C08 se fait aussi sous une tension de 5V et la fréquence du BUS I2C est sous 100Khz.
Pour rappel 1 byte = 1 octet = 8 bits ce qui donne 255 en décimal de possibilité.
Pour être puriste, en définitive ce n’est pas 8K bytes exact, mais plutôt 8192 bytes car 1Kilobyte correspond à 1024 bytes ce qui donne 20 6661 120 en décimal de possibilité! (simple règle de 3 à appliquer via le petit rappel juste au dessus ;-).
Le fonctionnement est différent du PCF8574A mais le principe reste identique. En effet, le 24C08 a toujours une adresse « slave adresse » comme représenté sur la figure ci-dessous:
mais la particularité, c’est que vous pouvez écrire sur ses pages… Mais qu’est ce que cela veux bien dire ??!!
Ce qu’il faut comprendre c’est que l’EEPROM, est organisée en 4 ou 8 blocs de 256 octets soit:
(4 x 256 x 8) ou (8 x 256 x 8) c’est à dire, un octet de contrôle est le premier octet reçu après la condition de démarrage du périphérique maître. L’octet de commande consiste en un code de commande à 4 bits, pour le 24C08B, il est défini comme binaire 1010 pour les opérations de lecture et d’écriture. Les trois bits suivants de l’octet de commande sont les bits de sélection de bloc (B2, B1, B0). Ils sont utilisés par le dispositif maître pour sélectionner lequel des huit blocs de mémoire de 256 mots doit être accédé. Ces bits sont en fait les trois bits les plus significatifs de l’adresse de mot. Le dernier bit de l’octet de contrôle définit l’opération à effectuer. Lorsqu’il est réglé sur un, une opération de lecture est sélectionnée, lorsqu’il est réglé sur zéro, une opération d’écriture est sélectionnée. Suite à la condition de démarrage, le 24C08B surveille le bus SDA en vérifiant l’identifiant du type d’appareil transmis, sur un code 1010, l’appareil esclave émet un signal d’acquittement sur le Ligne SDA. En fonction de l’état du bit R / W, le 24C08B sélectionnera une opération de lecture ou d’écriture.
|
// Ecriture
{SEQUENCE000=S 10100000b N 00001000b N 00000001b N P} {SEQUENCE001=S 10100000b N 00001001b N 00000010b N P} {SEQUENCE002=S 10100000b N 00001010b N 00000011b N P} {SEQUENCE003=S 10100000b N 00001011b N 00000100b N P} |
(Copier et coller ce code dans le debugger I2C)
Le code ci-dessous permet d’écrire sur 4 adresse différentes qui sont:
Add N°8 – 0x08 (00001000b) – Valeur = 0x01 (00000001b)
Add N°9 – 0x09 (00001001b) – Valeur = 0x02 (00000010b)
Add N°10 – 0x0A (00001010b) – Valeur = 0x03 (00000011b)
Add N°11 – 0x0B (00001011b) – Valeur = 0x04 (00000100b)
Nous avons toujours, adresse de l’esclave, adresse sur la page que nous désirons écrire, et la valeur que nous allons ajouter dans l’adresse correspondante avec le dernier bit (bit0 en rouge) à l’état logique bas ce qui nous permet d’écrire
{SEQUENCE000=S 10100000b N 00001000b N 00000001b N P}
{SEQUENCE001=S 10100000b N 00001001b N 00000010b N P}
{SEQUENCE002=S 10100000b N 00001010b N 00000011b N P}
{SEQUENCE003=S 10100000b N 00001011b N 00000100b N P}
Si on se refaire à la doc technique du constructeur et si on fait une analogie avec ce qui est indiqué ci-dessus la correspondance est identique et on remarque bien que le bit avant “ACK” (acquittement) est à l’état logique bas “0”.
Ici nous faisons rien de plus que d’écrire dans les adresses correspondantes !
EEPROM – 24C08B (sur platine EasyPic V7) – Mode Lecture
En ce qui concerne le montage électronique rien n’a changé.
cependant la seule chose qui va changée c’est la partie code du debugger I2C, et ici nous faisons que de lire les données situées dans l’EPPROM 24C08B.
|
// Lecture adresse : 8 -> 0x08
{SEQUENCE004=S 10100000b N 00001000b N P} {SEQUENCE005=S 10100001b N P} – // Lecture adresse : 9 -> 0x09 {SEQUENCE006=S 10100000b N 00001001b N P} {SEQUENCE007=S 10100001b N P} – // Lecture adresse : 10 -> 0x0A {SEQUENCE008=S 10100000b N 00001010b N P} {SEQUENCE009=S 10100001b N P} – // Lecture adresse : 11 -> 0x0B {SEQUENCE010=S 10100000b N 00001011b N P} {SEQUENCE011=S 10100001b N P} |
Code debugger I2C complet + test
Il suffit de copier ce code dans le debugger comme ceci:
|
// Ecriture
{SEQUENCE000=S 10100000b N 00001000b N 00000001b N P} {SEQUENCE001=S 10100000b N 00001001b N 00000010b N P} {SEQUENCE002=S 10100000b N 00001010b N 00000011b N P} {SEQUENCE003=S 10100000b N 00001011b N 00000100b N P} – // Lecture adresse : 8 -> 0x08 {SEQUENCE004=S 10100000b N 00001000b N P} {SEQUENCE005=S 10100001b N P} – // Lecture adresse : 9 -> 0x09 {SEQUENCE006=S 10100000b N 00001001b N P} {SEQUENCE007=S 10100001b N P} – // Lecture adresse : 10 -> 0x0A {SEQUENCE008=S 10100000b N 00001010b N P} {SEQUENCE009=S 10100001b N P} – // Lecture adresse : 11 -> 0x0B {SEQUENCE010=S 10100000b N 00001011b N P} {SEQUENCE011=S 10100001b N P} |
Afin de remplacer le code d’un manière “plus compact” en l’occurence celui-ci:
|
// Ecriture
{SEQUENCE000=S 10100000b N 00001000b N 00000001b N P} {SEQUENCE001=S 10100000b N 00001001b N 00000010b N P} {SEQUENCE002=S 10100000b N 00001010b N 00000011b N P} {SEQUENCE003=S 10100000b N 00001011b N 00000100b N P} – // Lecture adresse : 8 -> 0x08 {SEQUENCE004=S 10100000b N 00001000b N P} {SEQUENCE005=S 10100001b N P} – // Lecture adresse : 9 -> 0x09 {SEQUENCE006=S 10100000b N 00001001b N P} {SEQUENCE007=S 10100001b N P} – // Lecture adresse : 10 -> 0x0A {SEQUENCE008=S 10100000b N 00001010b N P} {SEQUENCE009=S 10100001b N P} – // Lecture adresse : 11 -> 0x0B {SEQUENCE010=S 10100000b N 00001011b N P} {SEQUENCE011=S 10100001b N P} |
deviendra comme ci-dessous, ajout de “Sr” qui permet de faire un “restart” on relance tout de suite derrière par des nouvelles données
|
// Ecriture
{SEQUENCE000=S 10100000b N 00001000b N 00000001b N P} {SEQUENCE001=S 10100000b N 00001001b N 00000010b N P} {SEQUENCE002=S 10100000b N 00001010b N 00000011b N P} {SEQUENCE003=S 10100000b N 00001011b N 00000100b N P} – // Lecture adresse : 8 -> 0x08 {SEQUENCE004=S 10100000b N 00001000b N Sr 10100001b N P} – // Lecture adresse : 9 -> 0x09 {SEQUENCE005=S 10100000b N 00001001b N Sr 10100001b N P} – // Lecture adresse : 10 -> 0x0A {SEQUENCE006=S 10100000b N 00001010b N Sr 10100001b N P} – // Lecture adresse : 11 -> 0x0B {SEQUENCE007=S 10100000b N 00001011b N Sr 10100001b N P} |
Historiques
28/12/2020
-1er mise à disposition
