Circuit intégré PCF8591 (classe ICPCF8591)

Dans l'article traitant du bus I2C, un circuit intégré PCF8591 avait été utilisé comme exemple de périphérique esclave d'un Arduino Uno. Ce composant mérite qu'un article lui soit dédié. En effet, il est souvent utiliser en robotique pour délivrer une tension variable d'une part, et d'autre part il permet une extension du nombre d'entrées analogique pour les micro-contrôleurs en ne monopolisant que deux pins pour gérer le bus I2C, pins qui sont partagées par tous les périphériques compatibles avec ce protocole. Ce qui permet d'augmenter le nombre de capteurs à gérer.

Le composant PCF8591 est un convertisseur analogique/digital, digital/analogique. L'écriture ou la lecture des données numériques se fait par le biais d'un bus I2C. Et il dispose de quatre entrées analogiques AIN0 à AIN3, mais d'une seule sortie analogique AOUT.

Cet article décrit d'abord le brochage du PCF8591, puis à partir de deux projets exemples, expose le principe de programmation de ce composant à l'aide de la classe PCF8591.

Caractéristiques du PCF8591

Brochage du PCF8591

Le circuit intégré PCF8591 possède 16 broches dont la signification est la suivante :

N°	Nom	Description
1	AIN0	Entrée analogique 0.
2	AIN1	Entrée analogique 1.
3	AIN2	Entrée analogique 2.
4	AIN3	Entrée analogique 3.
5 à 7	A0 à A2	L'adresse I2C de base du PCF8591 est 0x48. Cette adresse est incrémentée par la valeur de ces trois broches.
8	VSS	Alimentation électrique du circuit. Doit être reliée à GND de l'Arduino..
9	SDA	Ligne Serial Data du bus I2C.
10	SCL	Ligne Serial Clock du bus I2C.
11	OSC	Oscillateur (horloge).
12	EXT	Commutateur d'horloge interne (valeur 0) / externe (valeur 1).
13	AGND	Tension 0 de référence pour les entrées/sorties analogiques. Doit être reliée à GND sur l'Arduino.
14	VREF	Tension 1 de référence pour les entrées analogique sur AIN0 à AIN3.
15	AOUT	Sortie analogique.
16	VDD	Alimentation électrique du circuit. Doit être reliée à +5V (ou éventuellement à +3V) sur l'Arduino.

La tension en entrée sur les broches AIN0 à AIN3 est convertie en une valeur numérique sur le bus I2C entre 0 et 255. 0 correspond à la tension de la broche 13 et 255 correspond à la tension de la broche 14 utilisées comme références.
Le PCF8591 dispose d'une horloge interne. Lorsque la broche 12 est à 0, cette broche expose l'oscillateur interne. Lorsque la broche 12 est à 1, une horloge externe peut être connectée à cette broche pour synchroniser le circuit avec d'autres composants.
Lorsqu'une valeur numérique entre 0 et 255 est écrite sur le bus I2C, celle-ci est convertie en une tension analogique exposée sur la broche 15. La tension correspondant à 0 est celle de la broche 13. La tension correspondant à 255 est celle de la broche 16.

Adressage du PCF8591 sur le bus I2C

Comme abordé dans l'article traitant du bus I2C, chaque périphérique I2C possède une adresse sur 7 bits. Cette adresse est arrêtée par le constructeur. Et, pour le PCF8591, l'adresse par défaut est fixée à la valeur 0x48.

Cependant on peut imaginer des projets utilisant plusieurs circuits PCF8591. Et il serait bon que ceux-ci, s'ils sont interconnectés sur le même bus, ne soient pas en conflit. C'est pourquoi, le PCF8591 est doté de trois broches A0, A1, A2 qui, selon le câblage, permettent de décaler l'adresse. Ce décalage est donc paramétrable sur trois bits qui sont ajouté à l'adresse par défaut.

A2	A1	A0	Adresse I2C
0	0	0	0x48 (par défaut)
0	0	1	0x49
0	1	0	0x4A
0	1	1	0x4B
1	0	0	0x4C
1	0	1	0x4D
1	1	0	0x4E
1	1	1	0x4F

Il est donc possible d'adresser ainsi, sur une même projet, huit PCF8591 connectés sur le même bus.

Définition de la classe ICPCF8591

Afin de faciliter l'utilisation du circuit PCF8591, voici la classe ICPCF8591. La définition de cette classe est contenue dans le fichier ICPCF8501.h et doit être inclus par la directive #include dans tous les projets où le circuit est utilisé.

/* 1 */
#ifndef ICPCF8591_h
#define ICPCF8591_h

/* 2 */
#include <Component.h>
#include <Wire.h>

/* 3 */
class ICPCF8591 : public Component {
/* 4 */
uint8_t __i2caddress;
/* 5 */
static const uint8_t BASE = 0x40;

public:
/* 6 */
static const uint8_t I2C_ADDRESS = 0x48;

/* 7 */
ICPCF8591(uint8_t=0);
/* 8 */
uint8_t I2CAddress() { return this->__i2caddress; }
/* 9 */
void begin(void);
void loop(void) { }
/* 10 */
uint8_t analogWrite(byte);
byte analogRead(uint8_t ainPin);
};

/* 1 */
#endif // ICPCF8591_h

Application de la bonne pratique consistant à définir les classes d'une bibliothèque entre deux directives #ifndef et #endif en prévention de multiples définitions dans les projets composites.
inclusion des définitions des classes utilisées par la classe ICPCF8591 par des directives #include :

Comme toutes les classes relatives à des composants électroniques, la classe ICPCF8591 implémente l'interface Component dont la définition se trouve dans le fichier Component.h.
La classe ICPCF8591 utilise la bibliothèque standard Wire dont la définition se trouve dans le fichier Wire.h.

La classe ICPCF8591 implémente l'interface Component. Ce qui l'oblige à implémenter les méthodes membres begin() et loop().
Comme tous les périphériques I2C, le circuit PCF8591 possède une adresse sur 7 bits. Cette adresse est régulièrement utilisée pour toutes les opérations de lecture ou d'écriture sur le bus I2C. Elle est mémorisée dans l'attribut privé __i2caddress.

Les commandes du PCF8591 utilisent le bit b₁₀. Cette valeur est définie dans la constante de classe privée BASE.
L'adresse I2C par défaut du PCF8591 est 0x48. Cette valeur est définie dans la constante de classe publique I2C_ADDRESS.
L'adresse I2C du PCF8591 peut être déplacée sur trois bits défini par le câblage des broches A0 à A2. Ce déplacement est passé en paramètre du constructeur de la classe ICPCF8591. Par défaut (lorsque les broches A0 à A2 sont reliées à la masse), le déplacement est 0 et l'adresse I2C effective du circuit est 0x48.
La méthode I2CAddress() expose l'attribut privé __i2caddress en lecture seule.
La classe ICPCF8591 implémentant l'interface Component, celle-ci doit implémenter les méthodes begin() et loop(). La méthode begin() doit être invoquée soit dans la méthode setup() de l'Arduino, soit dans la méthode begin() du composite utilisant le circuit. La méthode loop() ne fait rien. Elle est implémentée vide dans la définition de la classe ICPCF8591.
Implémentation des méthodes de lecture et d'écriture sur le bus I2C :

La méthode analogWrite() écrit la valeur de 8 bits passée en paramètre sur le bus I2C à destination du PCF8591. Cette valeur est transformée en une tension analogique que l'on récupère sur la broche AOUT du circuit. La valeur réelle de la tension dépend de la tension d'alimentation du circuit. Elle est égale à (VDD - AGND) * value / 255.
Il ne faut pas confondre cette méthode avec la fonction analogWrite() de l'Arduino qui, elle, écrite une valeur numérique sur une pin de micro-contrôleur paramétrée en PWM.
La méthode analogRead() lit une tension analogique sur la broche AINx ou x (de 0 à 3) est le paramètre passé à la méthode. La valeur récupérée est égale 255 * V / (VREF - AGND), où V est la tension en entrée sur la broche AINx.
Il ne faut pas confondre cette méthode avec la fonction analogRead() qui, elle, lit une tension analogique sur l'une des pins analogiques de l'Arduino A0 à A5. De plus la valeur retournée par la fonction Arduino est sur 10 bits (0 à 1023) contre 8 bits (0 à 255) sur le PCF8591.

Implémentation de la classe ICPCF8591

Constructeur de la classe ICPCF8591

Le circuit PCF8591 est connecté au bus I2C par les deux pins de l'Arduino dédiées à cet effet. Pour l'Arduino UNO, il s'agit des pins A4 (SDA) et A5 (SCL). L'adresse I2C est 0x48 par défaut. Mais elle peut être décalée sur 3 bits en fonction du câblage des broches A0 à A2 du PCF8591. Le décalage est alors passé en paramètre addrOffset du constructeur.

ICPCF8591::ICPCF8591(byte addrOffset) {
this->__i2caddress = I2C_ADDRESS + addrOffset ;
}

Le décalage addrAddress (0 par défaut) est ajouté à l'adresse I2C_ADDRESS du PCF8591 et stockée dans l'attribut privé __i2caddress. Cet attribut contient l'adresse I2C effective à utiliser pour les opérations de lecture et d'écriture sur le bus.

Méthode begin()

La méthode begin() est héritée de l'interface Component qui définit un polymorphisme sur tous les composants C++ en les obligeant à implémenter les méthodes begin() et loop(). Cette méthode doit être invoquée soit dans la méthode setup() du sketch Arduino, soit dans la méthode begin() des composites qui utilisent ce composant.

void ICPCF8591::begin(void) {
Wire.begin();
}

Dans le cas de la classe ICPCF8591, celle-ci utilisant la bibliothèque standard Wire, la seul chose à faire est d'invoquer la méthode begin() de cette bibliothèque. Ce qui va initialiser le bus I2C.

Méthode publique analogWrite()

La méthode analogWrite() écrit une valeur value de 8 bits sur le bus I2C à destination du PCF8591. L'adresse de ce circuit a été fixée par le constructeur. Cette valeur est convertie en une tension sur la broche AOUT du PCF8591. La valeur de cette tension dépend de la tension d'alimentation du circuit. Elle vaut (VDD - AGND) * value / 255. Le résultat de la méthode est 0 si tout s'est bien passé.

uint8_t ICPCF8591::analogWrite(byte value) {
Wire.beginTransmission(this->__i2caddress);
Wire.write(BASE);
Wire.write(value);
return Wire.endTransmission();
}

La méthode commence par une préemption du bus I2C pour initialiser un flux de données avec le périphérique dont l'adresse se trouve dans l'attribut __I2caddress en invoquant la méthode beginTransmission() de la bibliothèque Wire.
La première invocation de la méthode write() de la bibliothèque Wire initialise le PCF8591 en mode conversion Digital/Analogique. La valeur à passer est la valeur BASE (bit b₁₀ à 1).
La seconde invocation de la méthode write() permet de transmettre les 8 bits de value au PCF8591
La transmission est effective après l'invocation de la méthode endTransmission() de la bibliothèque Wire. Le résultat de cette méthode est 0 si l'écriture a bien eu lieu. Sinon un code erreur est renvoyé en résultat.

Méthode publique analogRead()

La méthode publique analogRead() lit une valeur de 8 bits par le bus I2C sur la broche dont le numéro ainPin est passé en paramètre. La tension V de la broche est convertie en une valeur numérique de 8 bits. La valeur résultante dépend aussi de la tension entre les broches VREF et AGND selon la forumule 255 * V / (VREF - AGND). La valeur x du paramètre ainPin fait référence à la broche AINx sur laquelle est mesurée la tension.

byte ICPCF8591::analogRead(uint8_t ainPin) {
Wire.beginTransmission(this->__i2caddress);
Wire.write(BASE | ainPin);
Wire.endTransmission();
Wire.requestFrom(int(this->__i2caddress), 1);
Wire.requestFrom(int(this->__i2caddress), 1);
byte value = Wire.read();
return value;
}

La méthode commence par une préemption du bus I2C pour initialiser un flux de données avec le périphérique dont l'adresse se trouve dans l'attribut __I2caddress en invoquant la méthode beginTransmission() de la bibliothèque Wire.
La méthode write() de la bibliothèque Wire est invoquée pour initialiser le PCF8591 en mode conversion Analogique/Digital sur la broche AINx. La valeur à passer est la valeur BASE (bit b₁₀ à 1) avec un OU avec x sur les bits b₀ et b₁.
L'initialisation est confirmée par l'invocation de la méthode endTransmission().
Une première requête en lecture est effectuée par l'invocation de la méthode requestFrom().

Le premier paramètre (de type int ???) correspond à l'adresse du composant sollicité pour une lecture. Le premier paramètre est de type int (sur deux octets). Ce qui est étrange puisque cela correspond à une adresse I2C sur 7 bits. Une conversion explicite de l'attribut __i2caddress (déclaré sur 8 bits) en int est nécessaire pour éviter une warning de compilation.
Le deuxième paramètre est le nombre d'octets attendus en lecture sur la ligne.

Pour une raison inconnue (si quelqu'un a une réponse rationnelle à me fournir...), il est nécessaire de réitérer la requête de lecture. Sinon la valeur retournée par la méthode read() correspond à la broche d'entrée analogique initialisée la fois précédente. C'est le seul moyen trouvé pour obtenir le comportement attendu. A savoir, que la valeur retournée correspond toujours à la broche passée en paramètre.
Une valeur est lue par l'invocation de la méthode read() de la bibliothèque Wire. Celle-ci renvoie une valeur sur 8 bits (1 octet). La conversion se fait (enfin normalement) à partir de la broche AINx correspondant à l'initialisation effectuée par l'invocation de la méthode write() entre beginTransmission() et endTransmission().

Application du PCF8591 pour piloter l'intensité lumineuse d'une LED

Cet exercice consiste à piloter l'intensité lumineuse d'une LED à l'aide d'un potentiomètre. La borne variable du potentiomètre est reliée à une entrée analogique du PCF8591. Et l'anone de la LED est reliée à la sortie analogique du convertisseur.

Même si cela peut paraître absurde de passer par un convertisseur, puisque électroniquement parlant, on pourrait obtenir le même résultat en connectant directement la borne du potentiomètre à l'anode de la LED, cet exercice a le mérite de mettre en oeuvre à la fois la conversion dans les sens Analogique-Digital par une lecture via le bus I2C de l'une des quatre entrées analogique du PCF8591, et dans les sens Digital-Analogique par une écriture du bus I2C pour générer une tension variable par programmation sur la broche de sortie connectée à le LED.

Câblage du projet

Le câblage de cet exercice reprend le câblage donné en exemple dans l'article de présentation du bus I2C. Mais au lieu de connecter la broche AOUT du PCF8591 à la pin A0 de l'Arduino, on la connecte à l'anode de la LED à piloter. Ce qui donne le schéma électrique suivant :

Les broches SDA de l'Arduino (pin A4) et du PCF8591 (broche 9) sont reliées entre elles. Une résistance 10 kΩ connecté sur le +5V de l'Arduino assure le pull-up de la ligne.
Les broches SCL de l'Arduino (pin A5) et du PCF8591 (broche 10) sont reliées entre elles. Une résistance 10 kΩ connecté sur le +5V de l'Arduino assure le pull-up de la ligne.
Les broches VDD et VREF du PCF8591 sont reliées au +5V. De ce fait les valeurs analogiques des tensions vont de 0 à +5V.
Les broches VSS, AGND et EXT du PCF8591 sont reliées à la masse.
Les broches EXT du PCF8591 sont reliées à la masse. Ce qui signifie que c'est l'horloge interne du circuit qui est utilisée sur le bus I2C. En conséquence, la broche OSC reste libre.
Les broches A0 à A2 du PCF8591 sont également reliées à la masse. Elle définissent ainsi l'adresse I2C du composant à la valeur 0x48.
Les trois broches d'entrées analogiques AIN0 à AIN2 sont laissées libres. La broche AIN3 est reliée à la borne variable d'un potentiomètre de 10KΩ.
Les deux autres bornes du potentiomètre sont reliées respectivement à 0 et +5V. Ce qui signifie que la tension délivrée par la borne variable du potentiomètre varie de (presque) 0 à +5V.
L'unique broche de sortie analogique AOUT est reliées à l'anode d'une LED protégée par une résistance de 220Ω.

Ce qui, traduit sur une platine d'expérimentation, donne :

Codage du sketch du projet

L'existence de la classe ICPCF8591 simplifie considérable l'écriture du sketch :

/* 1 */
#include "ICPCF8591.h"

/* 2 */
CPCF8591 pcf;

/* 3 */
void setup() {
pcf.begin();
}

/* 4 */
void loop() {
byte value = pcf.analogRead(3);
pcf.analogWrite(value);
delay(1);
}

Pour pouvoir utiliser la classe ICPCF8591, il faut inclure sa définition qui se trouve dans le fichier ICPCF8591.h.
Déclaration de l'instance pcf de la classe ICPCF8191. Aucun paramètre n'est spécifié au constructeur. Ce qui signifie que l'adresse 0x48 par défaut est utilisée sur le bus I2C. Ce qui est cohérent avec le câblage ci-dessus où les trois broches A0, A1 et A2 du PCF8591 sont reliées à la masse.
Dans la fonction setup(), le PCF8591 est initialisé par l'invocation de la méthode begin() sur l'instance pcf.
Dans la boucle loop(), une valeur value est lue (via le bus I2C) sur l'entrée analogique AIN3 (connectée à la borne variable du potentiomètre de 10KΩ) par l'invocation de la méthode analogRead() sur l'instance pcf, puis réécrite pour être convertie en tension sur la broche AOUT du PCF8691 (connectée à l'anode de la LED) par l'invocation de la méthode analogWrite().

Application du PCF8591 pour piloter la couleur d'une LED RGB.

Cet exercice consiste à piloter la couleur d'une LED Couleur RGB à l'aide de trois potentiomètre. Le principe est le même qu pour l'exercice précédent. La borne variable des potentiomètres est reliée respectivement aux entrée analogique AIN0, AIN1 et AIN2 du PCF8591. Le circuit ne possédant qu'une seule sortie analogique, les trois anones de la LED couleur sont reliées à trois pins PWM de l'Arduino. Précaution importante à prendre quant au choix de ces trois pins : toutes les pins de l'Arduino ne permettent pas l'usage d'une sortie analogique en PWM. Seules, celles signalées par un moins (-) le permettent. Pour cet exercice, les anones de la LED relatives aux composantes de couleur rouge, verte et bleue sont respectivement connectées aux pin 3, 5 et 6 (la 4 ne permettant pas le PWM) del'Arduino.

Cet exercice n'a pas beaucoup plus de sens que le précédent, puisqu'on pourrait arriver au même résultat en connectant les trois anones directement à la borne variable des trois potentiomètre.
Mais il permet de mettre en évidence un petit problème rencontré avec la bibliothèque Wire (ou avec le PCF8591). En effet, lors d'une lecture analogique sur une broche AINx déterminée du circuit, la valeur retournée retournée est toujours celle correspondant à l'initialisation précédente avec la fonction entre beginTransmission() et endTransmission() et non pas à la dernière initialisation. Ce qui provoquai un comportement incohérent du robot. Le problème peut être résolu (sans explication rationnelle) en effectuant deux appels successifs à la méthode requestFrom() avant de procéder à la lecture. Ce qui a été implémenté dans la méthode anologRead() de la classe ICPCF8591.

Câblage du projet

Le câblage de cet exercice reprend le câblage de l'exercice précédent. Mais les anodes de la LED couleur RGB sont reliées à des sortie PWM de l'Arduino. Ce qui donne le schéma électrique suivant :

Les broches SDA de l'Arduino (pin A4) et du PCF8591 (broche 9) sont reliées entre elles. Une résistance 10 kΩ connecté sur le +5V de l'Arduino assure le pull-up de la ligne.
Les broches SCL de l'Arduino (pin A5) et du PCF8591 (broche 10) sont reliées entre elles. Une résistance 10 kΩ connecté sur le +5V de l'Arduino assure le pull-up de la ligne.
Les broches VDD et VREF du PCF8591 sont reliées au +5V. De ce fait les valeurs analogiques des tensions vont de 0 à +5V.
Les broches VSS, AGND et EXT du PCF8591 sont reliées à la masse.
Les broches EXT du PCF8591 sont reliées à la masse. Ce qui signifie que c'est l'horloge interne du circuit qui est utilisée sur le bus I2C. En conséquence, la broche OSC reste libre.
Les broches A0 à A2 du PCF8591 sont également reliées à la masse. Elle définissent ainsi l'adresse I2C du composant à la valeur 0x48.
Les trois broches d'entrées analogiques AIN0 à AIN2 sont reliées à la borne variable d'un potentiomètre de 10KΩ. La broche AIN3, elle, est laissée libre.
Les deux autres bornes des potentiomètres sont reliées respectivement à 0 et +5V. Ce qui signifie que la tension délivrée par la borne variable du potentiomètre varie de (presque) 0 à +5V.
L'unique broche de sortie analogique AOUT est laissée libre. En effet, il faudrait trois sortie analogique pour piloter les trois composantes de couleur d'une LED RGB.
Les trois anodes de la LED sont reliées au pins 3, 5 et 6 de l'Arduino. Elles sont respectivement protégées par une résistance de 220Ω. Une tension variable est délivrée sur ces trois broches en mode PWM. Aussi les broches de l'Arduino choisies doivent être capables de délivrer ce type de tension. Celles-ci sont signalées par un -.

Ce qui, traduit sur une platine d'expérimentation, donne :

Codage du sketch du projet

Le sketch de cet exercice reprend le principe de l'exercice précédent adapté à une LED RGBnbsp;:

/* 1 */
#define RED_PIN 3
#define GREEN_PIN 5
#define BLUE_PIN 6

/* 2 */
#include "RGBLed.h"
#include "ICPCF8591.h"

/* 3 */
RGBLed led(RED_PIN, GREEN_PIN, BLUE_PIN);
/* 4 */
ICPCF8591 pcf;

/* 5 */
void setup() {
pcf.begin();
led.begin();
}

/* 6 */
void loop() {
byte red = pcf.analogRead(0);
byte green = pcf.analogRead(1);
byte blue = pcf.analogRead(2);
led.setColor(red, green, blue);
delay(1);
}

Les pins de l'Arduino utilisées sont déclarées en constantes. Le pin 3, 5 et 6 sont respectivement connectée aux anodes RED, GREEN et BLUE de la LED.
Pour pouvoir utiliser la classe ICPCF8591, il faut inclure sa définition qui se trouve dans le fichier ICPCF8591.h. Le sketch utilise également la classe RGBLed, dont la définition se trouve dans le fichier RGBLed.h, pour piloter la LED couleur.
Déclaration de l'instance led de la classe RGBLed. Les trois pins auxquelles sont connectées les anodes de la LED sont passées en paramètres du constructeur.
Déclaration de l'instance pcf de la classe ICPCF8191. Aucun paramètre n'est spécifié au constructeur. Ce qui signifie que l'adresse 0x48 par défaut est utilisée sur le bus I2C. Ce qui est cohérent avec le câblage ci-dessus où les trois broches A0, A1 et A2 du PCF8591 sont reliées à la masse.
Dans la fonction setup(), le PCF8591 et la LED sont initialisés par l'invocation de leur méthode begin() respective.
Dans la boucle loop(), la valeur des composantes de couleurs red, green et blue sont lues (via le bus I2C) respectivement sur les entrées analogiques AIN0 à AIN2 (qui sont connectées à la borne variable d'un potentiomètre de réglage) par l'invocation de la méthode analogRead() sur l'instance pcf. Ces trois valeurs sont utilisées pour modifier la couleur de la LED en invoquant la méthode setColor() sur l'instance led.

Conclusion

De même façon que le circuit intégré 74HC595 procure une extension du nombre de sorties numériques pour les micro-contrôleur Arduino en ne mobilisant que trois pins sur celui-ci, de même le PCF8591 fournit une extension du nombres d'entrées analogiques. Ce qui permet de multiplier les capteurs gourmands de ce type de connexion. De plus, le fait d'utiliser le bus I2C permet de connecter d'autre circuits compatibles avec ce protocole sans monopoliser de sortie ou d'entrée supplémentaire.

Le système de décalage d'adresse sur 3 bits basé sur le câblage des broches A0 à A2 permet de faire cohabiter jusqu'à 8 circuit PCF8591 dans un même projet. Ce qui ajoute potentiellement 8 entrées et 32 sorties analogiques suplémentaires.

Pour en revenir au circuit 74HC595, les huit sorties numériques offertes monopolisent trois pins sur l'Arduino. La question d'un circuit intégré, compatible I2C, offrant les mêmes services se pose pour libérer les trois pins en question. En effet, il existe un tel circuit — le PCF8574 — qui rend ce service, à savoir offrir huit entrées/sorties parallèles supplémentaires. Un prochain article traitera du pilotage d'un module LCD 1602 par le bus I2C par le biais de ce circuit.

Applications Arduino