Chapitre 8Livre « Arduino sous le capot »

Les entrées analogiques

Lire une tension avec fiabilité, de analogRead() aux registres du convertisseur

Température, lumière, position d’un bouton rotatif, tension d’une batterie : les grandeurs que mesure un système embarqué varient continûment, et les capteurs les traduisent en tensions. Pour que le programme puisse les exploiter, il faut les convertir en nombres. C’est le rôle du convertisseur analogique-numérique intégré à l’ATmega.

Ce chapitre présente d’abord le principe de la conversion – échantillonnage, quantification, résolution – et le fonctionnement du convertisseur à approximations successives de l’ATmega. Il montre ensuite comment l’utiliser avec analogRead() et analogReference(), comment raccorder des capteurs résistifs et des capteurs de température, et comment obtenir des mesures fiables. Il descend enfin au niveau des registres pour lancer les conversions sous interruption ou au rythme d’un timer, avant deux exemples complets.

Objectifs du chapitre

  • Expliquer l’échantillonnage et la quantification, et calculer la résolution d’un convertisseur.
  • Décrire le fonctionnement d’un convertisseur à approximations successives.
  • Mesurer une tension avec analogRead() et choisir la tension de référence adaptée.
  • Raccorder un capteur résistif par un pont diviseur et un capteur de température analogique.
  • Configurer l’ADC par ses registres, en interruption ou en déclenchement automatique.

Prérequis

Les entrées-sorties et les registres (chapitre 3), les timers en mode CTC (chapitre 7) et les interruptions (chapitre 6).

Plan du chapitre

  1. Partie I – Principe
  2. 8.1Analogique ou numérique ?
  3. 8.2Le convertisseur de l’ATmega
  4. Partie II – Avec Arduino
  5. 8.3analogRead() et la tension de référence
  6. 8.4Raccorder des capteurs
  7. 8.5Des mesures fiables
  8. Partie III – Avec les registres
  9. 8.6Les registres de l’ADC
  10. 8.7Interruption et déclenchement automatique
  11. Partie IV – Exemples et évaluation
  12. 8.8Deux exemples complets
  13. 8.9À retenir et QCM
  14. 8.10Sources et références

Chapitre 8 · Partie I

Principe

Comment passe-t-on d’une tension qui varie continûment à une suite de nombres ? Cette partie présente les notions d’échantillonnage et de quantification, puis le convertisseur de l’ATmega et sa méthode de conversion.

Chapitre 8 · Section 8.1

Analogique ou numérique ?

Le monde est analogique : une grandeur physique varie continûment, et un capteur la traduit en une tension qui peut prendre n’importe quelle valeur. Le microcontrôleur, lui, ne manipule que des nombres.

Figure 8.1 interactif – Du signal du capteur aux nombres : la tension (en bleu) est mesurée à intervalles réguliers et chaque échantillon (en orange) est remplacé par un niveau.

8.1.1Échantillonner et quantifier

Pour convertir une tension en nombres, il faut deux opérations (figure 8.1) :

  • échantillonner : prélever la tension à des instants réguliers. Chaque échantillon est encore une valeur analogique, une tension qui peut prendre n’importe quelle valeur ; seul le temps est devenu discret ;
  • quantifier : ranger chaque échantillon dans l’un des niveaux disponibles et lui attribuer un numéro. On obtient alors une valeur numérique, un nombre entier que le processeur peut traiter.

C’est le rôle du convertisseur analogique-numérique (CAN, en anglais ADC, Analog-to-Digital Converter) intégré à l’ATmega : il transforme une tension de 0 à 5 V en un nombre de 0 à 1023.

Définition – Convertisseur analogique-numérique

Circuit qui mesure une tension d’entrée et la traduit en un nombre entier proportionnel, compris entre 0 et 2n − 1 pour un convertisseur de n bits.

8.1.2Quantification et résolution

Figure 8.2 interactif – Quantification d’une tension : réglez la tension d’entrée et le nombre de bits du convertisseur.

Un convertisseur de n bits découpe la plage de 0 à Vréf en 2n niveaux. L’ADC de l’ATmega a 10 bits : 1 024 niveaux, numérotés de 0 à 1 023. L’écart entre deux niveaux est le quantum q, ou résolution, la plus petite variation de tension détectable :

q = Vréf / 1024 = 5 V / 1024 ≈ 4,88 mV
N = Ve × 1024 / Vréf (partie entière)    Ve ≈ N × Vréf / 1024

Toute tension comprise entre deux niveaux donne le même nombre : l’erreur de quantification peut atteindre un quantum. Par exemple, 2,5 V donne N = 2,5 × 1024 / 5 = 512. Une tension de 5 V donnerait 1 024, qui n’existe pas : la valeur maximale est 1 023. La figure 8.2 montre comment la finesse de la quantification augmente avec le nombre de bits.

Exercices

1. Quelle valeur renvoie l’ADC pour une tension de 1,8 V, avec Vréf = 5 V ?

N = 1,8 × 1024 / 5 = 368,64 : partie entière 368.

2. Un convertisseur 12 bits de référence 3,3 V équipe une autre carte. Quel est son quantum ?

212 = 4 096 niveaux : q = 3,3 / 4 096 ≈ 0,81 mV.

✎ Signaler une erreur dans cette section

Chapitre 8 · Section 8.2

Le convertisseur de l’ATmega

L’ATmega328P et l’ATmega2560 contiennent un seul convertisseur, partagé entre plusieurs entrées. Il convertit par approximations successives, en un temps fixe quelle que soit la tension.

Schéma de l’ADC de l’ATmega : multiplexeur, échantillonneur-bloqueur, comparateur, logique SAR et convertisseur numérique-analogique.
Figure 8.3 – Schéma de l’ADC de l’ATmega : multiplexeur, échantillonneur-bloqueur, comparateur, logique SAR et convertisseur numérique-analogique.

8.2.1Un seul convertisseur, plusieurs entrées

Le multiplexeur, commandé par les bits MUX, choisit l’entrée à mesurer. L’échantillonneur-bloqueur fige la tension pendant la conversion. Un comparateur la compare à une tension d’essai produite par un convertisseur numérique-analogique de 10 bits, piloté par la logique SAR. Le résultat est rangé dans les registres ADCH:ADCL. La tension de référence (AVcc, 1,1 V interne ou AREF) et l’horloge de l’ADC, obtenue en divisant les 16 MHz par 128, complètent le schéma (figure 8.3).

CaractéristiqueValeur
Résolution10 bits (0 à 1023)
EntréesUno : A0 à A5 · Nano : A0 à A7 · Mega : A0 à A15
Durée13 cycles d’horloge ADC, soit 104 µs (25 cycles pour la première mesure)
Cadence≈ 9 600 mesures par seconde
Horloge ADC50 à 200 kHz pour 10 bits précis ; 125 kHz avec le réglage Arduino
Plage d’entrée0 V à Vréf

Attention

Il n’y a qu’un convertisseur : les entrées sont mesurées l’une après l’autre, par le multiplexeur. Deux tensions ne peuvent pas être mesurées au même instant.

8.2.2Les approximations successives

Figure 8.4 interactif – La conversion par approximations successives, pas à pas : réglez la tension d’entrée et suivez les dix comparaisons.

Le convertisseur cherche N comme on devine un nombre en posant des questions « plus grand ou plus petit ? ». À chaque étape, il met à 1 le bit suivant en partant du poids fort, fabrique la tension correspondante avec son CNA et la compare à l’entrée : si Ve ≥ Vessai, le bit reste à 1, sinon il revient à 0. La première comparaison décide si la tension est au-dessus ou au-dessous de 2,5 V, la deuxième la situe dans le quart correspondant, et ainsi de suite (figure 8.4).

Dix bits demandent dix comparaisons, d’où une durée fixe quelle que soit la tension. Pendant tout ce temps, l’échantillonneur-bloqueur maintient la tension d’entrée constante.

Définition – Approximations successives (SAR)

Méthode de conversion par dichotomie : le résultat est construit bit par bit, du poids fort au poids faible, en comparant l’entrée à la tension correspondant au résultat partiel. Un convertisseur de n bits fait n comparaisons.

Exercices

1. Déroulez les trois premières étapes de la conversion de 3,2 V avec Vréf = 5 V.

Bit 9 : essai 512 → 2,5 V ; 3,2 ≥ 2,5, le bit reste à 1. Bit 8 : essai 768 → 3,75 V ; 3,2 < 3,75, le bit revient à 0. Bit 7 : essai 640 → 3,125 V ; 3,2 ≥ 3,125, le bit reste à 1. Le résultat commence par 101… ; le résultat final est 655.

2. Combien de mesures par seconde obtient-on en lisant A0 et A1 alternativement ?

Environ 9 600 conversions par seconde au total, soit environ 4 800 par entrée.

✎ Signaler une erreur dans cette section

Chapitre 8 · Partie II

Avec Arduino

La fonction analogRead() rend la conversion très simple. Bien l’utiliser suppose de choisir la tension de référence, d’adapter les capteurs à l’entrée et de se protéger du bruit.

Chapitre 8 · Section 8.3

analogRead() et la tension de référence

analogRead() lance une conversion, attend sa fin et renvoie le résultat. Sa précision dépend directement de la tension de référence, que l’on choisit avec analogReference().

Figure 8.5 interactif – Lire un potentiomètre : tournez-le et observez la valeur, la tension et le pourcentage affichés dans le moniteur série.

8.3.1Lire un potentiomètre

const int POT = A0;
void setup() {
  Serial.begin(9600);              // pas de pinMode() nécessaire
}
void loop() {
  int n = analogRead(POT);         // 0 à 1023, environ 100 µs
  float u = n * 5.0 / 1024;        // tension en volts
  int pc = map(n, 0, 1023, 0, 100);
  Serial.print(n);     Serial.print(" ");
  Serial.print(u, 2);  Serial.print(" V ");
  Serial.print(pc);    Serial.println(" %");
  delay(200);
}

Le potentiomètre est branché entre 5 V et GND, son curseur sur A0 (figure 8.5). Il n’est pas nécessaire d’appeler pinMode() : les broches A0 à A5 sont des entrées au démarrage. La fonction map() convertit proportionnellement une plage de valeurs en une autre.

Attention – La division entière

n * 5 / 1024 est un calcul entre entiers, qui ne donne que 0, 1, 2, 3 ou 4. Il faut écrire 5.0 pour que le calcul se fasse en virgule flottante et conserve les décimales.

Le traceur série de l’IDE (menu Outils) affiche les valeurs envoyées sous forme de courbe : c’est l’outil idéal pour observer l’évolution d’une mesure.

8.3.2La tension de référence

La fonction analogReference() choisit la tension de référence Vréf : DEFAULT (5 V, toutes les cartes), INTERNAL (1,1 V sur la Uno), INTERNAL1V1 et INTERNAL2V56 (1,1 V et 2,56 V sur la Mega) ou EXTERNAL (la tension appliquée sur la broche AREF). Une référence plus basse donne une meilleure résolution, mais réduit la plage : au-dessus de Vréf, la mesure reste bloquée à 1 023 (figure 8.6). La référence DEFAULT dépend de l’alimentation : sur USB, le « 5 V » peut ne valoir que 4,8 V et fausser toutes les mesures. Les références internes en sont indépendantes, mais leur valeur exacte varie de quelques pour cent d’un microcontrôleur à l’autre.

Figure 8.6 interactif – Comparer les références : réglez la tension à mesurer et observez la plage mesurable et la résolution de chaque référence.

Attention

  • Ne rien brancher sur AREF quand on utilise une référence interne : la tension externe serait court-circuitée par la référence interne.
  • Appeler analogReference(EXTERNAL) avant le premier analogRead().
  • Après un changement de référence, les premières mesures sont fausses : on les ignore.

✎ Signaler une erreur dans cette section

Chapitre 8 · Section 8.4

Raccorder des capteurs

L’ADC mesure une tension. Beaucoup de capteurs sont pourtant des résistances variables, et d’autres délivrent une tension trop grande ou trop faible. Le pont diviseur et le choix de la référence règlent la plupart de ces cas.

8.4.1Le pont diviseur

Photorésistance (LDR), thermistance (CTN), capteur de flexion : ces capteurs voient leur résistance varier avec la grandeur mesurée. On les place dans un pont diviseur avec une résistance fixe, et l’on mesure la tension au point milieu :

VA0 = 5 V × Rbas / (Rhaut + Rbas)

Figure 8.7 interactif – Le pont diviseur avec une photorésistance : réglez l’éclairement, la position de la LDR et la résistance fixe.

Définition – Pont diviseur

Deux résistances en série entre une tension et la masse. La tension au point commun est une fraction de la tension d’alimentation, fixée par le rapport des résistances. Il sert à mesurer une résistance variable ou à réduire une tension trop élevée.

8.4.2Capteurs de température analogiques

Le LM35 délivre 10 mV par °C, avec 0 V à 0 °C. À 25 °C, il ne fournit que 0,25 V : avec la référence de 5 V, un quantum de 4,88 mV vaut près de 0,5 °C. La référence interne de 1,1 V divise le quantum par 4,5 :

const int CAPTEUR = A0;           // sortie du LM35 : 10 mV par °C
void setup() {
  analogReference(INTERNAL);      // INTERNAL1V1 sur la Mega
  Serial.begin(9600);
  analogRead(CAPTEUR);            // 1re mesure après le changement : ignorée
}
void loop() {
  int n = analogRead(CAPTEUR);
  float u = n * 1.1 / 1024;       // tension en volts
  float t = u * 100.0;            // 10 mV/°C → °C
  Serial.print(t, 1);
  Serial.println(" °C");
  delay(500);
}

Avec 1,1 V, un pas vaut 1,07 mV, soit 0,1 °C ; la plage mesurable va de 0 à 110 °C.

CapteurSortieConversion
LM3510 mV/°C, 0 V à 0 °CT = U × 100
TMP3610 mV/°C, 0,5 V à 0 °CT = (U − 0,5) × 100
CTN 10 kΩrésistance qui diminue quand T montepont diviseur, puis formule non linéaire (coefficient β)

Le LM35 et le TMP36 ont trois broches (alimentation, sortie, masse) et une sortie directement proportionnelle à la température ; grâce à son décalage de 0,5 V, le TMP36 mesure aussi sous 0 °C. Pour une sortie numérique sans calcul ni étalonnage, on préfère le DS18B20 (chapitre 5).

✎ Signaler une erreur dans cette section

Chapitre 8 · Section 8.5

Des mesures fiables

Une mesure analogique est toujours entachée de bruit, et l’entrée de l’ADC a ses exigences. Quelques bonnes pratiques font la différence entre une valeur qui saute sans cesse et une mesure stable.

Figure 8.8 interactif – L’effet de la moyenne : comparez les mesures brutes et la valeur affichée après une moyenne de 1, 4, 16 ou 64 mesures.

8.5.1Les bonnes pratiques

Bruit. La dernière valeur varie souvent de ±1 ou 2. Faire la moyenne de plusieurs mesures réduit cette fluctuation (figure 8.8) :

int lireMoyenne(byte broche, byte n) {
  long somme = 0;
  for (byte i = 0; i < n; i++) somme += analogRead(broche);
  return somme / n;
}

Une moyenne de n mesures prend n fois 104 µs ; avec 16 mesures, on reste sous les 2 ms.

Impédance. L’échantillonneur-bloqueur doit se charger en peu de temps : la source doit présenter une résistance de moins de 10 kΩ. Au-delà, on ajoute un condensateur de 100 nF entre l’entrée et GND, qui fournit la charge nécessaire.

Changement d’entrée. La première mesure après un changement de broche ou de référence peut être fausse : on la lit deux fois et l’on garde la seconde.

Entrée en l’air. Une broche non branchée donne des valeurs au hasard, influencées par les entrées voisines.

Attention

Jamais de tension négative ni supérieure à 5 V sur une entrée. Pour mesurer une tension plus élevée, on utilise un pont diviseur ; une résistance série de quelques kilo-ohms protège l’entrée en cas de fausse manœuvre.

Exercices

1. Une LDR vaut 1 kΩ en pleine lumière et 50 kΩ dans l’obscurité. Elle est placée en haut du pont, avec 10 kΩ en bas. Quelles tensions obtient-on sur A0 ?

Lumière : 5 × 10 / (1 + 10) ≈ 4,55 V. Obscurité : 5 × 10 / (50 + 10) ≈ 0,83 V. La mesure augmente avec la lumière.

2. Un TMP36 fournit 0,72 V. Quelle est la température ? Quelle référence choisir pour mesurer de −40 à +80 °C ?

T = (0,72 − 0,5) × 100 = 22 °C. De −40 à +80 °C, la sortie va de 0,1 à 1,3 V : la référence de 1,1 V est trop faible. Sur une Mega, INTERNAL2V56 convient (quantum 2,5 mV, soit 0,25 °C) ; sur une Uno, on garde DEFAULT ou l’on applique une référence externe sur AREF.

3. Écrivez la fonction qui calcule la tension en volts à partir de la moyenne de 8 mesures, avec Vréf = 5 V.
float lireTension(byte broche) {
  long somme = 0;
  for (byte i = 0; i < 8; i++) somme += analogRead(broche);
  return somme / 8.0 * 5.0 / 1024;
}

✎ Signaler une erreur dans cette section

Chapitre 8 · Partie III

Avec les registres

analogRead() bloque le programme pendant chaque conversion et ne garantit pas un rythme régulier. En programmant directement l’ADC, on peut lancer les conversions sous interruption, en continu ou au rythme exact d’un timer.

Chapitre 8 · Section 8.6

Les registres de l’ADC

Trois registres de configuration et un registre de résultat suffisent à piloter l’ADC : ADMUX pour la référence et l’entrée, ADCSRA pour la marche, le lancement, l’interruption et le prédiviseur, ADCSRB pour le déclencheur automatique.

8.6.1Les registres de la Uno et de la Mega

Les deux cartes utilisent les mêmes registres, avec les mêmes noms et le même rôle. Seuls quelques bits changent, parce que l’ATmega2560 de la Mega possède seize entrées analogiques au lieu de huit et une référence interne supplémentaire. La figure 8.9 affiche les registres de chaque carte : choisissez l’entrée, la référence et le prédiviseur pour voir les bits concernés et les lignes de code correspondantes.

Figure 8.9 interactif – Les registres de l’ADC de la Uno et de la Mega 2560 : choisissez la carte, l’entrée, la référence et le prédiviseur.
  • ADMUX : référence (REFS1:0), alignement du résultat (ADLAR) et numéro de l’entrée, sur 4 bits pour la Uno (MUX3:0), sur 5 bits pour la Mega (MUX4:0) ;
  • ADCSRA, identique sur les deux cartes : mise en marche (ADEN), lancement (ADSC), déclenchement automatique (ADATE), drapeau (ADIF) et interruption (ADIE) de fin de conversion, prédiviseur (ADPS2:0) ;
  • ADCSRB : source du déclenchement automatique (ADTS2:0). Sur la Mega, il contient aussi le bit MUX5, à 1 pour les entrées A8 à A15 ; MUX4:0 donne alors le numéro moins 8 ;
  • DIDR0 désactive l’entrée numérique des broches A0 à A7 ; la Mega ajoute DIDR2 pour A8 à A15 ;
  • le résultat est dans le registre 16 bits ADC (ADCH:ADCL), sur les deux cartes.
REFS1:0UnoMegaADPS2:0DivisionADTS2:0Déclencheur
00AREFAREF0118000conversion continue
01AVcc (5 V)AVcc (5 V)10016010INT0
10réservéinterne 1,1 V10132100débordement Timer0
11interne 1,1 Vinterne 2,56 V11064101égalité B Timer1
111128 (Arduino)110débordement Timer1

Pour toutes les cartes

  • ADLAR = 1 aligne le résultat à gauche : lire seulement ADCH donne 8 bits, plus vite.
  • ADSC passe à 1 pour lancer une conversion et revient à 0 à la fin.
  • ADEN = 1 est obligatoire, sinon l’ADC est arrêté. Arduino le met à 1 au démarrage.
  • Désactiver l’entrée numérique des broches analogiques (DIDR0, DIDR2) réduit le bruit et la consommation.

Attention – Même code, référence différente

Le codage REFS1:0 = 11 sélectionne la référence interne de 1,1 V sur la Uno, mais celle de 2,56 V sur la Mega. Un programme écrit directement avec les registres pour une carte donne donc des mesures fausses sur l’autre ; analogReference(), qui utilise des noms différents selon la carte, évite ce piège.

8.6.2Lancer une conversion et lire le résultat

Une fois l’ADC configuré, chaque mesure se fait en trois temps : on met le bit ADSC à 1 pour lancer la conversion, on attend que le matériel le remette à 0, ce qui signale la fin de la conversion, puis on lit le résultat dans le registre ADC. La fonction lire() ci-dessous réalise ces trois étapes pour l’entrée A0 :

void setup() {
  ADMUX  = (1 << REFS0);                    // AVcc, entrée A0
  ADCSRA = (1 << ADEN)                      // ADC en marche
         | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);   // ÷ 128
}
unsigned int lire() {
  ADCSRA |= (1 << ADSC);             // lancer
  while (ADCSRA & (1 << ADSC)) { }   // attendre la fin
  return ADC;
}

Cette fonction fait le même travail qu’analogRead(A0). Comme elle, elle bloque le programme pendant toute la conversion, environ 104 µs avec le prédiviseur 128 : c’est le mode attente. La section 8.7 montre comment laisser le programme continuer pendant la conversion.

Le configurateur de la figure 8.10 écrit ce programme pour n’importe quel réglage : choisissez la carte, l’entrée, la référence, le prédiviseur, la taille du résultat et le mode de fonctionnement – attente, interruption ou conversion continue.

Figure 8.10 interactif – Configurateur de l’ADC : choisissez la carte, l’entrée, la référence, le prédiviseur, la taille du résultat et le mode de fonctionnement, et lisez le programme généré.

✎ Signaler une erreur dans cette section

Chapitre 8 · Section 8.7

Interruption et déclenchement automatique

Pour analyser un son ou un signal, il faut des échantillons pris à intervalles parfaitement réguliers, sans bloquer le programme. L’ADC peut lancer lui-même ses conversions au rythme d’un timer et prévenir le programme par une interruption.

8.7.1Trois modes de fonctionnement

Jusqu’ici, le programme lançait chaque conversion lui-même puis attendait sa fin. L’ADC sait faire mieux : il peut prévenir le programme par une interruption quand la mesure est prête, et même démarrer ses conversions tout seul. On distingue ainsi trois façons de l’utiliser :

  • analogRead() bloque le programme pendant environ 100 µs et ne garantit pas un rythme régulier.
  • Avec ADIE, la fin de conversion lance ISR(ADC_vect) : le programme continue pendant la mesure.
  • Avec ADATE, la conversion démarre seule à chaque événement choisi par ADTS : l’échantillonnage est régulier.
ModeRéglage
Conversion continueADATE = 1, ADTS = 000
Déclenchée par un timerADATE = 1, ADTS = 101 ou 110
Une à uneADATE = 0, ADSC = 1 à chaque fois

8.7.2Échantillonner à 1 kHz

Le Timer1 est réglé en CTC à 1 kHz (chapitre 7). Comme seule l’égalité B peut déclencher l’ADC, on donne à OCR1B la même valeur qu’à OCR1A : l’égalité B se produit en même temps que la remise à zéro. Chaque égalité lance une conversion, dont la fin déclenche l’interruption :

volatile unsigned int mesure;
volatile bool nouvelle = false;

void setup() {
  // Timer1 en CTC à 1 kHz
  TCCR1A = 0; TCCR1B = 0;
  OCR1A = 249; OCR1B = 249;                   // égalité B en même temps que A
  TCCR1B = (1 << WGM12) | (1 << CS11) | (1 << CS10);   // N = 64
  // ADC déclenché par l’égalité B du Timer1
  ADMUX  = (1 << REFS0);                      // AVcc, entrée A0
  ADCSRB = (1 << ADTS2) | (1 << ADTS0);       // ADTS = 101
  ADCSRA = (1 << ADEN) | (1 << ADATE) | (1 << ADIE)
         | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
}
ISR(ADC_vect) {
  mesure = ADC;
  nouvelle = true;
  TIFR1 = (1 << OCF1B);   // effacer le drapeau pour le prochain déclenchement
}

Attention

Le déclenchement se fait sur le front montant du drapeau OCF1B. Comme aucune routine ne traite l’interruption d’égalité B, ce drapeau n’est pas effacé automatiquement : il faut l’effacer dans l’ISR de l’ADC, sinon l’ADC ne repart plus.

Exercices

1. Quelle valeur écrire dans ADMUX pour mesurer A3 avec la référence interne de 1,1 V sur une Uno ?

REFS1:0 = 11 et MUX3:0 = 0011 : ADMUX = (1 << REFS1) | (1 << REFS0) | 3;, soit 0xC3.

2. Avec un prédiviseur de 16, quelle est la fréquence de l’horloge ADC ? Pourquoi ce réglage n’est-il pas conseillé pour des mesures sur 10 bits ?

16 MHz / 16 = 1 MHz, bien au-dessus des 200 kHz recommandés pour une précision de 10 bits. Les conversions sont plus rapides (13 µs) mais les derniers bits deviennent imprécis ; ce réglage ne se justifie que si 8 bits suffisent (ADLAR = 1, lecture d’ADCH).

3. Modifiez le programme d’échantillonnage pour obtenir 8 kHz.

125 µs × 16 MHz = 2 000 pas : avec N = 8, 250 pas, donc OCR1A = OCR1B = 249 et TCCR1B = (1 << WGM12) | (1 << CS11);. Une conversion durant 104 µs, 8 kHz reste possible, mais 9,6 kHz est la limite avec l’horloge ADC à 125 kHz.

✎ Signaler une erreur dans cette section

Chapitre 8 · Partie IV

Exemples et évaluation

Deux exemples complets – une lampe crépusculaire et un voltmètre de batterie – puis une synthèse, un questionnaire et les sources du chapitre.

Chapitre 8 · Section 8.8

Deux exemples complets

Une lampe qui s’allume à la tombée de la nuit et un voltmètre de batterie réunissent les techniques du chapitre : pont diviseur, moyenne, seuils et conversion en grandeur physique.

Figure 8.11 interactif – Lampe crépusculaire : la lumière baisse lentement avec du bruit ; comparez un seuil unique et deux seuils.

8.8.1Lampe crépusculaire avec hystérésis

const int LDR = A0;           // LDR en haut du pont, 10 kΩ en bas
const int LAMPE = 13;
const int SEUIL_ON  = 300;    // il fait nuit : allumer
const int SEUIL_OFF = 400;    // il fait jour : éteindre
bool allumee = false;

void setup() { pinMode(LAMPE, OUTPUT); }

void loop() {
  int n = analogRead(LDR);    // petite valeur = sombre
  if (!allumee && n < SEUIL_ON)  allumee = true;
  if (allumee  && n > SEUIL_OFF) allumee = false;
  digitalWrite(LAMPE, allumee);
  delay(100);
}

Avec un seul seuil, au crépuscule, la mesure bruitée oscille autour de la limite : la lampe clignote. Deux seuils séparés éliminent ce défaut : une fois allumée, la lampe ne s’éteint que lorsque la lumière a nettement augmenté (figure 8.11). L’écart entre les deux seuils s’appelle l’hystérésis.

Définition – Hystérésis

Écart entre le seuil de basculement dans un sens et le seuil de retour. Il évite les basculements répétés lorsque la grandeur mesurée, bruitée, fluctue autour d’un seuil unique.

8.8.2Voltmètre de batterie de 0 à 15 V

Figure 8.12 interactif – Simulation du voltmètre : réglez la tension de la batterie et observez la tension sur A0 et la valeur affichée.

Une tension de 15 V ne peut pas être appliquée à une entrée. Un pont diviseur de 20 kΩ et 10 kΩ la divise par 3 : 15 V donnent 5 V sur A0 (figure 8.12).

const int MESURE = A0;
const float RAPPORT = (20.0 + 10.0) / 10.0;   // 3
const float VREF = 5.0;                        // à mesurer pour être précis

void setup() { Serial.begin(9600); }

void loop() {
  long somme = 0;
  for (int i = 0; i < 16; i++) somme += analogRead(MESURE);
  float n = somme / 16.0;                      // moyenne de 16 mesures
  float ubat = n * VREF / 1024 * RAPPORT;
  Serial.print(ubat, 2);
  Serial.println(" V");
  delay(500);
}

La résolution vaut 4,88 mV × 3 ≈ 15 mV. La précision dépend de Vréf et des résistances : on mesure le 5 V réel de la carte au multimètre pour corriger VREF, et l’on utilise des résistances à 1 %. L’impédance du pont, 20 kΩ // 10 kΩ ≈ 6,7 kΩ, est proche de la limite de 10 kΩ : un condensateur de 100 nF entre A0 et GND est recommandé.

Exercices

1. Dimensionnez un pont diviseur pour mesurer une tension de 0 à 24 V.

Il faut un rapport d’au moins 24 / 5 = 4,8. Avec Rbas = 10 kΩ, Rhaut = 39 kΩ donne un rapport de 4,9 : 24 V produisent 4,9 V sur A0. La résolution est d’environ 24 mV.

2. Le voltmètre affiche 12,35 V alors qu’un multimètre indique 12,10 V. La carte est alimentée par USB et son « 5 V » mesure 4,90 V. Corrigez le programme.

Le programme suppose Vréf = 5 V au lieu de 4,90 V, d’où un excès de 2 % : 12,35 × 4,90 / 5 ≈ 12,10 V. On remplace VREF = 5.0 par VREF = 4.90.

✎ Signaler une erreur dans cette section

Chapitre 8 · Section 8.9

À retenir et QCM

Le tableau suivant résume les éléments essentiels de la conversion analogique-numérique. Le questionnaire de la figure 8.13 permet de vérifier qu’ils sont acquis.

ÉlémentÀ retenir
Conversion10 bits : N = Ve × 1024 / Vréf, de 0 à 1023 ; quantum 4,88 mV en 5 V
analogRead(A0)≈ 100 µs, environ 9 600 mesures par seconde, une entrée à la fois
analogReference()DEFAULT (5 V), INTERNAL 1,1 V (Uno), INTERNAL1V1 / INTERNAL2V56 (Mega), EXTERNAL
Pont diviseurV = 5 V × Rbas / (Rhaut + Rbas) : résistances variables, tensions supérieures à 5 V
ADMUX, ADCSRA, ADCSRBréférence et entrée · marche, lancement, interruption, prédiviseur · déclencheur

Bonnes habitudes

  • 0 à 5 V : Jamais de tension négative ou supérieure à Vréf (et à 5 V).
  • Calcul en float : n * 5.0 / 1024 : le .0 évite la division entière.
  • Moyenne : Plusieurs mesures pour réduire le bruit.
  • Hystérésis : Deux seuils pour éviter les basculements répétés.

8.9.1Se tester

Le QCM comporte vingt et une questions. Choisissez une réponse à la souris ou avec les touches 1 à 4, puis validez avec Entrée. En fin de questionnaire, chaque question manquée renvoie à la section qui donne les explications.

Figure 8.13 interactif – QCM d’évaluation du chapitre 8.

✎ Signaler une erreur dans cette section

Chapitre 8 · Section 8.10

Sources et références

La référence Arduino décrit analogRead() et analogReference() ; le chapitre « Analog-to-Digital Converter » des fiches techniques détaille les registres et les caractéristiques de l’ADC.

Référence Arduino

Fiches techniques

Pour aller plus loin

✎ Signaler une erreur dans cette section