Pont diviseur de tension : formule, calcul et exemples Arduino

Un pont diviseur de tension est le circuit le plus simple pour transformer une tension en une tension plus faible et facile à calculer, à l'aide de deux résistances en série. La tension de sortie se calcule avec Vs = Ve × R2 / (R1 + R2) : R1 est reliée à la source, R2 à la masse (GND), et la sortie se prend au point milieu, là où elles se rejoignent. Par exemple, deux résistances de 10 kΩ divisent 12 V exactement par deux, soit 6 V. Ces deux résistances sont au cœur d'innombrables montages : mesurer une batterie de 12 V avec un Arduino, adapter un signal de 5 V aux broches 3,3 V d'un ESP32 ou encore lire des capteurs comme une LDR ou une thermistance CTN (NTC).

Dans ce guide, tu verras avec des chiffres concrets d'où vient la formule, comment choisir les valeurs des résistances et pourquoi la sortie chute quand tu branches quelque chose sur le pont (l'effet de charge). Ensuite, nous écrirons pas à pas le code qui mesure la tension d'une batterie avec un Arduino Uno, un ESP32 et un Raspberry Pi Pico, nous choisirons les bons couples de résistances pour passer de 5 V à 3,3 V et nous lirons une LDR et une CTN avec un pont diviseur. Enfin, nous verrons pourquoi un pont diviseur ne doit jamais remplacer une alimentation.

Qu'est-ce qu'un pont diviseur de tension et comment fonctionne-t-il ?

La formule du pont diviseur découle directement de la loi d'Ohm. Le même courant traverse R1 et R2, montées en série entre la source et la masse : I = Ve / (R1 + R2). La tension aux bornes de R2, c'est-à-dire la sortie, est ce courant multiplié par R2 : Vs = I × R2 = Ve × R2 / (R1 + R2). En bref, la tension de la source se répartit entre les résistances proportionnellement à leurs valeurs ; la plus grande résistance reçoit la plus grande part. La sortie est toujours plus faible que l'entrée, car le rapport R2 / (R1 + R2) est inférieur à 1. Tu trouveras plus de détails sur la répartition des tensions dans un circuit série dans Calcul des résistances en série et en parallèle.

Tu peux aussi raisonner à l'envers : si tu veux ramener 12 V à 3,3 V et que tu as choisi 10 kΩ pour R2, tu obtiens R1 = 10 × (12 / 3,3 − 1) ≈ 26,4 kΩ. Cette valeur n'existe pas dans le commerce, tu prends donc la valeur normalisée immédiatement supérieure, 27 kΩ, et la sortie vaut 12 × 10 / 37 ≈ 3,24 V. Arrondir R1 vers le haut baisse légèrement la sortie, ce qui va dans le sens de la sécurité pour la broche. Un potentiomètre est d'ailleurs un pont diviseur réglable : son curseur partage la piste résistive en R1 et R2. Si tu ne veux pas calculer à la main, le calculateur de pont diviseur te donne la sortie instantanément à partir de la tension d'entrée et des résistances. En électronique, on retrouve surtout le pont diviseur dans ces usages :

• Mesurer des tensions élevées : ramener des sources comme une batterie de 12 V ou un pack lithium de 7,4 V dans la plage que peut mesurer une entrée analogique.
• Abaisser un niveau logique : rendre un signal de 5 V supportable par les entrées 3,3 V d'un ESP32 ou d'un Raspberry Pi Pico.
• Lire des capteurs résistifs : convertir en tension la variation de résistance d'une LDR, d'une CTN, d'un capteur de flexion ou d'un capteur de force (FSR).
• Lire plusieurs boutons sur une broche : une échelle de résistances donne à chaque bouton une tension différente, si bien que cinq boutons peuvent se partager une seule entrée analogique.
• Contre-réaction des régulateurs : des régulateurs comme le LM317 ou le LM2596 réglable stabilisent leur sortie en la mesurant à travers un pont ; pour le LM317, Vs = 1,25 × (1 + R2 / R1).
• Créer une tension de référence : fournir la moitié de la tension d'alimentation comme référence dans les montages à amplificateur opérationnel.

Comment choisir les valeurs des résistances ?

La formule ne s'intéresse qu'au rapport : 1 kΩ + 1 kΩ et 100 kΩ + 100 kΩ divisent de la même façon, exactement par deux. En pratique, les valeurs absolues comptent pourtant aussi. Des résistances faibles laissent passer beaucoup de courant dans le pont ; ce courant est de l'énergie gaspillée qui vide inutilement la batterie dans un projet autonome. Des résistances élevées consomment très peu, mais leur sortie est « faible » : une charge branchée ou le condensateur d'échantillonnage de l'entrée analogique perturbent facilement la tension de sortie, et le bruit capté par les fils passe plus facilement. Le bon choix est un compromis entre ces deux extrêmes :

1. Détermine la tension d'entrée maximale. Une batterie au plomb de 12 V peut atteindre 14,4 V en charge ; prends le pire cas de la tension à mesurer et ajoute 10 % de marge.
2. Détermine la tension maximale admise par la broche. 5 V sur l'Arduino Uno, 3,3 V sur l'ESP32 et le Pico ; comme cible sûre, vise environ 4,5 V sur l'Uno, 2,5 V sur l'ESP32 et 3,0 V sur le Pico.
3. Calcule le rapport : k = sortie visée / entrée maximale. Par exemple 4,5 / 14,4 ≈ 0,31.
4. Choisis R2 (10 kΩ est un bon point de départ dans la plupart des cas) et calcule R1 = R2 × (1 / k − 1). Arrondis le résultat à la valeur supérieure parmi les valeurs normalisées de résistances.
5. Vérifie le courant et la puissance : I = Ve / (R1 + R2) et P = Ve² / (R1 + R2). Dans un projet sur batterie, essaie de rester dans le domaine du microampère.
6. Vérifie la résistance de sortie : R1 × R2 / (R1 + R2) doit rester sous 10 kΩ pour l'Arduino Uno ; sinon, ajoute un condensateur de 100 nF entre l'entrée analogique et GND.
7. Mets le rapport réel dans ton code : recalcule le rapport avec les valeurs normalisées choisies, puis mesure au multimètre une fois le montage réalisé et étalonne.

Effet de charge : que se passe-t-il quand on branche quelque chose sur le pont ?

La formule suppose qu'aucun courant n'est prélevé en sortie. Dès que tu branches une charge, elle se retrouve en parallèle avec R2, la résistance équivalente de la branche basse diminue et la tension de sortie chute. Le plus simple pour le calculer est de voir le pont comme son générateur équivalent de Thévenin : une source dont la tension est celle mesurée à vide (Vth) et dont la résistance interne vaut Rth = R1 × R2 / (R1 + R2). Avec une charge RL, la sortie devient Vth × RL / (Rth + RL). Le tableau ci-dessous montre une source de 10 V divisée par 10 kΩ + 10 kΩ (Vth = 5 V, Rth = 5 kΩ) avec différentes charges en sortie :

La règle pratique : si la résistance de la charge vaut au moins 100 fois la résistance de sortie du pont (Rth), l'erreur reste inférieure à 1 %. Si la charge est plus faible, diminue les résistances ou intercale un ampli-op monté en suiveur (tampon). L'entrée analogique d'un microcontrôleur a elle-même une résistance très élevée, mais elle contient un petit condensateur d'échantillonnage qui se charge à chaque conversion (environ 14 pF sur l'ATmega328P). C'est pourquoi la fiche technique recommande une résistance de source d'environ 10 kΩ ou moins. Si ton pont utilise des valeurs plus élevées, ajoute un condensateur de 100 nF entre l'entrée analogique et GND : il garde en réserve la charge nécessaire au moment de l'échantillonnage. Et si tu lis plusieurs entrées analogiques à la suite, ignorer la première lecture de chaque broche supprime l'erreur laissée par le changement de canal.

Pourquoi un pont diviseur ne remplace pas une alimentation

Le piège le plus courant chez les débutants consiste à tirer 5 V d'un adaptateur 12 V avec deux résistances pour alimenter un Arduino ou un module. Sur le papier, un pont de 7 kΩ et 5 kΩ donne exactement 5 V à partir de 12 V, mais seulement tant qu'aucun courant n'est prélevé en sortie. Une carte qui consomme 50 mA se comporte comme une charge d'environ 100 Ω ; en parallèle avec les 5 kΩ de R2, la branche basse tombe à 98 Ω et la sortie s'effondre à 0,17 V. Si tu réduis les résistances à 70 Ω et 50 Ω, le montage consomme 100 mA et dissipe 1,2 W de chaleur même sans rien de branché ; avec la charge, la sortie descend quand même à 3,9 V, et chaque variation de consommation de la carte (Wi-Fi, servo, relais) fait bouger la tension. De plus, quand on retire la charge, la tension remonte et peut endommager les composants sensibles.

Mesurer une batterie de 12 V et des piles avec Arduino

Les entrées analogiques de l'Arduino Uno lisent au maximum 5 V ; brancher directement une batterie de 12 V détruirait la broche. La solution est un pont de 22 kΩ (R1) et 10 kΩ (R2) : avec un rapport de 0,3125, les 14,4 V de charge arrivent sur la broche sous forme de 4,5 V, et le montage peut mesurer jusqu'à 16 V. Sous 12 V, le pont ne consomme que 0,375 mA et sa résistance de sortie de 6,9 kΩ reste sous la limite recommandée de 10 kΩ. L'ADC 10 bits distingue environ 4,9 mV par pas ; avec le pont, cela correspond à une résolution d'environ 15,6 mV en entrée. Comme l'ESP32 et le Pico fonctionnent en 3,3 V, on utilise sur ces cartes une R1 plus grande (56 kΩ) :

1// 12 V akü gerilimini gerilim bölücüyle ölçme / Measuring a 12 V battery with a voltage divider
2// Kaynak + -> 22k (R1) -> A0 -> 10k (R2) -> GND / Source + -> 22k (R1) -> A0 -> 10k (R2) -> GND
3// Kaynağın eksisi Arduino GND'sine bağlı / Source minus is tied to the Arduino GND
4const int VIN_PIN = A0;
5const float VREF = 5.0;      // 5V pininde ölçtüğün gerilim / voltage you measured on the 5V pin
6const float R1 = 22000.0;    // üst direnç (ohm) / top resistor (ohms)
7const float R2 = 10000.0;    // alt direnç (ohm) / bottom resistor (ohms)
8const float CAL = 1.000;     // kalibrasyon: gerçek / okunan / calibration: real / measured
9const float LOW_V = 11.8;    // düşük akü eşiği (V) / low battery threshold (V)
10
11float readInputVoltage() {
12  analogRead(VIN_PIN);                        // ilk okumayı at / discard the first reading
13  long sum = 0;
14  for (int i = 0; i < 16; i++) {              // 16 ölçümün ortalaması / average of 16 readings
15    sum += analogRead(VIN_PIN);
16    delay(2);
17  }
18  float vPin = (sum / 16.0) * VREF / 1024.0;  // pindeki gerilim / voltage at the pin
19  return vPin * (R1 + R2) / R2 * CAL;         // bölücüden önceki gerilim / voltage before the divider
20}
21
22void setup() {
23  Serial.begin(9600);
24  pinMode(LED_BUILTIN, OUTPUT);
25}
26
27void loop() {
28  float v = readInputVoltage();
29  Serial.print(F("Giris / Input: "));
30  Serial.print(v, 2);
31  Serial.println(F(" V"));
32  digitalWrite(LED_BUILTIN, v < LOW_V ? HIGH : LOW);  // akü zayıfsa LED yanar / LED on when the battery is low
33  delay(1000);
34}

Le code ignore la première lecture pour laisser le condensateur d'échantillonnage de l'ADC se stabiliser, puis fait la moyenne de 16 mesures pour réduire le bruit. La valeur lue est d'abord convertie en tension sur la broche (on divise par 1024, car la fiche technique de l'ATmega328P donne ADC = Ve × 1024 / Vref), puis multipliée par (R1 + R2) / R2 = 3,2 pour retrouver la tension avant le pont. La principale source d'erreur est Vref : la broche 5V d'un Uno alimenté en USB se situe souvent entre 4,7 et 5,1 V. Mesure donc la broche 5V au multimètre et reporte la valeur dans VREF ; mesure ensuite la tension réelle de la batterie au multimètre, compare-la à la valeur affichée dans le moniteur série et entre CAL = réelle / mesurée dans le code. Cette seule étape corrige à la fois l'erreur de Vref et celle des tolérances. Si tu branches le pont après l'interrupteur marche/arrêt de l'appareil, il ne consomme rien quand l'appareil est éteint ; 0,375 mA représentent environ 9 mAh par jour, rien pour une batterie de voiture, mais sensible sur une petite batterie. Voici des couples de résistances adaptés à d'autres sources :

Mesurer une tension avec l'ESP32

Sur l'ESP32, l'ADC est sur 12 bits (0–4095), mais il présente deux différences importantes. D'abord, les broches de l'ADC2 ne sont pas lisibles quand le Wi-Fi est actif : branche donc toujours le pont sur une broche de l'ADC1, GPIO 32 à 39 (les GPIO 34 à 39 sont des entrées seules, idéales pour cet usage). Ensuite, l'ADC n'est pas linéaire aux extrémités : avec l'atténuation par défaut de 11 dB, Espressif recommande environ 150–2450 mV comme plage la plus précise. La broche affiche des valeurs jusqu'à environ 3,1 V, mais l'erreur augmente dans cette zone. C'est pourquoi nous avons choisi un pont de 56 kΩ + 10 kΩ : 14,4 V arrivent sur la broche sous forme de 2,18 V et restent dans la plage précise. Au lieu de l'analogRead() brut, nous utilisons analogReadMilliVolts(), qui renvoie directement des millivolts grâce aux données d'étalonnage écrites dans la puce en usine :

1// ESP32: 56k + 10k bölücüyle 12 V ölçme / ESP32: measuring 12 V with a 56k + 10k divider
2const int VIN_PIN = 34;        // ADC1_CH6, Wi-Fi açıkken de çalışır / ADC1_CH6, works with Wi-Fi on
3const float R1 = 56000.0;      // üst direnç (ohm) / top resistor (ohms)
4const float R2 = 10000.0;      // alt direnç (ohm) / bottom resistor (ohms)
5const float CAL = 1.000;       // multimetreyle ayarla / tune with a multimeter
6
7void setup() {
8  Serial.begin(115200);
9  analogReadResolution(12);    // 0-4095 (varsayılan / default)
10}
11
12void loop() {
13  uint32_t mv = 0;
14  for (int i = 0; i < 32; i++) {
15    mv += analogReadMilliVolts(VIN_PIN);     // kalibre edilmiş milivolt / calibrated millivolts
16  }
17  float vPin = mv / 32.0 / 1000.0;           // pindeki gerilim (V) / voltage at the pin (V)
18  float vIn = vPin * (R1 + R2) / R2 * CAL;   // bölücüden önceki gerilim / voltage before the divider
19  Serial.printf("Pin: %.3f V  Giris / Input: %.2f V\n", vPin, vIn);
20  delay(1000);
21}

Mesurer une tension avec le Raspberry Pi Pico (MicroPython)

Sur le Raspberry Pi Pico, les entrées analogiques sont GP26, GP27 et GP28 (ADC0 à ADC2). La fonction read_u16() de MicroPython met la mesure 12 bits à l'échelle 0–65535, et la référence est ADC_VREF, issue du 3,3 V de la carte. Comme l'ADC du Pico mesure jusqu'à 3,3 V, un pont de 56 kΩ + 10 kΩ te permet de monter jusqu'à environ 21 V. Détail amusant : le Pico utilise lui-même un pont diviseur. Un pont sur la carte divise par trois la tension d'alimentation VSYS et l'envoie sur GP29 (ADC3) ; en multipliant par 3 la tension lue avec ADC(29), tu obtiens la tension d'alimentation de la carte (sur le Pico W, GP29 est partagée avec la puce sans fil, donc cela ne fonctionne pas directement).

1from machine import ADC
2import time
3
4adc = ADC(26)            # GP26 = ADC0 (pin 31)
5VREF = 3.3               # ADC_VREF; multimetreyle ölçüp düzelt / measure and correct with a multimeter
6R1 = 56000               # üst direnç (ohm) / top resistor (ohms)
7R2 = 10000               # alt direnç (ohm) / bottom resistor (ohms)
8CAL = 1.000              # kalibrasyon katsayısı / calibration factor
9
10
11def read_input_voltage(samples=32):
12    total = 0
13    for _ in range(samples):
14        total += adc.read_u16()                  # 0-65535
15    v_pin = total / samples * VREF / 65535       # pindeki gerilim / voltage at the pin
16    return v_pin * (R1 + R2) / R2 * CAL          # bölücüden önceki gerilim / voltage before the divider
17
18
19while True:
20    v_in = read_input_voltage()
21    print("Giris / Input: {:.2f} V".format(v_in))
22    time.sleep(1)

Abaisser un signal de 5 V à 3,3 V (pour ESP32 et Pico)

Les broches de l'ESP32 et du Pico ne tolèrent pas le 5 V. Si la sortie ECHO d'un HC-SR04, la broche TX d'un Arduino Uno ou la sortie numérique d'un module alimenté en 5 V est reliée directement à ces cartes, les diodes de protection de l'entrée sont surchargées et la broche peut lâcher avec le temps. Pour un signal à sens unique, la solution la moins chère est un pont diviseur. L'objectif est une tension qui ne dépasse jamais 3,3 V tout en restant assez élevée pour être lue comme HIGH : l'ESP32 considère 75 % de son alimentation (environ 2,5 V) comme niveau haut minimal, et le RP2040 du Pico 2,0 V. Une sortie entre 3,0 et 3,3 V laisse donc une marge confortable sur les deux cartes. C'est aussi la méthode recommandée dans le guide du capteur de distance HC-SR04 pour relier la broche ECHO à une carte 3,3 V.

Avec la capacité de la broche, le pont forme un petit filtre RC. Les 6,7 kΩ de résistance de sortie d'un pont de 10 kΩ + 20 kΩ, associés à environ 15 pF de broche et de breadboard, donnent une constante de temps d'environ 100 ns ; un UART à 115200 bauds (8,7 µs par bit) ne s'en aperçoit pas, mais les fronts de signaux SPI à quelques MHz s'arrondissent. Sur les lignes rapides, préfère 1 kΩ + 2 kΩ. N'oublie pas non plus qu'un pont ne fonctionne que dans un sens, de la tension la plus haute vers la plus basse. Dans l'autre sens, il n'y a généralement rien à faire : l'Arduino Uno considère tout ce qui dépasse 3,0 V comme HIGH et peut donc lire la sortie 3,3 V de l'ESP32, avec une faible marge. Sur des lignes bidirectionnelles comme l'I2C, en revanche, un pont ne sert à rien ; on utilise alors un convertisseur de niveau logique à MOSFET.

Lire une LDR et une CTN avec un pont diviseur

Un microcontrôleur ne sait pas mesurer une résistance, seulement une tension. Quand tu mets un capteur résistif comme une LDR ou une CTN en série avec une résistance fixe pour former un pont diviseur, la variation de résistance devient une variation de tension au point milieu. La valeur de la résistance fixe détermine la sensibilité. Pour obtenir la plus grande excursion de tension, la résistance fixe doit être la moyenne géométrique des résistances minimale et maximale du capteur sur la plage qui t'intéresse : R = √(Rmin × Rmax). Pour une LDR de 1 kΩ en pleine lumière et 100 kΩ en lumière faible, on obtient √(1 k × 100 k) = 10 kΩ. Sous 5 V, avec 10 kΩ la sortie varie sur 4,09 V, alors qu'avec 1 kΩ ou 100 kΩ la variation tombe à 2,45 V. Voilà pourquoi les kits de démarrage fournissent des résistances de 10 kΩ. Autre avantage : comme le pont et l'ADC sont alimentés par le même 5 V, la résistance calculée ne dépend pas de la tension d'alimentation (mesure ratiométrique) ; le code ci-dessous n'a donc même pas besoin de Vref.

1// LDR ve NTC'yi gerilim bölücüyle okuma / Reading an LDR and an NTC with voltage dividers
2// A0: 5V -> LDR -> A0 -> 10k -> GND
3// A1: 5V -> 10k -> A1 -> NTC 10k (B = 3950) -> GND
4const float R_FIXED = 10000.0;  // sabit dirençler (ohm) / fixed resistors (ohms)
5const float R0 = 10000.0;       // NTC'nin 25 °C direnci / NTC resistance at 25 °C
6const float BETA = 3950.0;      // NTC B katsayısı / NTC beta coefficient
7const float T0 = 298.15;        // 25 °C kelvin cinsinden / 25 °C in kelvin
8
9void setup() {
10  Serial.begin(9600);
11}
12
13void loop() {
14  analogRead(A0);                         // kanal değişti, ilk okumayı at / channel changed, discard first reading
15  int ldrRaw = analogRead(A0);
16  analogRead(A1);
17  int ntcRaw = analogRead(A1);
18  if (ldrRaw < 1) ldrRaw = 1;             // sıfıra bölmeyi önle / avoid division by zero
19
20  // Oransal ölçüm: besleme gerilimi hesaptan düşer / ratiometric: the supply voltage cancels out
21  float rLdr = R_FIXED * (1024.0 / ldrRaw - 1.0);
22  float rNtc = R_FIXED * ntcRaw / (1024.0 - ntcRaw);
23  float tempC = 1.0 / (1.0 / T0 + log(rNtc / R0) / BETA) - 273.15;  // Beta denklemi / Beta equation
24
25  Serial.print(F("LDR: "));
26  Serial.print(rLdr / 1000.0, 1);
27  Serial.print(F(" kOhm   NTC: "));
28  Serial.print(rNtc / 1000.0, 2);
29  Serial.print(F(" kOhm   "));
30  Serial.print(tempC, 1);
31  Serial.println(F(" C"));
32  delay(1000);
33}

Dans le code, la LDR est en haut : la valeur lue augmente donc avec la lumière ; sa résistance vaut R = 10 kΩ × (1024 / ADC − 1). La CTN est en bas : quand la température monte, sa résistance diminue, et la tension lue aussi. Pour les CTN courantes de 10 kΩ à 25 °C avec un coefficient B de 3950, la température se calcule avec l'équation Bêta : 1 / T = 1 / T0 + ln(R / R0) / B (températures en kelvins). Comme la résistance fixe vaut la résistance de la CTN à 25 °C, la sortie à température ambiante vaut exactement la moitié de l'alimentation, là où la sensibilité est maximale. Pour plus de précision sur une large plage de températures, nous abordons l'équation de Steinhart-Hart et l'auto-échauffement de la CTN dans le guide de la thermistance CTN.

Idées de projets avec un pont diviseur

• Surveillance de batterie avec alarme : surveille la batterie d'un camping-car ou d'une installation solaire et déclenche un buzzer quand elle passe sous 11,8 V ; pour les solutions d'alimentation sur batterie, consulte Alimenter un Arduino sur batterie.
• Voltmètre numérique : affiche la tension mesurée sur un écran LCD ou OLED ; les étapes sont dans Fabriquer un voltmètre avec Arduino.
• Veilleuse automatique : avec un pont à LDR, allume des LED ou un relais quand la nuit tombe.
• Suiveur solaire : compare les tensions de deux ponts à LDR pour orienter un panneau vers la lumière (suiveur solaire).
• Cinq boutons sur une broche : monte une échelle de résistances différentes et déduis de la valeur analogique quel bouton est pressé (brancher un bouton).
• Thermostat : mesure la température avec un pont à CTN et commande un ventilateur ou un chauffage par relais à la température choisie.

Erreurs fréquentes et solutions

Un pont diviseur, ce n'est que deux résistances et une formule, et pourtant on le retrouve dans presque tous les projets qui mesurent quelque chose. Choisis le rapport avec la formule et les valeurs absolues en équilibrant courant et résistance de sortie, tiens compte de l'effet de charge et étalonne le résultat au multimètre : tu obtiendras des mesures fiables. Les bases de la lecture analogique sont expliquées dans Qu'est-ce qu'un ADC ?. Dans l'application BlueGrays, tu trouveras des projets comme la lecture de l'intensité lumineuse avec une LDR, une veilleuse à LDR, un voltmètre numérique avec écran LCD, la mesure de température avec une CTN et un télémètre ESP32 avec HC-SR04, expliqués pas à pas avec schémas et code.