Sie sind auf Seite 1von 22

MSSP en mode I2C ISET Kairouan

LE PORT SERIE SYNCHRONE MSSP EN MODE I2C

1. Introduction
1.1. Présentation
I²C (pour Inter Integrated Circuit Bus) est le nom du bus historique, développé par Philips
Semiconductor pour les applications de domotique et d’électronique domestique au début des années
1980, notamment pour permettre de relier facilement à un microprocesseur les différents circuits d’une
télévision « moderne ».

1.2. Caractéristiques
Il présente les propriétés suivantes :
 C’est un bus série synchrone bifilaire utilisant une ligne de donnée appelé SDA (Serial Data) et une
ligne d’horloge appelé SCL (Serial clock). Une masse commune doit être connectée (figure 1).
 Les données peuvent être échangées dans les deux sens sans restriction ;
 Le bus est multi- maitres ;
 Chaque abonné dispose d’une adresse unique codée sur 7 ou 10 bits. On peut donc connecter
simultanément 128 ou 1024 abonnés d’adresses différentes sur le même bus (sous réserve de ne pas le
surcharger électroniquement) ;
 Un acquittement est généré pour chaque octet de donnée transféré ;
 Le bus peut travailler à une vitesse de 100Kbit/s mode standard et 400Kbits/s en mode rapide voire
même 1Mbit/s pour les circuits les plus récents (High speed mode).

Figure 1 : Architecture I²C

 Au repos, SDA et SCL sont au niveau haut. Elles peuvent être uniquement être forcées au niveau bas.
On ne peut pad les forcer au niveau haut ;

 Le module qui demande le transfert de données et qui génère l’horloge est le maître, le module qui
répond est un esclave. Un même système peut disposer de plusieurs maîtres, on le nomme alors
multi-maître. Dans ce cas, il faut arbitrer la discussion entre les différents modules.

1.3. Principe de bus I2C

Comme les lignes SDA et SCL sont au repos au niveau haut, les composants (maîtres, esclaves) I²C ne
peuvent donc que les forcer qu’à l’état bas. Pour éviter les conflits électriques, le fonctionnement impose aux
circuits des sorties à collecteur (figure 2) ouvert ou à drain ouvert pour SDA et SCL.

1
MSSP en mode I2C ISET Kairouan

Figure 2: Connexions à collecteur ouvert

2. Protocole du bus I2C


1. Prise de contrôle de bus
 Le bus doit être au repos avant la reprise de contrôle (SDA et SCL à 1 logique)
 Pour transmettre des données il faut surveiller :
 la condition de départ : SDA passe à 0, SCL reste à 1
 la condition d’arrêt : SDA passe à 1, SCL reste à 1
 Apres avoir vérifié que le bus est libre puis prendre le contrôle de celui-ci, le circuit en devient le
maitre : c’est lui qui génère le signal d’horloge.

Figure 3: Bus I²C, Bit de Start et Bit de Stop

2. Transmission d’un octet


Le format d'une trame standard est reproduit dans le tableau 1.

S Adresse R/W ACK Donnée ACK … Donnée ACK P

Tableau 1: Trame I²C

2
MSSP en mode I2C ISET Kairouan

 S : bit de Start, est la condition de départ : SDA passe de l’état haut à l’état bas pendant que SCL est au
niveau haut (cf. figure 2).
 Adresse : représente celle du module à laquelle on veut s ‘adresser, elle est composée de 7 bits A0 à A6.
 A6A5A4A3 sont fixés par l’I²C commitee. A2A1A0 sont libres pour nous permettre de mettre plusieurs
fois le même esclave sur le bus (au maximum 8).
 R/W (Read Write) : est le bit de mode de transmission. S’il est à 0, on est en mode écriture, c’est le
maître qui envoie des données à l’esclave. S’il est à 1, on est en mode lecture, c’est l’esclave qui envoie
des données au maître. L’Adresse et R/W sont transmis ensemble ce qui forme un mot de 8 bits.
 ACK : bit d’acquittement, il a lieu à la fin de chaque transmission d’un mot pour dire que le récepteur a
bien reçu les données. Après, l’envoi du mot de 8 bits, au coup d’horloge, le récepteur force SDA à
l’état bas.
 Donnée : sont les huit bits de données que l’on transmet.
 P : bit de stop, est la condition de stop. SDA passe de l’état bas à l’état haut pendant que SCL est au
niveau haut (cf. figure 3).

a) Transmission d’une adresse


Le nombre des composants est important, d’où la nécessité de définir chacun une adresse unique.
L’adresse codée sur 7 bits est définie par :
 son type
 l’état appliqué à un certain nombre de ces broches

L’adresse transmise est sous la forme d’un octet au format particulier :


 D7 à D1 : 7 bits d’adresse A6 à A0
 D0 : bit R/W qui détermine si le maitre veut lire ou écrire

Figure 4: Transmission d’une adresse

b) Ecriture d’une donnée


Le maitre envoi l’adresse de destination et sélectionne le mode Ecriture (R/W à 0) puis envoi la donnée.
A chaque fois, le maitre attend le ACK avant de poursuivre.

Figure 5: Séquence d’Ecriture

c) Lecture d’une donnée


 Le maitre envoi l’adresse puis attend le ACK
 l’ACK est positionné par l’esclave, puis celui-ci émet les données sur SDA
 ensuite le maitre positionne le ACK à 0 pour continuer lecture, ou à 1 pour stopper la transmission.

Figure 6: Séquence d’Ecriture

3
MSSP en mode I2C ISET Kairouan

3. Collision de bus en mode multi-maitre


a) Problème
Le bus I2C est de conception destiné à accueillir plusieurs maitres. Chaque maitre peut prendre la
possession du bus des que celui-ci est libre. Possibilité que deux maitres prennent le bus au même temps.
Le problème ne se pose pas électriquement puisqu’on fonctionne à collecteur ouvert, mais on doit éviter la
corruption des données due à la collision des bits transmis.

b) Prise de contrôle de bus


 Le maitre doit vérifier que le bus est libre
 La condition d’arrêt doit être envoyée depuis au moins 4,7μs
 La prise de contrôle est effectif mais le maitre doit vérifier l’état des lignes SDA et SCL. Plusieurs
cas peut se produire :
 différents maitres envoient les mêmes données au même temps : aucun conflit (cas rare)
 un maitre impose un ‘0’ : il relire obligatoirement un ‘0’ et continuera à transmettre
 un autre maitre cherche à appliquer un ‘1’ sur le bus :
s’il lit ‘1’, il continu à transmettre
s’il lit ‘0’, cela veut dire qu’un autre maitre a pris la parole au même temps : il perd dans ce
cas l’arbitrage et arrête d’émettre

Exemple :

SDA1 : Niveaux de SDA imposés par le maitre N°1


Figure 7 : Séquence de collision
SDA2 : Niveaux de SDA imposés par le maitre N°2
SDAR : Niveaux de SDA réels résultants lus par les deux maitres.

Les deux maitres imposent les mêmes données, le premier octet sera alors transmis normalement.
Pour le deuxième octet, le maitre N°2 impose ‘1’ mais relit ‘0’ ; il perd le contrôle du bus et devient esclave.
Le maitre N°1 ne voit pas le conflit et continue d’émettre normalement, et l’esclave reçoit les données sans
erreurs.

4
MSSP en mode I2C ISET Kairouan

3. Fonctionnement du MSSP en mode I2C (PIC 18F4520)


Le module MSSP supporte tous les protocoles de dialogue du bus I2C en maitre et en esclave. Il gère les
adresses codées sur 7 bits et 10 bits.
Il permet la génération d’interruptions matérielle
suite à une condition de départ ou une condition
d’arrêt.
Le module MSSP utilise 6 registres pour
l’exploitation du mode I2C :
 le registre de contrôle N° 1 : SSPCON1 ;
 le registre de contrôle N° 2 : SSPCON2 ;
 le registre d’état SSPSTAT ;
 le registre tampon (Buffer)
d’émission/réception : SSPBUF ;
 le registre à décalage, non directement
accessible, SSPSR ;
 le registre d’adresse : SSPADD.

Le registre SSPBUF contient la donnée à émettre ou


la donnée reçu selon le sens de fonctionnement du
circuit. En mode réception, ce registre forme, avec le
registre à décalage SSPSE, un système à double
tampon qui permet de lire un caractère alors que le
suivant est en cours de réception. Figure 8 : Schéma synoptique du mode I2C

En mode esclave, le registre SSPADD contient l’adresse de l’esclave. Lorsque le SSP est configuré en mode
maître, les 7 bits du poids faible du SSPADD représentent le compteur du générateur d’horloge.
Vitesse en baud= FOSC/(4 * (SSPADD + 1))
Au mode adresse 10 bits, l’utilisateur doit tout d’abord écrire les bits de poids forts de cette adresse dans le
registre SSPADD (11110A9 A8 0) puis après une comparaison réussie avec les informations reçues, y écrire
les 8 bits de poids faibles

3.1. Les registre de contrôle et d’état

a) Le registre d’état SSPSTAT

R/W R/W R R R R R R
SSPSTAT SMP CKE D/A P S R/W UA BF
Bit 7 Bit 0

bit 7 SMP : Slew Rate Control bit


1 = Ce bit invalide la vitesse de montée pour le mode standard à 100Khz
0 = Le contrôle de la vitesse de montée, pour le mode rapide à 400KHz, est validée

5
MSSP en mode I2C ISET Kairouan

bit 6 CKE : SMBus Select bit


1 = Les niveaux d’entrée sont conformes à la norme SMBus
0 = Les niveaux d’entrée sont conformes à la norme I2C
bit 5 D/A : Data/Address bit (en mode esclave)
1 = Le dernier octet émis ou reçu est une donnée
0 = Le dernier octet émis ou reçu est une donnée
bit 4 P : Stop bit
1 = Indique qu’une détection d’une condition d’arrêt a eu lieu
0 = Pas de Détection d’une condition d’arrêt
bit 3 S : Start bit
1 = Détection d’une condition de départ
0 = Pas de Détection d’une condition de départ
bit 2 R/W : Read/Write Information bit
En mode esclave : 1 = (Read) opération de lecture
0 = (Write) opération d’écriture
En mode maître : 1 = Emission en cours
0 = Pas d’émission
bit 1 UA: Update Address bit (10-Bit Slave mode only)
1 = Indique qu’il faut charger le registre SSPADD avec l’octet de poids faible de l’adresse
0 = Pas besoin de charger le registre SSPADD
bit 0 BF: Buffer Full Status bit
1 = Le registre SSPBUF est plein
0 = Le registre SSPBUF est vide

b) Le registre de contrôle SSPCON1


R/W R/W R/W R/W R/W R/W R/W R/W
SSPCON1 WCOL SSPOV SSPEN(1) CKP SSPM3 SSPM2 SSPM1 SSPM0
Bit 7 Bit 0

bit 7 WCOL : Write Collision Detect bit


En mode maître ce bit mis à 1 lors d’une tentative d’écriture dans le registre SSPBUF alors
que les conditions I2C correspondantes ne sont pas satisfaites. Ce bit doit être mis à 0 par
logiciel
En mode esclave ce bit mis à 1 lors d’une tentative d’écriture dans le registre SSPBUF alors
que l’octet précédent est en cours d’émission. Ce bit doit être mis à 0 par logiciel
bit 6 SSPOV: Receive Overflow Indicator bit
1 = une nouvelle donnée est reçu alors que le contenu précédent du registre SSPBUF n’a pas
encore été lu. Ce bit est sans signification en mode émission
0 = pas de Overflow
bit 5 SSPEN: Master Synchronous Serial Port Enable bit
1 = valide le module SSP et les lignes SCL et SDA sont avtives
0 = invalide le module SSP
bit 4 CKP: SCK Release Control bit (en mode esclave)
1 = l’horloge SCL fonctionne normalement
0 = l’horloge SCL maintenu en niveau bas

6
MSSP en mode I2C ISET Kairouan

en mode maitre ce bit n’est pas utilisé


bit 3-0 SSPM<3:0>: Master Synchronous Serial Port Mode Select bits
ces bits permettent de sélectionner le mode de fonctionnement du MSSP selon les indications
suivante :
1111 = I2C esclave, adresse 10 bit, validation d’interruption sur conditions de départ et d’arrivée
1110 = I2C esclave, adresse 7-bit, validation d’interruption sur conditions de départ et d’arrivée
1011 = I2C maître à contrôle logiciel
1000 = I2C maître
0111 = I2C esclave, adresse 10 bit
0110 = I2C esclave, adresse 7 bit

c) Le registre de contrôle SSPCON2


R/W R/W R/W R/W R/W R/W R/W R/W
SSPCON1 GCEN ACKSTAT ACKDT ACKEN RCEN PEN RSEN SEN
Bit 7 Bit 0

bit 7 GCEN : General Call Enable bit (Slave mode only)


1 = autorise la génération d’une interruption lorsqu’un appel général d’adresse 0000 est reçu
dans le registre SSPSR
0 = désactive l’appel général
bit 6 ACKSTAT: Acknowledge Status bit (Master Transmit mode only)
1 = l’acquittement n’a pas été reçu depuis l’esclave
0 = l’acquittement est reçu depuis l’esclave
bit 5 ACKDT: Acknowledge Data bit (Master Receive mode only)
bit d’acquittement d’une séquence de réception maître. Son contenu est transmis en fin de
séquence. Compte tenu du protocole I2C, il indique un acquittement s’il est à 0 et une absence
d’acquittement s’il est à 1
bit 4 ACKEN: Acknowledge Sequence Enable bit (Master Receive mode only)
ce bit autorise l’émission automatique d’une séquence d’acquittement et transmet le bit
ACQDT lorsqu’il est mis à 1. Il est automatiquement remis à 0 par le circuiterie d’interface
I2C interne
bit 3 RCEN: Receive Enable bit (Master mode only)
1 = autorise le mode réception
0 = désactive le mode réception
bit 2 PEN: Stop Condition Enable bit (Master mode only)
1 = émission d’une condition d’arrêt sur les pins SCL et SDA. Automatiquement remis à 0.
0 = désactive la condition d’arrêt
bit 1 RSEN: Repeated Start Condition Enable bit (Master mode only)
1 = émission d’une condition de départ répété. Automatiquement remis à 0.
0 = désactive la condition de départ répété
bit 0 SEN: Start Condition Enable/Stretch Enable bit
1 = émission d’une condition de départ. Automatiquement remis à 0.
0 = désactive la condition de départ

7
MSSP en mode I2C ISET Kairouan

3.2. Fonctionnement en mode I2C esclave


En mode esclave les lignes SDA et SCL doivent être configurées en entrées en configurant correctement les
bits du registre TRISC correspondant.
Lorsqu’une égalité d’adresse a lieu ou lorsqu’un transfert des données a lieu après la réception d’une adresse
valide, la logique intégrée au niveau du port se charge automatiquement de la génération de l’impulsion
d’acquittement et charge ensuite le registre SSPBUF avec la donnée reçue temporairement contenue dans le
registre à décalage SSPSR.

a) Réception en mode esclave


Lorsque le bit R/W de l’octet d’adresse est positionné à 0 et qu’une égalité d’adresse se produit, une
interruption d’origine MSSP est générée pour chaque transfert de donnée ayant lieu sur le bus I2C.
L’indicateur d’interruption SSPIF remis à 0 par logiciel. Le contenu du registre SSPSTAT doit être utilisé
pour connaitre l’état de la donnée reçue.
La figure 9 représente le chronogramme d’une réception de donnée en mode esclave avec une adresse de 7
bits.

Figure 9 : Chronogramme de réception en mode esclave

b) Emission en mode esclave


Lorsque le bit R/W de l’octet d’adresse est positionné à 1 et qu’une égalité d’adresse se produit, le bit R/W
du registre SSPSTA est également mis à 1. L’adresse reçue est alors chargée dans le registre SSPBUF. Une
impulsion d’acquittement est alors envoyée.
Les données à émettre doivent être chargées dans le registre SSPBUF qui les transfère dans le registre
SSPSR. Les 8 bits de ce dernier registre sont envoyés sur la ligne SDA sur le front descendant de l’horloge
présente sur la ligne SCL.
Une interruption d’origine SSP est générée pour chaque octet de donnée envoyé. Le bit d’indication
d’interruption SSPIF est positionné lors du front descendant de la 9ème impulsion d’horloge SCL.
L’indicateur d’interruption SSPI doit être remis à 0 par logiciel.
La figure 10 représente le chronogramme d’une émission de donnée en mode esclave avec une adresse de 7
bits.

8
MSSP en mode I2C ISET Kairouan

Figure 10 : Chronogramme d’émission en mode esclave

3.3. Fonctionnement en mode I2C maitre


Le fonctionnement du MSSP en mode I2C maitre est supporté grâce à la génération d’interruption suite à la
détection des conditions de départ et d’arrêt. Lorsque le MSSP fonctionne en mode I2C maitre, le contrôle
des lignes SDA et SCL est assuré par le circuiterie spécifique au bus I2C intégré dans le MSSP.
Le mode I2C maitre doit être configuré correctement par les bits SSPM du registre SSPCON1. On doit
positionner le bit SSPEN.
Le premier octet de donnée transmis contient l’adresse de l’esclave sur 7 bits et le bit de lecture écriture
(R/W). Les données séries sont transmises octet par octet et, après chacun d’eux, un acquittement doit être
reçu par le maitre pour que la transmission puisse continuer.
Une séquence de transmission type se déroule de la manière suivante:
 l’utilisateur génère une condition de départ en positionnant à 1 le bit SEN du registre SSPCON2 ;
 le bit SSPIF est positionné à 1 et le MSSP attend le temps nécessaire avant qu’une autre opération
puisse avoir lieu ;
 l’utilisateur peut alors charger le registre SSPBUF avec l’adresse à émettre ;
 l’adresse est envoyée sur la ligne SDA bit par bit jusqu’à ce que ces 8 bits soient transmis ;
 le MSSP lit alors le bit d’acquittement et le copie dans le bit ACK du registre SSPCON2<6> ;
 le MSSP génère une interruption en positionnant le bit SSPIF à la fin de la neuvième impulsion
d’horloge SCL ;
 l’utilisateur charge le registre SSPBUF avec la donnée à transmettre ;
 la donnée est envoyée sur la ligne SDA bit par bit jusqu’à ce que ses 8 bits soient transmis ;
 le MSSP lit alors le bit d’acquittement et le copie dans le bit ACK du registre SSPCON2<6> ;
 Le MSSP génère une interruption e positionnant le bit SSPIF à la fin de la neuvième impulsion
d’horloge SCL ;
 l’utilisateur génère une condition d’arrêt en positionnant à 1 le bit PEN du registre SSPCON2 ;
 une interruption est générée par le MSSP lorsque la condition d’arrêt a exécutée.
9
MSSP en mode I2C ISET Kairouan

a) Emission de données en mode maître


La valeur à émettre est écrit dans le registre SSPBUF. Le bit BF sera positionné à 1 et déclenche la
génération d’horloge. Chaque bit de donnée est alors émis sur SDA. Après le 8ème bit de donnée, le maître
laisse remonter la ligne au niveau haut pour autoriser l’esclave à répondre par un bit d’acquittement. L’état
de cet acquittement est copié dans le bit ACKSTAT.

Figure 11 : Chronogramme d’émission en mode maître

b) Réception de données en mode maître


La réception en mode maitre est validée par mise à 1 du bit RCEN du registre SSPCON2. La donnée
présente sur SDA est placée dans un bit du registre SSPSR. Après le front descendant de la 8ème impulsion
d’horloge, le contenu du registre SSPSR est copié dans le registre SSPBUF.

10
MSSP en mode I2C ISET Kairouan

Figure 12 : Chronogramme d’une réception en mode maître

4. Application

On désire en premier partie et à travers le bus I2C, faire communiquer deux microcontrôleurs
PIC18F4520. Puis en deuxième partie, on veut connecter une EEPROM série 24C256 et un port E/S
PCF8574 au microcontrôleur PIC18F4520 via une liaison I2C.
Pour cela, on demande, en premier lieu, de concevoir une carte électronique à base de PIC 18F4520 en
utilisant le logiciel ISIS. En deuxième lieu, d’élaborer le programme moyennant le logiciel PIC C et de
simuler la carte avec (ISIS).

4.1. Le port E/S PCF8574


Le circuit PCF8574 est un port parallèle d’E/S de 8 bits pour le bus I2C.
Le schéma bloc est donné par la figure 13 suivante :

11
MSSP en mode I2C ISET Kairouan

Figure 13: Schéma bloc du port PCF8574

 Les sorties sont verrouillés. Elles peuvent délivrer un courant de ± 25mA (max).
 Les pins A2A1A0 permettent de fixer l’adresse du circuit.
 Les chronogrammes d’écriture et de lecture sont donnés respectivement par les figure 14 et figure 15 suivantes :

Figure 14: Cycle d’écriture du PCF8574

Figure 15: Cycle de lecture du PCF8574

12
MSSP en mode I2C ISET Kairouan

4.2. EEPROM série 24C256


La mémoire 24C256 est une EEPROM de 256K bit (32 Koctet) interfaçable avec le bus I2C.

 Schéma de connexion

Figure 16: Schéma de connexion et nom des pins

 Apres le Start bit, le maitre doit positionner l’adresse de l’esclave. Les quatre bits de poids le plus fort sont
réservés pour l’identification du type du circuit esclave. Pour l’EEPROM ils sont fixés à 1010.
Les trois bits suivant, spécifie l’adresse du circuit (1 parmi 8).

 Pour une opération d’écriture, deux champ d’adresse de 15 bits sont exigés pour accéder aux différents 32
Koctet. La figure 17 suivante montre les séquences d’adresse, de l’ACK et de transfert des données.

Figure 17: Cycle d’écriture d’un octet de l’eprom 24c256

 Pour une lecture aléatoire d’un octet le maitre, le maitre doit accomplir en premier lieu une fausse opération
d’écriture. Le maitre doit émettre une condition de départ, l’adresse de la mémoire puis l’adresse de l’octet à
lire. Après avoir reçu l’impulsion d’acquittement ̅̅̅̅̅̅
ACK, le maitre envoie immédiatement la condition de départ
et l’adresse de l’EEPROM avec 𝑅/𝑊 à 1. La 24C256 repend par ̅̅̅̅̅̅
̅ ACK suivi par les huit bit de donnée.
La figure 18 montre les séquences de la phase de lecture.

Figure 18: Cycle de lecture aléatoire de l’eprom 24C256

13
MSSP en mode I2C ISET Kairouan

4.3. Travail demandé

PARTIE 1 :

On veut faire communiquer deux microcontrôleurs (μC1 et μC2) à travers une liaison I2C.

C1 C2
Bus I2C

Maitre Esclave

Figure 19 : Communication I2C C1 - C2

Les données sur le port B du C1 (maitre) sont lues puis envoyées par la liaison I2C au C2 (esclave)
pour quelle sera affichées sur le port D de ce dernier.

Réaliser le montage suivant (Figure 20):

 μC1 : les boutons poussoirs sont liés aux portB


 μC2 : les LED sont commandées par le portD
 La ligne SCL est lié à RC3
 La ligne SDA est lié à RC4

14
MSSP en mode I2C ISET Kairouan

Figure 20

On va écrire deux programmes indépendants : l’un pour μC1 et l’autre pour μC2.

On affecte au C2 esclave l’adresse A0H.

Organigramme 1 (Maitre émetteur) :

15
MSSP en mode I2C ISET Kairouan

- Activer les fonctions prédéfinies du bus I2C


- Configurer le C1 comme maitre

Initialisation : PORTB en entrée Figure 21 : Organigramme (μC1 : Maitre émetteur)

Lecture du PORTB (VAR ← PORTB)

Tant que (vrai)


Non Oui
Nouveau donnée sur le PORTB ?

Emission d’une condition de départ

Envoie de l’adresse de l’esclave

Envoie des 8 bits de données

Emission d’une condition d’arrêt

Delay 10ms

Programme (Maitre émetteur):

16
MSSP en mode I2C ISET Kairouan

Organigramme 2 (Esclave Récepteur):


- Activer les fonctions prédéfinies du bus I2C
- Configurer le C2 comme esclave, adresse : A0H

Figure 22 : Organigramme (μC2 : récepteur)


- Initialisation : ●PORTD en sortie ● PORTC en entrée
- Autoriser l’interruption I2C
-Valider la priorité haute de l’interruption

Rien à faire
Tant que (vrai)

Organigramme de l’interruption :
Effacer le drapeau d’interruption

Lecture de la donnée reçue par le bus


I2C

Afficher la donnée sur le PORTD

Figure 23

Programme (récepteur):

17
MSSP en mode I2C ISET Kairouan

PARTIE 2 :
On désire connecter une EPROM série 24C256 et un port E/S PCF8574 à un microcontrôleur PIC18F4520
via une liaison I2C.
Réaliser le montage suivant (Figure 24):

Figure 24

Travail demandée :
1. Affecter une adresse à chaque composant.
2. Ecrire une procédure permettant de vérifier si le port pcf8574 est connecté au bus I2C :
int1 ext_port_ready() ;
On peut suivre l’organigramme suivant : Emettre la condition de depart

Envoyer l’adresse du port externe pcf 8574

Vérifier l’état de l’acquittement ACK (si ACK=0 dans ce cas le port est prés )

Retourner l’état du port pcf8574

Fin

3. Ecrie la procédure write_pcf8574 permettant d’envoyer un octet au circuit pcf8574 à travers le bus I2C,
void write_pcf8574(int data) ;
On peut suivre l’organigramme suivant : Emettre la condition de depart

Envoyer l’adresse du port externe pcf 8574

Envoyer l’octet à afficher sur le port externe

Emettre la condition de stop

Fin

18
MSSP en mode I2C ISET Kairouan

4. Ecrire une procédure permettant de vérifier si l’EEPROM 24c256 est connecté au bus I2C
int1 ext_eeprom_ready() ;

5. Ecrire la procédure write_24c256 permettant d’écrire à l’adresse Ad la valeur data.


void write_24c256(long int Ad, unsigned int data) ;
On peut suivre l’organigramme suivant :

Oui
Non Tester si l’EEPROM est prête

Emettre la condition de depart

Envoyer l’adresse de l’EEPROM 24c256 avec mode Ecriture

Envoyer l’adresse haute de l’octet dans la mémoire

Envoyer l’adresse basse de l’octet dans la mémoire

Envoyer l’octet à écrire vers l’EEPROM

Emettre la condition de stop

6. Ecrire la procédure read_24c256 permettant de renvoyer le contenu d’une case mémoire d’adresse Ad.
unsigned int read_24c256(unsigned int Ad) ;

On peut suivre l’organigramme suivant :

Oui
Non Tester si l’EEPROM est prête

Emettre la condition de depart

Envoyer l’adresse de l’EEPROM 24c256 avec mode Ecriture

Envoyer l’adresse haute de l’octet dans la mémoire

Envoyer l’adresse basse de l’octet dans la mémoire

Emettre la condition de depart

Envoyer l’adresse de l’EEPROM 24c256 en précisant le mode de Lecture

Lire l’octet de l’EEPROM

Emettre la condition de stop

19
MSSP en mode I2C ISET Kairouan

- i2c_start() Emettre la condition de depart (Issues a start command when in the I2C master mode).
- i2c_write(data) Envoyer un octet (Sends a single byte over the I2C interface).
- i2c_read() Lire un octet (Reads a byte over the I2C interface).
- i2c_stop() Emettre la condition de stop (Issues a stop command when in the I2C master mode).

7. Ecrire un programme permettant de :


 sauvegarder dans l’eprom les valeurs suivantes :
0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0xC0,0xE0,0xF0,0xF8,0xFC,0xFE,0xFF,0x00,
0x81, 0x42, 0x24, 0x18.
On définie un tableau TAB de 21 valeurs.
 envoyer le contenu de l’EPROM au circuit pcf8574 à une fréquence de 2Hz.

 Organigramme : - Activer les fonctions prédéfinies du bus I2C


- Configurer le C comme maitre

Déclaration de la table TAB de 21 éléments

Initialisation du compteur J (J←0)

Tq J≤21 write_24c256(J, TAB[J])

J ← J+1

Delay 10ms

J=0

Tq J≤21
val ← read_24c256(J)

Port pcf8574 ← val

J ← J+1

Delay 0.5s

20
MSSP en mode I2C ISET Kairouan

#include <18f4520.h>
#use delay (clock = 8M)
#include <REG18F4520.h>
#fuses HS, NOWDT, NOLVP

#use I2C(master, sda=PIN_C4, scl=PIN_C3)

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

void write_pcf8574(int data)


{ while(!ext_port_ready());
i2c_start();
i2c_write(0x40); // addresse du port
i2c_write(data);
i2c_stop();
}

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

void write_24c256(long int Ad, unsigned int data)


{ while(!ext_eeprom_ready());
i2c_start();
i2c_write(0xa0);
i2c_write((Ad>>8)&0x7F);
i2c_write(Ad);
i2c_write(data);
i2c_stop();
}

unsigned int read_24c256(unsigned int16 Ad)


{ unsigned int data;

while(!ext_eeprom_ready());
i2c_start();
i2c_write(0xa0);
i2c_write((Ad>>8)&0x7F);
i2c_write(Ad);
i2c_start();
i2c_write((0xa0|1));
data=i2c_read(0);
i2c_stop();
return(data);
}

21
MSSP en mode I2C ISET Kairouan

void main()
{ unsigned int val;
unsigned int TAB[21]={0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,
0xC0,0xE0,0xF0,0xF8,0xFC,0xFE,0xFF,0x00,0x81,
0x42,0x24,0x18};
unsigned int16 J;

/*********************************************************/
for(J=0;J<21;J++)
{ write_24c256(J, TAB[J]);
delay_ms(10);
}
for(J=0;J<21;J++)
{ val=read_24c256(J);
write_pcf8574(val);
delay_ms(500);
}
while(true)
{
}
}

22