UFAS1 2024/2025 (1er Semestre) Électronique des Systèmes Embarqués

Faculté de Technologie Master 2

Département d’Électronique TP-ESE

Interfaçage des Périphériques dans les Systèmes Embarqués

— Création de Drivers de Communication —

Objectifs
L’objectif de ce travail pratique est d’apprendre à concevoir des drivers de haut niveau, réutilisables,
pour des protocoles de communication (par exemple, I2C, SPI) sur différentes plateformes, telles
que mikroC pour le PIC16F877A, MicroPython pour l’ESP8266 et Python pour le Raspberry Pi.
Ce travail implique une compréhension approfondie des fonctions de bas niveau fournies par chaque
plateforme, ainsi que l’acquisition des compétences nécessaires pour lire et analyser les fiches techniques
des périphériques afin de concevoir les drivers appropriés en se basant sur les informations qu’elles
contiennent. De plus, ce TP a pour but d’implémenter une gestion robuste des erreurs et d’optimiser
les drivers pour garantir une communication efficace et fiable. Des exemples pratiques permettront
d’illustrer l’application de ces drivers dans des scénarios réels, accompagnés de tests et d’une phase
de débogage afin d’assurer leur bon fonctionnement sur toutes les plateformes.

Introduction
Les systèmes embarqués occupent une place prépondérante dans un large éventail d’applications
modernes, allant des objets connectés aux systèmes industriels complexes. Ces systèmes requièrent
une communication fiable et performante avec leurs périphériques externes. Les protocoles de com-
munication, tels que I2C, SPI et UART, jouent un rôle central dans cette interaction, fournissant
des solutions efficaces pour l’échange de données entre le microcontrôleur et les composants périphé-
riques. L’adoption généralisée de ces protocoles s’explique par leur efficacité, leur faible consommation
énergétique et leur large diffusion dans de multiples secteurs industriels.
La création de drivers constitue un aspect fondamental du développement des systèmes embarqués.
Un driver agit en tant qu’intermédiaire entre le matériel (périphérique) et le logiciel (application ou
système d’exploitation), facilitant ainsi la gestion des échanges de données. Les fonctions de bas niveau
contrôlent directement les protocoles de communication, en gérant les aspects matériels tels que les
registres et les interactions avec le périphérique à un niveau élémentaire. À l’inverse, les drivers de
haut niveau reposent sur ces fonctions de bas niveau pour offrir des interfaces abstraites, simplifiant
ainsi l’interaction avec les périphériques pour les développeurs d’applications.
Cependant, pour concevoir des drivers efficaces, il est impératif de comprendre de manière ap-
profondie les spécifications et les caractéristiques des périphériques avec lesquels le système interagit.
Cela nécessite notamment la capacité de lire et d’interpréter les fiches techniques (datasheets) des
composants, qu’il s’agisse de capteurs, de mémoires ou d’autres dispositifs. Ces documents fournissent
des informations essentielles concernant la configuration, les registres, les modes de communication
et les contraintes de fonctionnement des périphériques. Une lecture attentive et une compréhension

1/13 Dr. TERCHI Younes

approfondie de ces fiches permettent de concevoir des drivers qui exploitent pleinement les capacités
du matériel tout en évitant les erreurs de configuration ou de communication susceptibles d’altérer les
performances du système.
Le présent travail pratique a pour objectif d’enseigner aux étudiants comment transformer de
manière précise les informations contenues dans une datasheet en un driver fonctionnel, adapté à un
périphérique spécifique. Les étudiants apprendront à concevoir des drivers robustes et réutilisables
dans le but de garantir une interaction optimale entre le microcontrôleur et les périphériques. Ce
travail vise également à fournir aux étudiants les compétences nécessaires pour aborder la conception
de drivers pour d’autres périphériques dans le cadre de leurs futures carrières professionnelles.

1 Vue d’Ensemble du Protocole I2C

Le protocole Inter-Integrated Circuit (I2C) est un standard de communication largement uti-
lisé dans les systèmes embarqués, permettant à plusieurs dispositifs de communiquer via une interface
bidirectionnelle à deux fils : la Ligne de Données Série (SDA) et la Ligne d’Horloge Série
(SCL). Ce protocole, développé par Philips Semiconductors (aujourd’hui NXP), est reconnu pour
sa simplicité, sa scalabilité et sa capacité à supporter plusieurs dispositifs sur un seul bus. Les deux
lignes sont utilisées à la fois pour le transfert de données et la synchronisation de l’horloge, avec une
configuration à drain ouvert nécessitant des résistances de tirage externes pour ramener les lignes à
un état haut lorsqu’elles ne sont pas activement pilotées par un dispositif.
L’un des principaux
I2C Physical Layer avantages de l’I2C est sa capacité à connecter plusieurs périphériques www.ti.com sur un
même bus, permettant ainsi une communication entre un dispositif maître et un ou plusieurs dispositifs
2 I2C Physical Layer
esclaves. Le système global est illustré dans Figure 1, qui montre plusieurs dispositifs connectés aux
2.1 Two-Wire Communication
mêmes lignes2 SDA et SCL, avec des résistances de tirage assurant le maintien des niveaux logiques
An I C system features two shared communication lines for all devices on the bus. These two lines are used
appropriés.for bidirectional, half-duplex communication. I2C allows for multiple controllers and multiple target devices. Pullup
resistors are required on both of these lines. Figure 2-1 shows a typical implementation of the I2C physical layer.
VDD

SDA

SCL
VDD

VDD

VDD

VDD
SDA

SDA

SDA

SDA
SCL

SCL

SCL

SCL

Microprocessor Microprocessor Peripheral Peripheral

Controller 1 Controller 2 Target 1 Target 2
GND

GND

GND

GND

GND

GND

Figure 2-1. Typical I2C Implementation

Figure 1 – Bus I2C avec Plusieurs Dispositifs
One of the reasons that I2C is a common protocol is because there are only two lines used for communication.
The first line is SCL, which is a serial clock primarily controlled by the controller device. SCL is used to
synchronously clock data in or out of the target device. The second line is SDA, which is the serial data line.
SDA is used to transmit data to or from target devices. For example, a controller device can send configuration
1.1 data and output codes to a target digital-to-analog converter (DAC), or a target analog-to-digital converter (ADC)
Opération à Drain Ouvert
can send conversion data back to the controller device.
I2C is half-duplex
La configuration à communication
drain ouvert where
duonly a single controller
protocole I2C est or a une
targetcaractéristique
device is sending data on permettant
clé the bus at a au bus
time. In comparison, the serial peripheral interface (SPI) is a full-duplex protocol where data can be sent to and
à deux filsreceived
de supporter
back at the la communication
same bidirectionnelle.
time. SPI requires four Lorsqu’un
lines for communication, dispositif
two data lines are usedtire une
to send dataligne vers le
to and from the target device. In addition to the serial clock, a unique SPI chip select line selects the device for
bas, il force activement
communication andle signal
there à un
are two dataétat
lines, bas. Eninput
used for revanche,
and outputlorsqu’un dispositif
from the target device. ne pilote pas la ligne,
An I2C controller device starts and stops communication, which removes the potential problem of bus contention.
Communication with a target device is sent through a unique address on the bus. This allows for both multiple
controllers and multiple target devices on the I2C bus.2/13
The SDA and SCL lines have an open-drain connection to all devices on the bus. This requires a pullup resistor
to a common voltage supply.
les résistances de tirage assurent le retour de la ligne à un état haut. Ce comportement bidirectionnel
est essentiel pour maintenir une communication correcte sans nécessiter de lignes dédiées pour chaque
direction de transmission de données.
La Figure 2 fournie une représentation visuelle de cette opération à drain ouvert. La Figure 2a
montre l’état où un dispositif tire le bus vers le bas, tandis que la Figure 2b illustre le bus tiré vers le
haut lorsque aucun dispositif ne pilote la ligne, s’appuyant sur les résistances de tirage.

SDA/SCL

Slave or Master

RPU
VBUS
VBUS
Logic
V

Time

(a) Tirer le Bus I2C Vers le Bas avec une Sortie à Drain Ouvert

SDA/SCL

Slave or Master

RPU
VBUS
VBUS
Logic
V

Time

(b) Tirer le Bus I2C Vers le Haut avec une Résistance de Tirage

Figure 2 – Comparaison des deux configurations du Bus I2C

1.2 Communication des Données en I2C

La communication en I2C suit une séquence bien définie qui commence par l’initiation de la
transaction par le maître. Ce dernier génère une condition de début (start), signalant le début
de la communication, puis envoie l’adresse du dispositif esclave avec le bit R/W indiquant le type
d’opération—0 pour une écriture et 1 pour une lecture. Après la transmission de l’adresse, le maître
peut envoyer des données ou demander des données à l’esclave. La communication se termine par une
condition d’arrêt (stop), signalant la fin de la transaction.

1.2.1 Écriture vers un Dispositif Esclave

Dans une opération d’écriture typique, le maître commence par envoyer une condition de début
suivie de l’adresse de l’esclave avec le bit R/W réglé à 0, indiquant une opération d’écriture. Le maître
envoie ensuite l’adresse du registre auquel il souhaite écrire, après quoi l’esclave reconnaît la transmis-

3/13
sion. Le maître transmet ensuite les données, et l’esclave reconnaît chaque octet. La communication
se termine par une condition d’arrêt, comme le montre la Figure 3.

Device (Slave) Address (7 bits) Register Address N (8 bits) Data Byte to Register N (8 bits)

S A6 A5 A4 A3 A2 A1 A0 0 A B7 B6 B5 B4 B3 B2 B1 B0 A D7 D6 D5 D4 D3 D2 D1 D0 A P

START R/W = 0 ACK ACK ACK STOP

Le maître contrôle la ligne SDA L’esclave contrôle la ligne SDA

Figure 3 – Écriture d’un Octet sur un Dispositif Esclave I2C

1.2.2 Lecture depuis un Dispositif Esclave

La lecture depuis un dispositif esclave est similaire à l’opération d’écriture, mais implique des
étapes supplémentaires pour indiquer à l’esclave quel registre lire. Le maître commence par envoyer
une condition de début et l’adresse de l’esclave avec le bit R/W réglé à 0, suivie de l’adresse du
registre. Après que l’esclave ait reconnu cette adresse de registre, le maître génère une condition
de début répétée et envoie à nouveau l’adresse de l’esclave, mais cette fois avec le bit R/W réglé
à 1, signalant une opération de lecture. L’esclave transmet alors les données demandées au maître,
qui continue à générer des impulsions d’horloge pendant que l’esclave envoie les bits de données.
Après avoir reçu le nombre d’octets souhaité, le maître envoie un NACK pour signaler la fin de la
communication, suivi d’une condition d’arrêt. Cette séquence est illustrée dans la Figure 4.

Device (Slave) Address (7 bits) Register Address N (8 bits) Device (Slave) Address (7 bits) Data Byte From Register N (8 bits)

S A6 A5 A4 A3 A2 A1 A0 0 A B7 B6 B5 B4 B3 B2 B1 B0 A Sr A6 A5 A4 A3 A2 A1 A0 1 A D7 D6 D5 D4 D3 D2 D1 D0 NA P

START R/W = 0 ACK ACK Repeated START R/W = 1 ACK NACK STOP

Le maître contrôle la ligne SDA L’esclave contrôle la ligne SDA

Figure 4 – Lecture d’un Octet depuis un Dispositif Esclave I2C

1.3 Applications de l’I2C

L’I2C est particulièrement avantageux pour connecter des périphériques à faible vitesse tels que
des capteurs, des EEPROM et des horloges temps réel à des microcontrôleurs dans des systèmes em-
barqués. Sa simplicité de câblage—nécessitant seulement deux lignes pour plusieurs périphériques—le
rend idéal pour des applications où l’espace et le nombre de broches sont limités. La flexibilité et la
facilité d’utilisation du protocole en font également un choix standard pour les dispositifs nécessitant
une communication occasionnelle avec des microcontrôleurs, tels que les capteurs de température, les
convertisseurs analogique-numérique (CAN) et les pilotes d’affichage.

4/13
2 Manipulation
2.1 Mémoire EEPROM 24C08B/16B
L’EEPROM 24C08B/16B est une mémoire de 8 Kbits (pour la 24C08B) ou 16 Kbits (pour la
24C16B), basée sur une interface série I2C. Elle est organisée en blocs de 256 x 8 bits, ce qui permet de
structurer la mémoire de manière logique pour un accès facile. Cette EEPROM supporte les opérations
d’écriture par octet ainsi que des écritures par page pouvant atteindre 16 octets de données, ce qui
offre une flexibilité importante pour les applications nécessitant des écritures rapides et multiples.

A0 1 8 VCC
• VCC → 5V
• VSS → 0V
24C08B/16B

A1 2 7 WP
• SCL et SDA → Bus I2C
A2 3 6 SCL • A0, A1, A2 (flottantes)
• WP : VCC =⇒ protection contre l’écriture
VSS 4 5 SDA
VSS =⇒ écriture autorisée.

Cette EEPROM est dotée d’une adresse I2C fixe : 0xA0 pour l’écriture et 0xA1 pour la lecture.
Les broches A0, A1 et A2, non utilisées pour la sélection d’adresse, peuvent être laissées flottantes
ou reliées à VSS (masse) ou VCC (alimentation). Cette caractéristique simplifie l’interface, particu-
lièrement lorsque l’on utilise un seul périphérique.
Il existe deux modes d’écriture pour la mémoire EEPROM 24C08B/16B, à savoir l’écriture par
octet et l’écriture par page. L’écriture par octet suit la séquence illustrée dans Figure 5, tandis que
l’écriture par page suit la même procédure, mais permet d’envoyer jusqu’à 16 octets de données en
une seule opération, au lieu de les envoyer un par un, avant d’envoyer le signal de fin (voir FIGURE
4-2, page 6 de [1]). Dans Figure 5, WORD ADDRESS fait référence à l’adresse au sein d’un bloc spécifié.
FIGURE 4-1: BYTE WRITE
S S
BUS ACTIVITY T CONTROL WORD T
MASTER A BYTE ADDRESS DATA O
R P
T

SDA LINE S P

A A A
BUS ACTIVITY C C C
K K K

Figure 5 – Écriture d’un octet dans la mémoire EEPROM 24C08B/16B

De plus, trois modes de lecture sont disponibles : la lecture à la position actuelle, la lecture à partir
d’une adresse spécifique, et la lecture d’une page à une adresse donnée. La lecture d’un seul octet est
illustrée dans Figure 6. La lecture par page suit une structure similaire (voir FIGURE 7-3, page 8
de [1]).
NB. Il convient de souligner que le cycle d’écriture nécessite un délai de 10 ms pour être achevé.
En ce qui concerne le CONTROL BYTE, il est structuré comme illustré dans Figure 7. Les bits B2B1B0
correspondent à l’adresse du bloc (par exemple, 010=2 signifie la lecture/écriture depuis/vers le bloc
numéro 2).

Travail demandé 1. Réalisez le montage illustré dans la Figure 8. Ensuite, créez un nouveau projet
pour le microcontrôleur et ajoutez les fichiers C08.c et C08.h au répertoire du projet. Ces deux

5/13
 S S
T T S
BUS ACTIVITY A CONTROL WORD A CONTROL T
MASTER R BYTE ADDRESS (n) R BYTE DATA (n) O
T T P
S S P
SDA LINE
A A A N
C C C O
K K K
BUS ACTIVITY A
C
K

Figure 6 – Lecture d’un octet depuis la mémoire EEPROM 24C08B/16B

ALLOCATION
START READ/WRITE

SLAVE ADDRESS R/W A

1 0 1 0 B2 B1 B0

Figure 7 – Répartition du byte de contrôle pour la mémoire EEPROM 24C08B/16B

fichiers servent de bibliothèque pour les mémoires 24C08B/C16B. Bien que diverses fonctions aient
été implémentées par votre Prof., certaines restent à compléter par vous-même (La page d’aide de
mikroC relative à la classe I2 C [2] est essentielle pour comprendre le code). Le contenu du fichier
d’en-tête C08.h, qui contient les prototypes des fonctions, est présenté dans le Listing 1.

Listing 1 – Fichier d’entête C08.h

1 /* Created : Nov 16 th 2024 , By Dr . TERCHI Younes
2 For the lab work of the class : Embedded Systems , Master2
3 Department of Electronics , Setif 1 Ferhat Abbas University
4 Students are required to build complete driver For the 24 c08B /16 B */
5 # ifndef EEPROM_H
6 # define EEPROM_H
7 // Define the base address macro for the EEPROM
8 # define ADDRESS 0 b1010000
9 typedef unsigned char byte ;
10 // Function prototypes
11 void byteWrite ( byte block , byte wordAddr , byte dataa ) ;
12 byte byteRead ( byte block , byte wordAddr ) ;
13 byte byteRead2 ( unsigned int addr ) ;
14 void byteWrite2 ( unsigned int addr , byte dataa ) ;
15 void pageWrite ( byte block , byte page , byte * dataa ) ;
16 void pageRead ( byte block , byte page , byte * dataa ) ;
17 void Erase () ;
18 # endif // EEPROM_H

Saisissez, compilez, puis téléversez le code présenté dans le Listing 2 sur le microcontrôleur.

6/13
 SCL
13 33
OSC1/CLKIN RB0/INT
14 34
OSC2/CLKOUT RB1 SDA SDA
35 4.7k 4.7k
2
3
4
RA0/AN0
RA1/AN1
RB2
RB3/PGM
RB4
36
37
38 U1
SCL SCL I2C
RA2/AN2/VREF-/CVREF RB5 TRIG
5 39 6
RA3/AN3/VREF+ RB6/PGC SDA SCK
6 40 5
RA4/T0CKI/C1OUT RB7/PGD SDA
7 7
RA5/AN4/SS/C2OUT WP
15
RC0/T1OSO/T1CKI
8 16 24C08B
RE0/AN5/RD RC1/T1OSI/CCP2 LM016L
9 17
RE1/AN6/WR RC2/CCP1
10 18
RE2/AN7/CS RC3/SCK/SCL SCL
23
RC4/SDI/SDA SDA
1 24
MCLR/Vpp/THV RC5/SDO
25
RC6/TX/CK
26
RC7/RX/DT

VDD
VSS

VEE

RW
19

RS

D0
D1
D2
D3
D4
D5
D6
D7
RD0/PSP0 RS

E
20
RD1/PSP1 E
21
RD2/PSP2

1
2
3

4
5
6

7
8
9
10
11
12
13
14
22
RD3/PSP3
27
RD4/PSP4 D4
28
RD5/PSP5 D5
29
RD6/PSP6 D6
30

RS

D4
D5
D6
D7
RD7/PSP7 D7

PIC16F877A

Figure 8 – Montage avec une EEPROM 24C08B connectée au bus I2C

Listing 2 – Main code
1 # include " C08 . h "
2 // LCD module connections
3 sbit LCD_RS at RD0_bit ;
4 sbit LCD_EN at RD1_bit ;
5 sbit LCD_D4 at RD4_bit ;
6 sbit LCD_D5 at RD5_bit ;
7 sbit LCD_D6 at RD6_bit ;
8 sbit LCD_D7 at RD7_bit ;

9 sbit LCD_RS_Direction at TRISD0_bit ;

10 sbit LCD_EN_Direction at TRISD1_bit ;
11 sbit LCD_D4_Direction at TRISD4_bit ;
12 sbit LCD_D5_Direction at TRISD5_bit ;
13 sbit LCD_D6_Direction at TRISD6_bit ;
14 sbit LCD_D7_Direction at TRISD7_bit ;
15 // End LCD module connections

16 void afficher ( byte dataa ) {

17 char buff [5];
18 shortToHex ( dataa , buff ) ;
19 Lcd_Out_CP ( buff ) ;
20 }

21 void main () {
22 byte dataa , dataa2 [16];
23 I2C1_Init (100000) ; Lcd_Init () ; Lcd_Cmd ( _LCD_CURSOR_OFF ) ;
24 byteWrite (3 , 5 , 0 xAB ) ;
25 byteWrite2 (772 , 0 xDE ) ;

26 dataa = byteRead2 (772) ; afficher ( dataa ) ;

27 dataa = byteRead2 (773) ; afficher ( dataa ) ;
28 // pageWrite (3 , 0 , dataa2 ) ;
29 // dataa = byteRead2 (773) ; afficher ( dataa ) ;
30 }

7/13
 1. Expliquez le rôle des deux résistances de 4.7 kΩ.
2. Dans le fichier C08.c, en analysant les implémentations des fonctions byteWrite et byteWrite2,
mettez en évidence les différences entre les deux et justifiez leur utilité respective.
3. Après l’exécution du programme, expliquez les résultats affichés sur l’écran LCD.
4. Concernant les sorties de l’analyseur logique/I2C, les résultats obtenus sont présentés dans la
Figure 9. Interprétez ces résultats (les Figure 3 et 4 peuvent s’avérer utiles).

Start A6 ACK 05 ACK AB ACK Stop

Start A6 ACK 04 ACK DE ACK Stop

Start A6 ACK 04 ACK Repeated Start A7 ACK DE NACK Stop

Start A6 ACK 05 ACK Repeated Start A7 ACK AB NACK Stop

Figure 9 – Résultats de l’analyseur I2C après exécution du code du Listing 2

5. Décommentez les lignes 28 et 29 du code présenté dans le Listing 2. Exécutez le programme et

analysez les valeurs affichées sur l’écran LCD.

2.2 Mémoire EEPROM AT24C512–Dépassement des limitations du 24C08

Bien que la mémoire EEPROM 24C08 présente des caractéristiques intéressantes pour des ap-
plications de petite envergure, elle souffre de limitations notables. Sa capacité totale est limitée à 8
8 kbit (1 kB), ce qui peut être insuffisant pour des systèmes nécessitant un stockage de données étendu,
comme les journaux de données, les configurations complexes ou les enregistrements volumineux. De
plus, son système d’adressage basé sur des blocs de 256 octets impose des contraintes supplémentaires
en termes de gestion logicielle lorsqu’on souhaite accéder à un espace mémoire plus vaste.
Pour répondre à ces besoins, l’AT24C512 offre une capacité mémoire bien plus importante, attei-
gnant 512 kbit (64 kB), ainsi qu’un adressage sur 16 bits qui simplifie l’accès à de grandes quantités
de données. Afin d’illustrer son utilisation et d’encourager une compréhension pratique, nous propo-
sons le montage suivant intégrant deux AT24C512, permettant d’étendre davantage la capacité totale
disponible.

2.2.1 Adressage des dispositifs AT24C512

Chaque mémoire AT24C512 utilise un code d’adresse sur 7 bits pour la communication I2 C. Les
deux bits inférieurs de cette adresse (A1 et A0) sont configurés via les broches correspondantes du
dispositif, permettant d’utiliser jusqu’à huit mémoires AT24C512 sur un même bus. La figure 10
illustre la relation entre les broches d’adresse et le code d’adresse I2 C.

1 0 1 0 0 A1 A0 R/W̄

Figure 10 – Structure de l’adresse du dispositif pour l’AT24C512 et configuration des broches A0 et

A1

8/13
2.2.2 Modes d’accès à la mémoire : Lecture et écriture

L’AT24C512 nécessite un adressage sur 16 bits, impliquant l’envoi de deux mots d’adresse pour
spécifier une position mémoire précise. La figure 11 illustre la séquence d’écriture d’un octet, tandis
que la figure 12 présente la séquence de lecture d’un octet.

Figure 11 – Séquence d’écriture d’un octet pour l’AT24C512

Figure 12 – Séquence de lecture d’un octet pour l’AT24C512

Ces figures mettent en évidence l’importance de l’utilisation de deux mots d’adresse, particulière-
ment pour des applications nécessitant l’accès à des données réparties sur une mémoire étendue.

Travail demandé 2. Dans le montage présenté dans la Figure 13, deux AT24C512 sont connectés à
un même bus I2 C. Les broches d’adresse A0 et A1 permettent de différencier les deux composants en
configurant leurs adresses respectives. Ce dispositif offre ainsi une capacité totale de 128 kB, adressable
via un schéma cohérent.
Votre tâche consiste à développer un pilote (driver) pour gérer ce système à deux mémoires
AT24C512, en vous appuyant sur les informations présentées dans ce TP ainsi que sur celles four-
nies dans la fiche technique (datasheet) de l’AT24C512 [3].

3 Approfondissement (obtenir des points supplémentaires) 1

1. Dans l’annexe A, un code MicroPython implémentant certaines fonctions de base pour la
mémoire EEPROM 24C08B est présenté. Les fonctions read et write sont conçues dans un
esprit de généralité : lorsque le paramètre block est fourni, l’adresse est interprétée comme une
adresse locale, tandis que si ce paramètre est omis, l’adresse est considérée comme globale. Une
fonction erase est également implémentée, permettant de réinitialiser les octets de la mémoire
EEPROM à la valeur 0xFF.
1. Les tâches présentées ici ne sont pas obligatoires pour le compte rendu. Cependant, si vous souhaitez obtenir des
points supplémentaires, vous pouvez essayer de les réaliser.

9/13
 6 1
SCL SCL A0
13 33 5 2
OSC1/CLKIN RB0/INT SDA SDA A1
14 34 4.7k 4.7k 7
OSC2/CLKOUT RB1 WP
35
RB2 SDA SDA
2 36 AT24C512
3
4
5
RA0/AN0
RA1/AN1
RA2/AN2/VREF-/CVREF
RB3/PGM
RB4
RB5
37
38
39
SCL
6
5
SCL A0
1
2
SCL SCL I2C
RA3/AN3/VREF+ RB6/PGC SDA SDA A1 TRIG
6 40 7

SDA

SCL
RA4/T0CKI/C1OUT RB7/PGD WP
7
RA5/AN4/SS/C2OUT
15 AT24C512
RC0/T1OSO/T1CKI
8 16
RE0/AN5/RD RC1/T1OSI/CCP2 LM016L
9 17
RE1/AN6/WR RC2/CCP1
10 18
RE2/AN7/CS RC3/SCK/SCL SCL
23
RC4/SDI/SDA SDA
1 24
MCLR/Vpp/THV RC5/SDO
25
RC6/TX/CK
26
RC7/RX/DT

VDD
VSS

VEE

RW
19

RS

D0
D1
D2
D3
D4
D5
D6
D7
RD0/PSP0 RS

E
20
RD1/PSP1 E
21
RD2/PSP2

1
2
3

4
5
6

7
8
9
10
11
12
13
14
22
RD3/PSP3
27
RD4/PSP4 D4
28
RD5/PSP5 D5
29
RD6/PSP6 D6
30

RS

D4
D5
D6
D7
RD7/PSP7 D7

PIC16F877A

Figure 13 – Montage avec deux AT24C512 connectés en parallèle

(a) Identifiez les limitations des fonctions read et write et proposez des améliorations possibles
pour les optimiser.
(b) Comme le montre le Listing 3, la fonction erase efface 16 octets à la fois, c’est-à-dire une
page complète. Cette méthode constitue une approche par page pour l’effacement. Une autre
approche consisterait à effacer la mémoire octet par octet (byte-wise approach). Expliquez
pourquoi l’approche par page est préférable.
2. Dans l’annexe B, un programme (présenté dans le Listing 4) est conçu pour être exécuté sur
un Raspberry Pi 2 . Ce programme permet de transférer le contenu de la mémoire EEPROM
dans un fichier texte dans un format lisible. Il lit les quatre blocs de la mémoire 24C08B. Un
exemple du résultat obtenu est présenté dans la Figure 14.
(a) Expliquez les lignes 18 et 19 du Listing 4 et leur relation avec les 12 premiers octets du
Block 0 illustrés dans la Figure 14.
(b) Supposons l’existence d’un fichier binaire "f24.bin", de taille appropriée, présent dans le
système de fichiers du Raspberry Pi. Écrivez un programme en Python qui lit les octets du
fichier et les écrit sur la mémoire EEPROM 24C08B.

4 Mini-Projet
Under Construction
Will be completed by next week

2. Bien que le programme puisse théoriquement être utilisé sur n’importe quelle version du Raspberry Pi, il convient
de noter qu’il a été testé uniquement sur le modèle Raspberry Pi 2 Model B.

10/13
Annexes
A Code Micro-Python pour le 24C08B

Listing 3 – Exemple de code MicroPython pour implémenter des opérations de base pour la mémoire
EEPROM 24C08B
1 """
2 Created by Dr . TERCHI Younes as part of the lab on Embedded Systems
3 for Master 2 students , Department of Electronics , Setif 1 Ferhat Abbas
University
4 """
5 from machine import Pin , I2C
6 import utime

7 # Base address of the EEPROM

8 add0 =0 b1010000
9 # Initialize the I2C bus with SDA on pin 14 and SCL on pin 12
10 i2c = I2C ( sda =14 , scl =12)

11 # Read data from the EEPROM

12 def read ( address , count =1 , block = None ) :
13 """
14 Reads ’ count ’ bytes from the given address .
15 The ’ block ’ option adjusts the address based on the block .
16 """
17 if block is not None :
18 address += block * 256
19 addplus = add0 + (( address >> 8) )
20 return i2c . readfrom_mem ( addplus , address & 0 xff , count )

21 # Write data to the EEPROM

22 def write ( address , data , block = None ) :
23 """
24 Writes data to the given address . The ’ block ’ option adjusts the
address .
25 """
26 if block is not None :
27 address += block * 256
28 addplus = add0 + (( address >> 8) )
29 i2c . writeto_mem ( addplus , address & 0 xff , data )
30 utime . sleep_ms (10)

31 # Erase the EEPROM ( write 0 xFF )

32 def erase () :
33 """
34 Erases the EEPROM by writing 0 xFF to each block .
35 """
36 for block in range (4) :
37 for k in range (256 // 16) :
38 write (256 * block + k * 16 , bytes ([0 xFF ] * 16) )

11/13
B 24C08B avec Raspberry pi et python

Listing 4 – Code Python pour le vidage (dump) et l’analyse du contenu de la mémoire EEPROM
24C08B
1 """
2 Created by Dr . TERCHI Younes as part of the lab on Embedded Systems
3 for Master 2 students , Department of Electronics , Setif 1 Ferhat Abbas
University .
4 This program serves as a dumper for the 24 C08B EEPROM . It reads the EEPROM
content block by block and writes it to a file in a formatted structure
for analysis and debugging .
5 """
6 import smbus , time

7 # EEPROM base address

8 devAdrr =0 x50

9 # Initialize I2C bus

10 bus = smbus . SMBus (1)

11 # Function to read data from the EEPROM

12 def read ( block , adrr , count ) :
13 """
14 Reads ’ count ’ bytes starting from the given word address in the
specified block .
15 """
16 b = bus . r ea d _ i2 c _b l oc k _ da t a ( devAdrr + block , adrr , count ) ;
17 return b

18 bus . w r i t e _ i 2 c _ b l oc k _ d a t a ( devAdrr , 0 , [ ord ( c ) for c in ’ Hello World ! ’ ])

19 time . sleep (1)

20 # Open a file to save EEPROM data in a formatted structure

21 with open ( ’ dump . txt ’ , ’w ’) as fl :
22 s=’’
23 for k in range (16) : s += f ’{ k :0{2} X } ’
24 for block in range (4) :
25 fl . write ( ’ ’ *24+ ’ Block ’+ str ( block ) )
26 fl . write ( ’\ n ’)
27 fl . write ( ’ ’+ s + ’\ n ’)
28 for k in range (16) :
29 dt = read ( block , k *16 , 16)
30 fl . write ( f ’{ block *256+ k *16:0{4} X } -{ k *16:0{2} X }: ’)
31 for u in dt :
32 fl . write ( f ’{ u :0{2} X } ’)
33 fl . write ( ’\ n ’)
34 fl . write ( ’\ n ’)

12/13
 Block 0 Block 2
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
0000-00: 48 65 6C 6C 6F 20 57 6F 72 6C 64 21 FF FF FF FF 0200-00: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0010-10: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0210-10: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0020-20: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0220-20: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0030-30: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0230-30: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0040-40: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0240-40: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0050-50: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0250-50: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0060-60: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0260-60: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0070-70: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0270-70: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0080-80: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0280-80: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0090-90: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0290-90: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
00A0-A0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 02A0-A0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
00B0-B0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 02B0-B0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
00C0-C0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 02C0-C0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
00D0-D0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 02D0-D0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
00E0-E0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 02E0-E0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
00F0-F0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 02F0-F0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF

Block 1 Block 3
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
0100-00: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0300-00: 00 11 22 33 44 55 66 FF FF FF 2F FF FF FF FF FF
0110-10: FF FF 52 74 FF FF FF FF FF FF FF FF FF FF FF FF 0310-10: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0120-20: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0320-20: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0130-30: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0330-30: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0140-40: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0340-40: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0150-50: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0350-50: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0160-60: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0360-60: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0170-70: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0370-70: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0180-80: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0380-80: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
0190-90: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0390-90: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
01A0-A0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 03A0-A0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
01B0-B0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 03B0-B0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
01C0-C0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 03C0-C0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
01D0-D0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 03D0-D0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
01E0-E0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 03E0-E0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
01F0-F0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 03F0-F0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF

Figure 14 – Exemple d’un fichier texte produit par le programme de Listing 4

Références
[1] Microchip, “24c08b/16b, 8k/16k 5.0v i2c serial eeproms,” accessed : 2024-11-15. [Online].
Available : https://ww1.microchip.com/downloads/en/devicedoc/21081G.pdf
[2] Mikroe, “Mikroc i2 c library help,” accessed : 2024-11-16. [Online]. Available : https:
//download.mikroe.com/documents/compilers/mikroc/pic/help/i2c_library.htm
[3] ATMEL, “At24c512, two-wire serial eeprom,” accessed : 2024-11-16. [Online]. Available :
https://ww1.microchip.com/downloads/en/devicedoc/doc1116.pdf
[4] MicroPython, “class i2c – a two-wire serial protocol¶,” accessed : 2024-11-16. [Online]. Available :
https://docs.micropython.org/en/latest/library/machine.I2C.html
[5] ElectronicWings, “Python based i2c functions for raspberry pi,” acces-
sed : 2024-11-17. [Online]. Available : https://www.electronicwings.com/raspberry-pi/
python-based-i2c-functions-for-raspberry-pi

13/13
Table des matières
Objectifs 1

Introduction 1

1 Vue d’Ensemble du Protocole I2C 2

1.1 Opération à Drain Ouvert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Communication des Données en I2C . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Écriture vers un Dispositif Esclave . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Lecture depuis un Dispositif Esclave . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Applications de l’I2C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Manipulation 5
2.1 Mémoire EEPROM 24C08B/16B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Mémoire EEPROM AT24C512–Dépassement des limitations du 24C08 . . . . . . . . 8
2.2.1 Adressage des dispositifs AT24C512 . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.2 Modes d’accès à la mémoire : Lecture et écriture . . . . . . . . . . . . . . . . . 9

3 Perspectives d’approfondissement 9

4 Mini-Projet 10

Annexes 11
A Code Micro-Python pour le 24C08B . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
B 24C08B avec Raspberry pi et python . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

Références 13