Une sortie analogique pour l'Arduino: réseau R2R

Il y a quelques mois, nous avions exploré une première méthode pour produire un signal analogique au moyen d'une carte Arduino:  en faisant passer le signal modulé en largeur d'impulsion (pwm) par un filtre passe-bas (constitué d'une résistance et d'un condensateur), nous pouvions obtenir n'importe quelle tension continue située entre 0 et 5 V.  Il s'agit d'une méthode simple et efficace si nous désirons obtenir un signal continu, ou de basse fréquence. La présence du filtre passe-bas, toutefois, rend cette méthode peu satisfaisante si nous avons besoin d'un signal analogique qui varie rapidement.

Qu'à cela ne tienne, nous explorons aujourd'hui une autre façon d'ajouter une sortie analogique à notre carte Arduino:  nous allons construire un convertisseur numérique-analogique de type "réseau R-2R".

Combien de bits?

Plus notre système comporte un grand nombre de bits, meilleure sera la résolution du signal de sortie. Une meilleure résolution signifie que notre signal de sortie, tout en étant restreint à une valeur située entre 0 et 5 V, pourra prendre un plus grand nombre de valeurs possibles.

Par exemple, chaque sortie numérique de l'Arduino corespond à 1 bit:  elles peuvent prendre deux valeurs possibles:  0 ou 1 (0 ou 5 V).

Un système à 2 bits peut prendre 4 valeurs possibles:  les valeurs binaires 00, 01, 10 et 11 (qui pourraient correspondre, par exemple, à 0 V, 1,7 V, 3,3 V et 5 V).

Un système à 3 bits peut prendre 8 valeurs possibles:  les valeurs binaires 000, 001, 010, 011, 100, 101, 110 et 111 (si on sépare 5 volts en 8 parts égales, on obtient 0 V, 0,7 V, 1,4 V, 2,1 V, 2,9 V, 3,6 V, 4,3 V et 5 V).

Par contre, chaque bit étant contrôlé par une sortie de l'Arduino, plus notre système comporte un grand nombre de bits, plus il accaparera un grand nombre de sorties sur l'Arduino.

Je vous propose ici un réseau R-2R à 8 bits, ce que correspond à 256 valeurs possibles:  la tension de sortie pourra donc prendre n'importe quelle valeur située entre 0 et 5 volts, par bonds de 0,02 volts.

Le circuit

Le circuit s'appelle "réseau R-2R" parce qu'il est constitué d'une alternance de résistances identiques (R) et de leur double (2R).  J'ai utilisé des résistances R de 10 kΩ et des résistances 2R de 20 kΩ.

(Vous pouvez cliquer sur le schéma pour le voir en plus gros).

Attention à la précision des résistances:  si elles ne sont qu'approximativement égales, votre signal analogique risque de varier avec des bonds irréguliers.  J'ai mesuré chaque résistance utilisée, en ne retenant que celles qui se situaient à l'intérieur d'une tolérance de 0,5%.

Dans ce circuit, la sortie 2 de l'Arduino représente le bit de poids faible, alors que la sortie 9 représente le bit de poids fort.  Ainsi, si toutes les sorties sont à 0 sauf la numéro 2, ça correspond au nombre binaire 00000001, alors que si toutes les sorties sont à 0 sauf la numéro 9, ça correspond au nombre binaire 10000000.  La tension de sortie est nulle quand toutes les sorties sont à 0 (nombre binaire 00000000) et elle est à son maximum (presque 5 V) quand toutes les sorties sont à 5 V (nombre binaire 11111111).


Sketch

Voici d'abord un sketch qui permet à l'utilisateur d'entrer la valeur numérique de la tension de sortie qu'il désire au moyen du moniteur série.  Vous pouvez tester ce sketch en branchant un voltmètre à la sortie.

	/****************************************************************
	*
	* Utiliser ce sketch avec un réseau R-2R 8 bits branché
	* aux pins 2-3-4-5-6-7-8-9.
	*
	* L'utilisateur contrôle la tension de sortie (continue) au
	* moyen du moniteur série.
	*
	* https://electroniqueamateur.blogspot.com/2015/11/une-sortie-analogique-pour-larduino.html
	*
	***************************************************************/
	void setup() {
	// définition des pins 2 a 9 en sortie
	for (int x = 2; x <= 9; x++){
	pinMode(x,OUTPUT);
	}
	Serial.begin(9600);
	}
	void loop() {
	byte var;
	float tensionDesiree;
	int tensionInt;
	byte sorties;
	while (Serial.available() > 0){
	tensionDesiree = Serial.parseFloat(); // on récupere la valeur entrée par l'utilisateur
	if (tensionDesiree > 4.60) {
	Serial.println("La valeur maximale possible est de 4.60 volts.");
	tensionDesiree = 4.60;
	}
	if (tensionDesiree < 0) {
	Serial.println("La tension ne peut pas etre negative.");
	tensionDesiree = 0;
	}
	// transformation de la tension située entre 0 et 4.60 volts en un entier
	// situé entre 0 et 255
	tensionInt = map((tensionDesiree * 100), 0, 460,0,255);
	for (int x = 0; x <= 7; x++){
	var = tensionInt >> x; // bitshift vers la droite
	if (var & 1){ // l'avant-dernier bit est 1
	digitalWrite(2+x,1);
	}
	else
	{
	digitalWrite(2+x,0);
	}
	}
	Serial.print("La tension de sortie a ete reglee a ");
	Serial.print(tensionDesiree);
	Serial.println(" V");
	}
	}

view raw reseauR2R.ino hosted with ❤ by GitHub

Dans ce deuxième sketch, les sorties de l'Arduino prennent successivement toutes les valeurs binaires situées entre 00000000 et 11111111:  il en résulte un signal en dent de scie.  Ce signal pourrait être capté avec un oscilloscope, mais ici je l'ai mesuré au moyen de l'entrée A0 de l'Arduino.  On peut visualiser les valeurs numériques dans le moniteur série ou, mieux encore, visualiser le signal dans le nouveau traceur série de l'environnement de programmation Arduino.

	/****************************************************************
	*
	* Création d'un signal en dents de scie.
	*
	* Utiliser ce sketch avec un réseau R-2R 8 bits branché
	* aux pins 2-3-4-5-6-7-8-9.
	*
	* https://electroniqueamateur.blogspot.com/2015/11/une-sortie-analogique-pour-larduino.html
	*
	***************************************************************/
	byte compteur = B00000000;
	void setup() {
	for (int x = 2; x <= 9; x++){
	pinMode(x,OUTPUT);
	}
	Serial.begin(9600);
	}
	void loop() {
	byte var;
	int mesure;
	if (compteur < B11111111){
	compteur++;
	}
	else{
	compteur = 0;
	}
	for (int x = 0; x <= 7; x++){
	var = compteur >> x; // bitshift vers la droite
	if (var & 1){ // l'avant-dernier bit est 1
	digitalWrite(2+x,1);
	}
	else
	{
	digitalWrite(2+x,0);
	}
	}
	delay(100);
	mesure = analogRead(A0); // l'Arduino mesure la tension qu'il a lui-meme créée...
	Serial.println(mesure);
	}

view raw dentDeScie.ino hosted with ❤ by GitHub

Yves Pelletier   (Twitter, Facebook)