Convertisseur analogique-numérique (ADC) avec Arduino et ESP32

Un ADC (convertisseur analogique-numérique, ou CAN) est le circuit qui transforme la tension présente sur une broche, qui peut varier en continu, en un nombre que le microcontrôleur peut exploiter. Chaque fois que tu appelles analogRead() sur un Arduino, ce convertisseur travaille en coulisse : l'ADC 10 bits de l'Arduino Uno transforme une tension comprise entre 0 et 5 V en un nombre de 0 à 1023, tandis que les ADC 12 bits de l'ESP32 et du Raspberry Pi Pico transforment environ 0–3,3 V en un nombre de 0 à 4095. L'ADC est la clé pour lire tout composant à sortie analogique : potentiomètres, LDR, capteurs d'humidité du sol, joysticks et capteurs de température.

Dans ce guide, tu vas découvrir la différence entre signaux analogiques et numériques, comment un ADC convertit une tension en nombre étape par étape, et comment la résolution et la tension de référence influencent tes mesures. Avec des chiffres réels, nous verrons la formule qui convertit une mesure en volts, la modification de la plage de mesure avec analogReference, la fréquence d'échantillonnage et des moyens pratiques de réduire le bruit. Nous aborderons aussi l'ADC de l'ESP32, non linéaire aux extrémités, le conflit entre l'ADC2 et le Wi-Fi et le réglage d'atténuation, l'utilisation de l'ADC du Raspberry Pi Pico en MicroPython et, pour finir, une courte introduction au DAC, qui fait exactement l'inverse.

Quelle est la différence entre un signal analogique et un signal numérique ?

Un signal analogique est une grandeur qui peut prendre une infinité de valeurs dans une plage donnée et qui varie de façon continue dans le temps. Quand la tension sur la broche centrale d'un potentiomètre passe de 0 V à 5 V, elle traverse toutes les valeurs intermédiaires, comme 1,2 V, 1,21 V ou 1,215 V ; l'onde sonore d'un micro, la tension d'une thermistance qui varie avec la température ou la tension d'une pile qui baisse lentement sont aussi analogiques. Un signal numérique, lui, ne connaît que certains niveaux. Dans le monde de la logique de l'Arduino, il y en a deux : LOW (0) et HIGH (1). Sur l'Uno, une entrée numérique considère tout ce qui est en dessous d'environ 1,5 V comme LOW et tout ce qui dépasse 3,0 V comme HIGH ; la zone intermédiaire est indéfinie. C'est pourquoi digitalRead() ne fait pas la différence entre 3,7 V et 4,2 V sur une batterie et répond HIGH dans les deux cas. La force du signal numérique est sa résistance au bruit : 4,6 V et 5,0 V signifient le même HIGH. Pour mesurer, enregistrer ou utiliser dans un calcul une valeur analogique, il faut d'abord la convertir en nombre, autrement dit en valeur numérique, et c'est le rôle de l'ADC.

Qu'est-ce qu'un ADC et comment fonctionne-t-il ?

Le travail d'un ADC se résume en deux étapes. La première est l'échantillonnage : au moment de la mesure, le convertisseur copie la tension d'entrée sur un petit condensateur (circuit d'échantillonnage-blocage) et la maintient constante jusqu'à la fin de la conversion ; sur l'ATmega328P, ce condensateur fait environ 14 pF. La seconde est la quantification : la tension maintenue est arrondie au palier le plus proche d'une échelle qui divise la tension de référence en paliers égaux, et le numéro de ce palier est renvoyé comme résultat. Les ADC de l'Arduino Uno, de l'ESP32 et du Pico sont tous du type à approximations successives (SAR, Successive Approximation Register). Un ADC SAR fonctionne comme un jeu de devinette : il essaie d'abord la moitié de la référence, met le bit de poids fort à 1 si l'entrée est plus grande et le laisse à 0 si elle est plus petite, puis essaie la moitié de la plage restante et répète l'opération pour chaque bit. Un ADC 10 bits trouve ainsi le bon palier parmi 1024 possibilités en seulement 10 comparaisons. Pour simplifier, le tableau montre comment un ADC 4 bits avec une référence de 5 V mesure une entrée de 3,2 V :

L'écart de 0,075 V dans le résultat est l'erreur de quantification, et aucun ADC n'y échappe : si la tension réelle se situe entre deux paliers, l'ADC ne peut indiquer que l'un des deux. L'erreur reste inférieure à un palier (LSB) ; plus le palier est petit, plus la mesure est fine. Comme le condensateur d'échantillonnage doit se charger à chaque mesure, la résistance de la source qui attaque l'ADC compte aussi : la fiche technique de l'ATmega328P recommande une impédance de sortie d'environ 10 kΩ ou moins ; un pont diviseur de tension plus résistif n'arrive pas à charger le condensateur à temps et les mesures dérivent. En plus du type SAR des microcontrôleurs, il existe d'autres familles d'ADC. Les ADC sigma-delta sont lents mais très précis : le HX711 utilisé dans les projets de pesée offre 24 bits, et le module ADS1115 relié en I2C, 16 bits. Les ADC flash utilisent un comparateur distinct pour chaque palier ; ils sont extrêmement rapides et équipent par exemple les oscilloscopes.

Résolution de l'ADC : que signifient 10 bits et 12 bits ?

La résolution indique en combien de paliers l'ADC découpe sa plage de mesure. Un ADC de N bits produit 2^N paliers : 10 bits correspondent à 1024 paliers (0–1023), 12 bits à 4096 (0–4095) et 16 bits à 65 536. La tension d'un palier s'appelle le LSB (bit de poids faible) et se calcule avec LSB = Vref / 2^N. Sur l'Arduino Uno, cela donne 5 V / 1024 = 4,88 mV, et sur l'ESP32 et le Pico, 3,3 V / 4096 = 0,81 mV. L'Uno ne voit donc pas les variations inférieures à 4,88 mV ; avec un LM35 qui délivre 10 mV/°C, cela représente un pas d'environ 0,5 °C. Mais résolution et précision ne sont pas la même chose. Le bruit, la non-linéarité et l'erreur de référence d'un ADC rendent inutiles une partie des bits annoncés sur le papier. On mesure cela avec le nombre effectif de bits (ENOB) : l'ADC du RP2040 du Raspberry Pi Pico fournit un résultat sur 12 bits, mais selon sa fiche technique son nombre effectif de bits est de 8,7. Comparons les ADC des trois cartes :

Formule pour convertir la valeur de l'ADC en volts

Le nombre renvoyé par l'ADC ne veut rien dire tout seul ; pour le convertir en tension, tu utilises la tension de référence et le nombre de paliers : Tension = valeur ADC × Vref / 2^N. Sur l'Arduino Uno, cela donne V = valeur × 5,0 / 1024 ; si analogRead() a renvoyé 512, la tension sur la broche est de 512 × 5 / 1024 = 2,50 V. Dans l'autre sens, tu trouves le nombre correspondant à une tension avec valeur = V × 1024 / Vref : 3,3 V se lit environ 675 sur l'Uno. Dans beaucoup d'exemples, on divise par 1023 au lieu de 1024. La fiche technique de l'ATmega328P donne la formule ADC = Vin × 1024 / Vref ; la valeur maximale, 1023, représente un palier sous Vref. Diviser par 1023 affiche exactement 5,00 V pour la valeur maximale, mais décale toutes les valeurs d'environ 0,1 %. Cet écart est plus petit que l'erreur propre de l'ADC (±2 LSB), donc les deux conviennent ; l'important est de rester cohérent dans le projet. La vraie grosse source d'erreur, c'est Vref lui-même : la broche 5V d'un Uno alimenté en USB se situe souvent entre 4,7 et 5,1 V, et écrire 5,0 dans la formule entraîne jusqu'à 5 % d'erreur. Pour des mesures précises, mesure donc la broche 5V avec un multimètre et mets la vraie valeur dans le code. L'unique entrée analogique de l'ESP8266 (A0) est elle aussi sur 10 bits ; la puce mesure 0–1 V, et le pont diviseur intégré sur des cartes comme la NodeMCU et la Wemos D1 Mini étend cette plage à environ 0–3,2 V.

Câbler un potentiomètre : Arduino, ESP32 et Pico

Pas à pas : ta première mesure ADC avec Arduino

1. Monte le circuit : relie les broches extérieures d'un potentiomètre de 10 kΩ au 5V et au GND, et sa broche centrale à A0.
2. Mesure la broche 5V : mesure au multimètre la tension entre 5V et GND et reporte-la dans la constante VREF du code (par ex. 4.93).
3. Téléverse le code : ouvre le sketch ci-dessous dans l'IDE Arduino, choisis la carte et le port, puis téléverse-le.
4. Ouvre le moniteur série : règle-le sur 9600 bauds et regarde la valeur de l'ADC varier entre 0 et 1023 quand tu tournes le bouton (détails dans le guide du moniteur série).
5. Vérifie : mesure au multimètre entre A0 et GND et compare avec la tension affichée ; l'écart devrait rester autour de 10–20 mV.

1// Potansiyometreyi ADC ile okuma / Reading a potentiometer with the ADC
2// Kenar bacaklar 5V ve GND'ye, orta bacak A0'a / Outer legs to 5V and GND, wiper to A0
3const int POT_PIN = A0;
4const float VREF = 5.0;      // 5V pininde ölçtüğün gerilim / voltage you measured on the 5V pin
5
6void setup() {
7  Serial.begin(9600);
8}
9
10void loop() {
11  int raw = analogRead(POT_PIN);             // 0-1023 arası sayı / number between 0-1023
12  float volts = raw * VREF / 1024.0;         // sayıyı volta çevir / convert the number to volts
13  int percent = map(raw, 0, 1023, 0, 100);   // yüzdeye ölçekle / scale to percent
14
15  Serial.print(F("ADC: "));
16  Serial.print(raw);
17  Serial.print(F("  Gerilim / Voltage: "));
18  Serial.print(volts, 3);
19  Serial.print(F(" V  Yuzde / Percent: "));
20  Serial.println(percent);
21  delay(200);
22}

analogRead() termine une mesure en environ 100 µs et renvoie un entier entre 0 et 1023. Le code convertit d'abord ce nombre en volts avec la formule, puis en pourcentage avec map(). Comme map() travaille en arithmétique entière, il supprime la partie décimale ; si tu as besoin d'un résultat à virgule, fais le calcul toi-même avec un float. Il s'agit d'une mesure ratiométrique : comme le potentiomètre et l'ADC sont alimentés par le même 5 V, la position du bouton, donc la valeur de l'ADC, ne change pas même si l'alimentation descend à 4,9 V ; seule la tension calculée change. Il en va de même pour les capteurs lus via un pont diviseur, comme les LDR et les CTN. En revanche, quand tu mesures la tension d'une pile ou un capteur à sortie fixe en mV comme le LM35, la valeur réelle de Vref se répercute directement sur le résultat.

Tension de référence et analogReference

La tension de référence (Vref) est le haut de l'échelle de l'ADC : si la tension d'entrée atteint ou dépasse Vref, le résultat reste bloqué à la valeur maximale (1023). Réduire Vref rétrécit la plage de mesure, mais rend chaque palier plus petit, ce qui permet de mesurer plus finement les petits signaux. Sur l'Arduino Uno, tu choisis la référence avec la fonction analogReference(). Avec l'option INTERNAL, Vref passe à 1,1 V et un palier descend à 1,07 mV ; tu peux lire un LM35 (10 mV/°C) par pas d'environ 0,1 °C, mais en contrepartie rien au-dessus de 1,1 V, soit 110 °C, n'est mesurable. La référence interne de 1,1 V elle-même peut varier entre 1,0 et 1,2 V d'une puce à l'autre ; pour les projets précis, un étalonnage unique au multimètre s'impose. Les premières mesures après un changement de référence peuvent être fausses, comme le signale aussi la documentation Arduino, donc jeter quelques mesures après le changement est une bonne habitude. Par ailleurs, ce réglage s'applique à toutes les broches analogiques de la carte à la fois. Les options diffèrent selon la carte :

Fréquence d'échantillonnage : combien de mesures par seconde ?

La fréquence d'échantillonnage correspond au nombre de mesures que l'ADC peut faire en une seconde. Sur l'Arduino Uno, l'horloge de l'ADC est réglée à 125 kHz en divisant les 16 MHz par 128, et une conversion dure 13 cycles d'horloge ; c'est pourquoi analogRead() prend environ 100 µs et qu'on peut faire au maximum à peu près 10 000 mesures par seconde. Pour des grandeurs qui varient lentement, comme la température, la lumière ou la tension d'une batterie, c'est largement suffisant ; souvent, 10 mesures par seconde suffisent même. Pour les signaux rapides, c'est le théorème de Nyquist qui s'applique : pour capter un signal sans le perdre, il faut échantillonner au moins deux fois plus vite que sa fréquence la plus élevée, et en pratique on préfère 5 à 10 fois. Pour voir le ronflement secteur à 50 Hz, il faut au moins 100 mesures/s, et pour enregistrer la voix jusqu'à 4 kHz, au moins 8 000 mesures/s. Si tu as besoin de mesurer plus vite sur l'Uno, tu peux réduire le prédiviseur de l'ADC : avec ADCSRA = (ADCSRA & 0xF8) | 0x04; dans setup(), le prédiviseur passe à 16, l'horloge de l'ADC monte à 1 MHz et analogRead() descend à environ 16 µs, au prix d'un peu de précision. Sur l'ESP32, des appels isolés à analogRead() permettent des dizaines de milliers de mesures par seconde, et le mode continu avec DMA (analogContinuous() sous Arduino) permet de choisir une fréquence entre 20 kHz et 2 MHz ; ce mode ne fonctionne qu'avec les broches de l'ADC1. L'ADC du Raspberry Pi Pico tourne sur sa propre horloge de 48 MHz, termine chaque conversion en 96 cycles, soit 2 µs, et atteint 500 000 mesures par seconde ; une boucle MicroPython ne peut pas suivre ce rythme, et pour la pleine vitesse il faut le SDK C et le DMA.

ADC de l'ESP32 : non-linéarité, conflit ADC2/Wi-Fi et atténuation

Sur le papier, l'ADC 12 bits de l'ESP32 mesure quatre fois plus finement que celui de l'Uno, mais en pratique il faut surveiller trois points. Le premier est la non-linéarité : près de 0 V, l'ADC de l'ESP32 lit 0 jusqu'à environ 100–150 mV, et en haut de l'échelle il sature à 4095 avant que l'entrée n'atteigne 3,3 V ; la courbe entre les deux n'est pas non plus une droite parfaite. Le deuxième est la dispersion de la référence : par conception, la référence interne de l'ESP32 vaut 1100 mV, mais d'après Espressif elle varie entre 1000 et 1200 mV d'une puce à l'autre, ce qui représente une erreur d'environ ±9 % sur des mesures non étalonnées. C'est pourquoi Espressif inscrit des données d'étalonnage dans les eFuses des puces en production. La fonction Arduino analogReadMilliVolts() utilise ces données pour convertir directement la valeur brute en millivolts étalonnés et donne, dans la plupart des cas, un résultat bien plus juste que le calcul analogRead() × 3,3 / 4095. Le troisième est l'atténuation : le cœur de l'ADC ne mesure que jusqu'à environ 1 V, et les tensions plus élevées sont réduites par un atténuateur réglable à l'entrée. Sous Arduino, le réglage par défaut est de 11 dB, ce qui permet de lire jusqu'à environ 3,1 V, mais la plage précise recommandée par Espressif pour ce réglage est de 150 à 2450 mV. Pour les petits signaux, baisser l'atténuation améliore à la fois la précision et la résolution :

1// ESP32 ADC: ham değer ve kalibre milivolt / ESP32 ADC: raw value and calibrated millivolts
2// Potansiyometre: 3V3, GND ve orta bacak GPIO 34 / Pot: 3V3, GND and wiper to GPIO 34
3const int POT_PIN = 34;      // ADC1_CH6, Wi-Fi açıkken de çalışır / ADC1_CH6, works with Wi-Fi on
4
5void setup() {
6  Serial.begin(115200);
7  analogReadResolution(12);                     // 0-4095 (varsayılan / default)
8  analogSetPinAttenuation(POT_PIN, ADC_11db);   // yaklaşık 3,1 V'a kadar / up to about 3.1 V
9}
10
11void loop() {
12  uint32_t rawSum = 0;
13  uint32_t mvSum = 0;
14  for (int i = 0; i < 16; i++) {                // 16 ölçümün ortalaması / average of 16 readings
15    rawSum += analogRead(POT_PIN);              // ham ADC değeri / raw ADC value
16    mvSum += analogReadMilliVolts(POT_PIN);     // eFuse kalibrasyonlu mV / eFuse-calibrated mV
17  }
18  float raw = rawSum / 16.0;
19  float naiveV = raw * 3.3 / 4095.0;            // basit formül / naive formula
20  float calibratedV = mvSum / 16.0 / 1000.0;    // kalibre edilmiş / calibrated
21
22  Serial.printf("Ham / Raw: %4.0f  Formul / Formula: %.3f V  Kalibre / Calibrated: %.3f V\n",
23                raw, naiveV, calibratedV);
24  delay(500);
25}

Le code affiche deux résultats côte à côte : la valeur brute convertie avec la formule simple et la valeur étalonnée par analogReadMilliVolts(). En tournant le potentiomètre vers les extrémités, tu verras l'écart grandir, et tout en bas, là où la formule affiche 0,000 V, le multimètre mesure encore environ 0,1 V. analogSetPinAttenuation() change l'atténuation d'une seule broche, tandis qu'analogSetAttenuation() la change pour toutes. L'ESP32 est nettement plus bruité que l'Uno, surtout quand le Wi-Fi émet ; Espressif conseille lui-même d'ajouter un condensateur de 100 nF sur l'entrée et de moyenner plusieurs échantillons, ce que fait la moyenne de 16 mesures du code. Les puces plus récentes comme l'ESP32-S3 et l'ESP32-C3 utilisent un étalonnage plus évolué par ajustement de courbe, mais les numéros de broches et les règles de l'ADC2 varient selon le modèle : consulte toujours le brochage de ta carte (outil Pinout). Nous expliquons comment monter un pont diviseur pour mesurer des tensions supérieures à 3,3 V dans le guide du pont diviseur de tension.

ADC du Raspberry Pi Pico (MicroPython)

Le Raspberry Pi Pico possède trois entrées analogiques accessibles de l'extérieur : GP26 (ADC0), GP27 (ADC1) et GP28 (ADC2). GP29 (ADC3) mesure sur la carte un tiers de la tension d'alimentation VSYS, et l'ADC4 est relié au capteur de température interne de la puce. La fonction read_u16() de MicroPython met le résultat 12 bits à l'échelle 0–65535 pour que le même code fonctionne sur différentes cartes, mais la résolution réelle reste de 4096 paliers. Le RP2040 n'a pas de tension de référence séparée : il utilise sa propre alimentation d'ADC comme référence. Sur le Pico, cette alimentation (ADC_VREF, broche 35) provient de la sortie du régulateur à découpage 3,3 V (SMPS), filtrée par une résistance d'environ 200 Ω. La fiche technique de la carte Raspberry Pi en cite clairement trois conséquences : la précision du 3,3 V est limitée, l'alimentation est un peu bruitée, et le courant consommé par l'ADC crée un décalage d'environ 30 mV. Les remèdes figurent dans le même document : mettre GP23 à HIGH pour faire passer le régulateur en mode PWM, avec moins d'ondulation ; relier un canal d'ADC inutilisé à AGND et soustraire sa mesure comme décalage ; et, pour une bien meilleure précision, brancher une référence de 3,0 V comme le LM4040 entre ADC_VREF et AGND (la plage de mesure devient alors 0–3,0 V). On sait aussi que l'ADC du RP2040 présente de petits sauts (erreurs DNL) aux valeurs 512, 1536, 2560 et 3584 ; moyenner plusieurs mesures réduit leur effet. Sur le Pico W, GP23 est réservée à la puce sans fil et le mode du régulateur se commande via WL_GPIO1 ; sur un Pico W, supprime donc les lignes GP23 du code ci-dessous.

1from machine import ADC, Pin
2import time
3
4pot = ADC(26)                 # GP26 = ADC0 (pin 31)
5chip_temp = ADC(4)            # dahili sıcaklık sensörü / internal temperature sensor
6VREF = 3.3                    # ADC_VREF; multimetreyle ölçüp düzelt / measure and correct with a multimeter
7
8# Yalnız Pico ve Pico 2 (W değil): SMPS PWM moduna, daha az gürültü / Plain Pico and Pico 2 only (not W): SMPS to PWM mode, less noise
9smps_mode = Pin(23, Pin.OUT)
10smps_mode.value(1)
11
12
13def read_average(adc, samples=16):
14    total = 0
15    for _ in range(samples):
16        total += adc.read_u16()           # 0-65535 (12 bit ölçeklenmiş / 12-bit scaled)
17    return total / samples
18
19
20while True:
21    raw = read_average(pot)
22    volts = raw * VREF / 65535            # sayıyı volta çevir / convert the number to volts
23    t_volts = read_average(chip_temp) * VREF / 65535
24    temp_c = 27 - (t_volts - 0.706) / 0.001721    # RP2040 veri sayfası formülü / RP2040 datasheet formula
25    print("ADC: {:5d}  {:.3f} V  Yonga / Chip: {:.1f} C".format(int(raw), volts, temp_c))
26    time.sleep(0.5)

Méthodes pour réduire le bruit de l'ADC

Même en mesurant une tension stable, il est normal que la valeur de l'ADC bouge d'un ou deux paliers ; la quantification, l'ondulation de l'alimentation, les parasites captés par les longs fils et les moteurs ou émissions Wi-Fi à proximité y contribuent. Sur l'Uno, une variation de ±1–2 paliers est considérée comme saine ; beaucoup plus signale généralement un problème dans le circuit. Tu peux combattre le bruit à la fois côté matériel et côté logiciel :

• Ajoute un condensateur : un condensateur céramique de 100 nF entre la broche analogique et GND filtre les parasites rapides et fournit une charge prête au condensateur d'échantillonnage avec les sources très résistives.
• Garde des fils courts : si le câble du capteur est long, torsade ensemble les fils de signal et de GND ; fais passer les fils des moteurs et des relais loin des lignes analogiques.
• Soigne la masse : le courant de retour des charges gourmandes comme les moteurs, relais et rubans LED ne doit pas passer par le fil GND du capteur ; rassemble les masses en un seul point (masse en étoile).
• Utilise une référence propre : l'alimentation USB est bruitée ; pour les mesures de tension absolue, la référence interne ou un circuit de référence externe donnent des résultats plus stables.
• Jette la première mesure après un changement de canal : le multiplexeur à l'entrée de l'ADC peut garder la charge du canal précédent ; quand tu lis plusieurs broches à la suite, sacrifie une mesure sur chaque broche.
• Fais la moyenne : la moyenne de N mesures réduit le bruit aléatoire d'un facteur d'environ √N ; 16 mesures le divisent par quatre.
• Suréchantillonnage (oversampling) : si tu additionnes 4^n mesures et décales le résultat de n bits vers la droite, tu gagnes n bits de résolution ; décaler de 2 bits la somme de 16 mesures fait passer les 10 bits de l'Uno à 12. Pour que cela marche, le signal doit comporter au moins un palier de bruit naturel.
• Filtres médian et exponentiel : le filtre médian supprime les pics soudains dus aux moteurs, et la moyenne mobile exponentielle (EMA) donne une courbe lisse avec très peu de mémoire.

1// Ham, ortalama ve EMA filtreli ADC değerleri / Raw, averaged and EMA-filtered ADC values
2// Serial Plotter ile izle / Watch with the Serial Plotter
3const int SENSOR_PIN = A0;
4const float ALPHA = 0.1;     // EMA katsayısı (0-1) / EMA coefficient (0-1)
5float ema = 0;
6
7void setup() {
8  Serial.begin(115200);
9  analogRead(SENSOR_PIN);              // ilk okumayı at / discard the first reading
10  ema = analogRead(SENSOR_PIN);        // filtreyi başlat / seed the filter
11}
12
13void loop() {
14  int raw = analogRead(SENSOR_PIN);    // ham değer / raw value
15
16  long sum = 0;
17  for (int i = 0; i < 16; i++) {       // 16 ölçüm topla / sum 16 readings
18    sum += analogRead(SENSOR_PIN);
19  }
20  float average = sum / 16.0;          // ortalama (0-1023) / average (0-1023)
21
22  ema += ALPHA * (raw - ema);          // üstel hareketli ortalama / exponential moving average
23
24  Serial.print(F("ham:"));
25  Serial.print(raw);
26  Serial.print(F(" ortalama:"));
27  Serial.print(average);
28  Serial.print(F(" ema:"));
29  Serial.println(ema);
30  delay(20);
31}

Quand tu téléverses le code et ouvres le traceur série de l'IDE Arduino, tu vois trois courbes : la valeur brute tremble, la moyenne de 16 mesures est nettement plus calme et l'EMA est la courbe la plus lisse, mais elle réagit aux changements avec un peu de retard. Le coefficient ALPHA se choisit entre 0 et 1 : 0,1 signifie que chaque nouvelle mesure compte pour 10 % dans le résultat, si bien qu'à peu près les 10 dernières mesures ont un effet ; en l'augmentant, la réponse devient plus rapide mais le bruit augmente. Le bon filtre dépend du signal : une EMA forte convient à une température qui varie lentement, une moyenne courte à un joystick qui doit réagir vite. Nous comparons moyenne mobile, filtre médian et hystérésis sur des exemples réels de capteurs dans le guide sur le filtrage des données de capteurs.

Courte introduction au DAC : du numérique à l'analogique

Un DAC (convertisseur numérique-analogique, ou CNA) fait l'inverse d'un ADC : il reçoit un nombre et produit une tension proportionnelle. Si tu écris 0 dans un DAC 8 bits, tu obtiens 0 V, avec 255 une valeur proche de la tension d'alimentation et avec 128 environ la moitié. Les DAC les plus simples sont faits d'une échelle de résistances appelée R-2R. Dissipons au passage une confusion fréquente : analogWrite() sur l'Arduino Uno n'est pas un DAC, il génère du PWM ; la broche commute en réalité très vite entre 0 V et 5 V. Pour la luminosité d'une LED ou la vitesse d'un moteur, cela suffit, mais si tu as vraiment besoin d'une tension stable, il faut ajouter un filtre passe-bas RC sur la sortie PWM ; tu peux calculer la constante de temps du filtre avec l'outil de constante de temps RC. Côté cartes dotées d'un vrai DAC : l'ESP32 possède deux DAC 8 bits sur GPIO 25 et GPIO 26, utilisables avec dacWrite(broche, valeur), alors que l'ESP32-S3 et l'ESP32-C3 n'en ont pas. L'Arduino Uno R4 dispose d'un DAC 12 bits sur la broche A0. Pour l'Uno R3, le Nano et le Pico, le plus simple est le module MCP4725 12 bits relié en I2C. Avec un DAC, tu peux produire du son, générer des ondes sinusoïdales ou triangulaires, et même relier la sortie du DAC à une entrée de l'ADC pour tester l'ADC avec des tensions connues :

1// ESP32 DAC ile sinüs dalgası / Sine wave with the ESP32 DAC
2// Çıkış GPIO 25'te, osiloskopla izle / Output on GPIO 25, watch it with an oscilloscope
3const int DAC_PIN = 25;      // DAC1 = GPIO 25 (DAC2 = GPIO 26)
4const int STEPS = 64;        // bir periyottaki nokta sayısı / points per period
5uint8_t sineTable[STEPS];
6
7void setup() {
8  for (int i = 0; i < STEPS; i++) {
9    sineTable[i] = 128 + 127 * sin(2 * PI * i / STEPS);  // 1-255 arası tablo / table between 1-255
10  }
11}
12
13void loop() {
14  for (int i = 0; i < STEPS; i++) {
15    dacWrite(DAC_PIN, sineTable[i]);   // 0 → 0 V, 255 → yaklaşık 3,3 V / 0 → 0 V, 255 → about 3.3 V
16    delayMicroseconds(150);            // yaklaşık 100 Hz / roughly 100 Hz
17  }
18}

Idées de projets avec l'ADC

• Voltmètre numérique : mesure de 0 à 25 V avec un pont diviseur et affiche le résultat sur un écran LCD ; les étapes sont dans le guide fabriquer un voltmètre avec Arduino.
• Veilleuse automatique : lis la tension d'une LDR et allume les LED quand il fait sombre.
• Pot de fleurs intelligent : utilise la sortie analogique d'un capteur d'humidité du sol pour lancer une pompe quand la terre est sèche.
• Robot piloté au joystick : les deux axes d'un joystick sont deux entrées analogiques distinctes ; convertis leurs valeurs en vitesse et en direction des moteurs.
• Ampèremètre : lis la tension proportionnelle au courant d'un ACS712 pour savoir combien un appareil consomme.
• Indicateur de niveau sonore : échantillonne rapidement la sortie analogique d'un capteur de son KY-038 et allume une barre de LED selon la valeur crête.
• Jauge de batterie : mesure la tension dans un projet sur pile et affiche la charge restante en pourcentage sur un écran.

Erreurs fréquentes et solutions

L'ADC est le pont entre le monde physique et ton code : quand tu connais sa résolution, sa tension de référence et sa fréquence d'échantillonnage, tu sais aussi ce que représente chaque nombre affiché et à quel point tu peux t'y fier. Sur l'Uno, mesure correctement la référence ; sur l'ESP32, utilise les broches de l'ADC1 et analogReadMilliVolts() ; sur le Pico, tiens compte du décalage et du bruit ; puis lisse le résultat avec des moyennes et des filtres. Dans l'application BlueGrays, tu trouveras des projets basés sur la mesure analogique, comme la lecture de l'intensité lumineuse avec une LDR, un voltmètre numérique avec écran LCD, la mesure de température avec une CTN et le contrôle d'un servo et de la luminosité d'une LED avec un potentiomètre, avec schémas et code pas à pas.