I.

PCF8574A (Extension) :
Un circuit intégré (composant électronique qui comprend de multiples transistors, diodes et autres composants électroniques
interconnectés sur une petite puce et qui peuvent avoir de nombreuses fonctions différentes : mémoire, les amplificateurs,
les convertisseurs de données, extensions, etc.)
Le PCF8574A est un circuit intégré qui permet d’ajouter à la carte Arduino des extensions c’est-à-dire des entrées/Sorties
numériques en plus. Ce circuit peut se communiquer avec une carte Arduino par bus I2C (bus série).

 Transmission série (exemple I2C) : les bits sont envoyés un par un, du bit de poids faible
ou LSB (D0) au bit de poids fort MSB (D7), le premier bit envoyé est le premier arrivé. Ils
sont bien sûr cadencés par l’horloge (signal SCL).

 Transmission parallèle (exemple UART) : les bits sont envoyés à la fois et arrivent tous
en même temps. Donc on envoie plusieurs bits à la fois, dans ce cas 8 bits (octet).

Ce circuit intégré contient 16 broches (PIN) :

- 8 broches (P0 à P7) qui jouent le rôle de E/S numériques.
- 2 broches pour le I2C (communication série avec Arduino) :
 SDA branché à l’entrée analogique A4 : Bus de données bidirectionnel sur 8 bits qui permet de transférer et conduire
les données.
  SCL branché à l’entrée analogique A5 : Bus de synchronisation ou ligne d’horloge qui permet de contrôler et cadencer la
séquence de bits (exemple à chaque front montant on envoie un bit pour éviter le chevauchement des données entre
elles).
- 3 broches pour les adresses (A0, A1 et A2) : L'utilisation des adresses permet de configurer jusqu'à 8 périphériques (PCF8574A)
identiques sur un même bus I2C. Chaque périphérique doit avoir une adresse unique pour que le microcontrôleur (Arduino
dans ce cas) puisse communiquer avec lui.

Dans ce cas le microcontrôleurs Arduino joue le rôle du maitre (décide à quel moment et à quel périphérique envoyer les
données) et le PCF8574A joue le rôle de l’esclave (ils demandent des données et le maitre répond s’il veut) c’est ce qu’on appelle
en électronique (Maitre/Esclave ou Master/Slave en anglais, ils existent d’autres tels que publisher/subscriber ou bien
client/serveur, etc.)

Pour chaque PCF8574A on doit lui donner une adresse, ces adresses sont choisie grâce aux trois broches (A0 à A2). On trouve deux
modes selon ce tableau :
 - Mode avec lecture et écriture (R/W) : On ajoute le R/W pour définir les adresses en hexadécimal
 Lorsque (R/W = 1) : Mode lecture seule, dans ce cas les adresses sont comprises entre 0x71 (71h) et 0x7F (7Fh).
 Lorsque (R/W = 0) : Mode écriture seule, dans ce cas les adresses sont comprises entre 0x70 (70h) et 0x7E (7Eh).

- Mode sans (R/W) : c’est-à-dire on peut configurer le PCF8574A on écriture et en lecture à la fois. Dans ce cas on ignore le R/W
et on travaille uniquement avec A0 à A6 pour définir les adresses en hexa.
 Les adresses dans ce cas sont comprises entre 0x38 (38h) et 0x3F (3Fh)

- On trouve aussi les broches VSS qui représente le GND (branché à la masse).
- On trouve aussi les broches VDD qui représente le 5V (branché à 5volt de l’arduino).
- On trouve aussi le INT qui permet d’interrompre matériellement le PCF8574A (interruption)

Au niveau du code Arduino :

- Pour travailler avec le I2C on doit inclure la bibliothèque « wire.h » d’où le #include <wire.h>
- Pour définir l’adresse d’un PCF8574A on utilise la syntaxe suivante : #define PCF8574A_ADDR 0x38  On déclare ou on
définit une variable nommée « PCF8574A_ADDR » qui prend la valeur 38 en hexadécimale d’où le « 0x ».

Dans la fonction setup() :

- On doit initialiser le bus I2C c’est-à-dire SDA (A4) et SCL (A5), pour cela on utilise : Wire.begin();
- Pour utiliser le moniteur série pour afficher quelque chose on doit l’initialiser aussi : Serial.begin(9600) ;
Dans la fonction loop() :
- Initialiser la transmission (On commence la transmission de données « écriture » ) : Wire.beginTransmission(PCF8574A_ADDR);
On remarque que cette fonction elle prend en paramètre la variable d’adresse déclarée en haut « PCF8574_ADDR », ce qui veut dire
qu’on a commencer la transmission avec le composant PCF8574A qui prend l’adresse « 0x38 ».
- Envoyer les données sur 8bits (1 octet) du microcontrôleurs Arduino vers le PCF8574A à travers le SDA et chaque bit sera
assigné à une broche de P0 à P7 : Wire.write(0b01111100);

0 1 1 1 1 1 0 0
P7 P6 P5 P4 P3 P2 P1 P0

Le « 0b » : veut dire une valeur sur 8 bits (1 octet). *

Pour écrire vers une LED ou un autre actionneur on doit activer la broche et pour l’activer on envoie un 0, pour la désactiver on envoie
un 1 et ça peut se comprendre électriquement. Exemple ici si on branche une LED à P4 :

5V
Si on veut calculer le courant qui passe par la LED pour voir si elle s’allume ou pas :
Résistance

 Si on envoie un 0 (0v) : Vd tension aux bornes de la diode, R*I tension aux bornes de
la résistance

Selon la loi des mailles : 5v – R*I – Vd - 0 = 0 alors I = (5 - Vd) / R (le courant I est positif, donc il
y a un courant circule alors la LED s’allumer)

 Si on envoie un 1 (5v) :

Selon la loi des mailles : 5v – R*I – Vd – 5v = 0 alors - R*I – Vd = 0, alors I = -Vd/R (courant
négatif, il n’existe pas de courant négatif dans le continue, donc aucun courant ne circulera,
électriquement il est considéré comme courant nul, c’est pour ça LED s’éteint.
Parfois on a besoin d’écrire sur une broche à la fois (P0 ou P1 ou P2, etc.) ou bien une partie de broche à la fois, pour cela on utilise ce
qu’on appelle les masques :
Ils existent deux masques :
Un masque en ET (&) : utilisé pour écrire un 0 (activer la broche)
Exemple pour écrire un 0 sur le P0 : On utilise ce masque (0b11111110), peu importe la valeur qu’on met sur P0 elle sera toujours égale
à 0 (1 & 0 = 0 et aussi 0 & 0 = 0).

c = 0b11111111 ;
c = c & 0b11111110;
Wire.beginTransmission(PCF8574A_ADDR);
Wire.write(c);
Wire.endTransmission();

Masque en OU ( | ) : utilisé pour écrire un 1 (désactiver la broche)

Exemple pour écrire un 1 sur le P0 : On utilise ce masque (0b00000001), peu importe la valeur qu’on met sur P0 elle sera toujours égale
à 1 (1 | 1 = 1 et aussi 0 | 1 = 1).

c = 0b11111111 ;
c = c & 0b00000001;
Wire.beginTransmission(PCF8574A_ADDR);
Wire.write(c);
 Wire.endTransmission();

Pour la lecture, y aura un changement au niveau de la fonction loop() :

- Demander de lire un octet : Wire.requestFrom(PCF8574A_ADDR, 1); le 1 correspond à un octet (8 bits), le PCF8574A_ADDR
correspond à l’adresse déclarer au début.
- Vérifier si une donnée est disponible pour la lecture, ensuite lire la donnée et la stocker dans une variable déclarée au
début comme « byte c ; »
while (Wire.available()) {
c = Wire.read();
}

Quand on écrit : Serial.println(variable,BIN); veut dire qu’on va afficher la valeur de variable en binaire ou en octet (des 0 et des 1)

Si on veut lire l’état d’une broche on utilise un masque, exemple si on veut lire d’état d’un bouton branché à P2 :
Faut savoir qu’en informatique toute valeur différente de zéro est considérée comme un « 1 logique » et la valeur nulle est considérée bien sûr comme un « 0
logique »

 Si le bouton branché à P2 est enfoncé donc il envoie la valeur « 0 » :

byte c = wire.read() donc le c sera égale à 0b11111011

Pour lire la valeur de P2 (état de bouton) on utilise ce masque :

bool P2 =c & 0b00000100;

Donc 0b11111011 & 0b00000100 = 0b00000000 ; ce qui donne une valeur égale à zéro ce qui donne une « 0 logique » donc on a récupéré l’état du bouton qui est
0 (enfoncé)

 Si le bouton branché à P2 est relâché donc il envoie la valeur « 0 » :

byte c = wire.read() donc le c sera égale à 0b11111111

Pour lire la valeur de P2 (état de bouton) on utilise ce masque :

bool P2 =c & 0b00000100;

Donc 0b11111111 & 0b00000100 = 0b00000100 ; ce qui donne une valeur différente de zéro ce qui donne un « 1 logique » donc on a récupéré l’état du bouton qui
est 1 (relâché)