Réglage du LM2596 : convertisseur abaisseur en 5 V et 3,3 V

Régler un LM2596, c'est alimenter l'entrée du module puis tourner la vis en laiton du potentiomètre bleu tout en mesurant la sortie au multimètre, jusqu'à lire la tension voulue, par exemple 5 V ou 3,3 V. Le module abaisseur (step-down ou buck) LM2596 est un convertisseur bon marché et très répandu qui produit efficacement une tension plus basse à partir d'un bloc secteur 12 V, d'une batterie de voiture ou d'un pack Li-ion 2S pour alimenter Arduino, ESP32, servos et rubans LED. Il accepte 4,5 à 40 V en entrée, descend à n'importe quelle valeur entre environ 1,25 V et 35 V et peut fournir jusqu'à 3 A. La règle d'or tient en une phrase : règle et mesure toujours la sortie avant de brancher une charge.

Dans ce guide, tu vas découvrir comment fonctionne un convertisseur buck, quelles sont les broches et les composants du module, comment régler pas à pas 5 V et 3,3 V avec le potentiomètre et le multimètre, et la formule Vout = 1,23 × (1 + R2 / R1) qui fixe la sortie. Nous verrons ensuite comment alimenter un Arduino et des servos en 12 V, la limite de courant et l'échauffement, le rendement et la différence avec un 7805, ainsi que les erreurs fréquentes (inversion de polarité, chute de tension en charge), avant de passer au code qui mesure la sortie avec Arduino, ESP32 et Raspberry Pi Pico.

Qu'est-ce que le LM2596 et comment fonctionne-t-il ?

Le LM2596 est un circuit intégré régulateur abaisseur à découpage, conçu à l'origine par National Semiconductor et fabriqué aujourd'hui par Texas Instruments. Les régulateurs linéaires comme le 7805 se débarrassent de la tension en trop en la transformant en chaleur ; le LM2596, lui, ouvre et ferme son transistor de puissance interne environ 150 000 fois par seconde (150 kHz). Quand le transistor conduit, le courant traverse la bobine vers la charge et la bobine stocke de l'énergie dans son champ magnétique ; quand il se bloque, la bobine continue de fournir cette énergie à la charge à travers une diode Schottky. Le condensateur de sortie lisse ces impulsions. La part du temps pendant laquelle le transistor reste fermé s'appelle le rapport cyclique (duty cycle), soit environ D ≈ Vout / Vin : pour tirer 5 V de 12 V, l'interrupteur est fermé environ 42 % du temps.

Comme aucune énergie n'est brûlée, le rendement tourne autour de 80–90 % et le courant pris à l'entrée est plus faible que celui fourni en sortie : un module qui délivre 2 A sous 5 V à partir de 12 V ne consomme qu'environ 1 A en entrée. C'est la broche FB (feedback, contre-réaction) qui maintient la tension de sortie stable. La puce compare la tension sur FB à sa référence interne de 1,23 V et ajuste le rapport cyclique en conséquence. Sur le module tout fait, l'une des branches du pont diviseur relié à FB est un potentiomètre multitours ; en tournant la vis, tu changes le rapport du pont et donc la tension de sortie. Il existe aussi des versions fixes du LM2596 en 3,3 V, 5 V et 12 V, mais dans le monde Arduino le plus courant est le module bleu équipé de la version réglable (ADJ).

Broches du module et composants de la carte

Le module bleu LM2596 possède quatre points de connexion : IN+ et IN− pour l'entrée, OUT+ et OUT− pour la sortie. IN− et OUT− sont reliés sur la carte ; un convertisseur buck n'isole pas l'entrée de la sortie, donc la source, le module et la carte alimentée partagent une masse (GND) commune. Sur la carte, tu trouveras la puce LM2596S à cinq broches (boîtier TO-263 : VIN, sortie, GND, FB et ON/OFF), une grosse bobine de 33–47 µH généralement marquée 330 ou 470, une diode Schottky de 3 A comme la SS34, un condensateur électrolytique en entrée et un en sortie (souvent 100–220 µF) et un potentiomètre multitours marqué 103 (10 kΩ). Tu peux décoder le marquage de la bobine avec le calculateur de code des bobines. Sur la plupart des modules, la broche ON/OFF de la puce est reliée à la masse : le module démarre dès qu'il est alimenté.

Régler le LM2596 pas à pas : 5 V ou 3,3 V au multimètre

1. Ne branche rien sur la sortie. Le module se règle à vide ; tu ne branches l'Arduino ou l'ESP32 qu'après avoir vu la bonne tension.
2. Branche sur l'entrée la vraie source que tu utiliseras dans le projet (par exemple un bloc secteur 12 V 2 A) : le positif sur IN+, le négatif sur IN−. Si la carte a une LED, elle s'allume.
3. Mets le multimètre en tension continue (calibre 20 V ou automatique) ; pose la pointe rouge sur OUT+ et la noire sur OUT−. La première valeur peut être proche de la tension d'entrée, car le réglage d'usine est inconnu.
4. Avec un petit tournevis plat, tourne la vis en laiton du potentiomètre de 2 à 3 tours dans un sens et regarde l'affichage. Si la tension baisse, tu tournes dans le bon sens ; si elle monte, tourne dans l'autre sens. Le sens peut changer d'un module à l'autre selon le câblage du potentiomètre.
5. Sur un potentiomètre multitours d'environ 25 tours, parcourir toute la plage peut demander 20 tours ou plus. La vis n'a pas de butée ; en bout de course, elle tourne dans le vide avec un léger clic et la tension ne bouge plus. Dans ce cas, repars dans l'autre sens.
6. À l'approche de la cible, avance par quarts de tour puis par pas encore plus petits. Pour 5 V, laisse entre 5,00 et 5,10 V ; pour 3,3 V, entre 3,30 et 3,35 V. Sur les cartes en 3,3 V comme l'ESP32 et la Pico, ne dépasse jamais 3,6 V.
7. Branche la charge, ou teste avec une résistance de 10 Ω / 5 W qui tire environ 500 mA sous 5 V, et refais la mesure en charge. Si la tension chute de plus de 0,1–0,2 V, vérifie la source et le câblage.
8. Une fois terminé, mets une goutte de vernis à ongles ou de colle chaude sur la vis du potentiomètre ; sur les robots qui vibrent, le réglage peut dériver avec le temps.

La formule de sortie : Vout = 1,23 × (1 + R2 / R1)

Le LM2596 règle sa sortie de façon à avoir 1,23 V sur la broche FB. Si l'on appelle R2 la résistance entre la sortie et FB, et R1 celle entre FB et la masse, la sortie vaut Vout = 1,23 × (1 + R2 / R1). Sur le module, le potentiomètre de 10 kΩ joue le rôle de R2 et R1 est une petite résistance fixe de la carte. Deux conséquences importantes en découlent : même si R2 tend vers zéro, la sortie ne peut pas descendre sous 1,23 V ; et quelle que soit la valeur de R2, la sortie ne peut pas dépasser l'entrée. Si tu montes trop le potentiomètre, la puce laisse l'interrupteur fermé en permanence et la sortie reste bloquée environ 1 à 2 V sous l'entrée. C'est la cause la plus fréquente de la plainte "mon module n'abaisse pas la tension".

Si, dans un projet soumis aux vibrations ou destiné à durer, tu préfères des résistances fixes au potentiomètre, suis la datasheet et choisis R1 entre 240 Ω et 1,5 kΩ. Avec R1 = 1 kΩ, pour 5 V on obtient R2 = 1 kΩ × (5 / 1,23 − 1) ≈ 3,07 kΩ ; avec une 3,09 kΩ à 1 %, la sortie vaut 5,03 V. Pour 3,3 V, R2 ≈ 1,68 kΩ, et une 1,69 kΩ à 1 % donne 3,31 V. Ce n'est au fond qu'un pont diviseur ; tu peux vérifier les rapports avec le calculateur de pont diviseur.

Les valeurs minimales du tableau valent pour une charge de 2–3 A : l'interrupteur du LM2596 chute typiquement de 1,16 V à 3 A, et la bobine et les fils ajoutent quelques centaines de millivolts. À faible charge (environ 1 A), l'écart descend à environ 1,5 V. Un pack Li-ion 2S de 7,4 V tombe vers 6,4 V en se déchargeant ; c'est encore suffisant pour une ligne 5 V de 1 A, mais pas pour une ligne de servos en 6 V. Pour régler un module GSM qui demande 4 V, consulte l'article sur le SIM800L.

Alimenter un Arduino depuis un bloc secteur ou une batterie 12 V

Il existe deux bonnes façons d'alimenter un Arduino avec un LM2596. La première consiste à régler le module sur 5,0 V et à relier la sortie directement à la broche 5V. Comme on contourne ainsi le régulateur de la carte, il n'y a presque aucune chaleur et c'est la solution la plus efficace ; mais plus rien ne protège la carte. Si le potentiomètre dérive ou si le module tombe en panne et laisse passer l'entrée vers la sortie, les 12 V arrivent directement sur le microcontrôleur. Si tu branches aussi le câble USB avec ce montage, l'alimentation USB de l'ordinateur et la sortie du module se retrouvent reliées ; le plus sûr est de débrancher le module pendant le téléversement.

La seconde façon consiste à régler le module sur 7,5–9 V et à le brancher sur la prise jack ou la broche Vin. Le régulateur de la carte assure alors la dernière régulation, et la diode de la prise jack protège contre l'inversion de polarité. Envoyer directement 12 V dans la prise jack fonctionne aussi, mais avec une charge de 200 mA le petit régulateur de la carte dissipe (12 − 5) × 0,2 = 1,4 W ; si tu règles le LM2596 sur 7,5 V, cette perte tombe à (7,5 − 5) × 0,2 = 0,5 W. Tu trouveras toutes les solutions d'alimentation dans l'article alimenter un Arduino et l'emplacement des broches dans brochage de l'Arduino Uno.

Alimenter des servos et des moteurs : calcul du courant

L'usage le plus fréquent du LM2596, c'est la ligne d'alimentation des servos. Un SG90 consomme 100 à 250 mA en mouvement et monte à 600–700 mA au démarrage et sous effort. Un MG996R atteint environ 2,5 A bloqué sous 6 V. Pour choisir le module, ne compte pas la moyenne : additionne le courant de tous les servos qui peuvent forcer en même temps. Attendre 2 A en continu d'un LM2596 sans dissipateur est réaliste : 3 SG90 tournent sans souci, mais alimenter un bras robotique à 4–6 MG996R avec un seul module, c'est s'exposer aux redémarrages et aux tremblements. Dans ce cas, prends un module séparé pour chaque servo ou paire de servos, ou un module de 5 A comme le XL4015.

Il faut aussi calculer le courant d'entrée, car si le bloc secteur ne suit pas, la sortie chute, aussi bon que soit le module. La formule est Iin = (Vout × Iout) / (Vin × η). Pour 2 A sous 5 V depuis 12 V avec 85 % de rendement, Iin = 10 W / (12 V × 0,85) ≈ 0,98 A : un bloc 12 V 2 A suffit. La même charge tire environ 1,6 A sur un pack 2S de 7,4 V. Placer un condensateur électrolytique de 470–1000 µF près de la ligne des servos permet au condensateur, plutôt qu'au module, de fournir les pointes de démarrage. Pour toutes les solutions aux redémarrages causés par les servos, consulte Arduino redémarre tout seul, et pour le câblage des servos, qu'est-ce qu'un servomoteur et servo MG996R.

Limite de courant, échauffement et dissipateur

Un convertisseur buck est efficace, mais pas sans pertes. La puissance perdue vaut environ Ppertes = Psortie × (1/η − 1) et se répartit entre la puce, la diode Schottky et la bobine. Pour une sortie de 5 V 2 A (10 W) avec 85 % de rendement, on produit environ 1,8 W de chaleur. Le LM2596S du module est en boîtier TO-263 soudé sur une petite surface de cuivre ; selon la datasheet, sa résistance thermique vers l'air est de 30–50 °C/W selon la surface de cuivre. Voilà pourquoi, à 2 A, la puce devient trop chaude pour y laisser le doigt, et qu'à 3 A un petit dissipateur en aluminium autocollant et un flux d'air sont indispensables. Dans un boîtier fermé, ces limites baissent encore.

La limite de courant du LM2596 n'est pas réglable par l'utilisateur. Quand le courant de crête de l'interrupteur atteint environ 4,5 A (3,6–6,9 A selon la dispersion de fabrication), la puce raccourcit les impulsions, abaisse la fréquence en surcharge et se coupe si elle surchauffe. Ces protections sauvent généralement le module lors d'un court-circuit, mais elles ne remplacent pas un fusible. Pour les usages où il faut régler le courant, comme alimenter une LED de puissance ou monter une alimentation de test limitée en courant, il existe des modules LM2596 CC/CV (courant constant / tension constante) avec un second potentiomètre pour le courant. Pour une ligne robuste face aux courts-circuits, ajoute aussi un fusible adapté en entrée.

Rendement et comparaison avec le 7805

Face au régulateur de tension 7805, qui fait le même travail, l'écart saute aux yeux. Pour fournir 1 A sous 5 V depuis 12 V, le 7805 prend lui aussi 1 A en entrée et transforme (12 − 5) × 1 = 7 W en chaleur ; son rendement n'est que de 42 % et il lui faut un gros dissipateur. Le LM2596 prend environ 0,49 A en entrée pour la même charge et perd moins de 1 W. Dans les projets sur batterie, cette différence se traduit directement en autonomie : quand le rendement double, la batterie tient environ deux fois plus longtemps.

Le prix du buck, c'est le bruit. Selon la datasheet, l'ondulation en dents de scie en sortie représente typiquement 0,5 à 3 % de la tension de sortie, soit 25 à 150 mV sous 5 V, à quoi s'ajoute le bruit de découpage à 150 kHz. Pour un Arduino, des servos, des relais et des LED, ce n'est pas un problème, mais cela se remarque quand tu alimentes des mesures analogiques précises, un micro ou un amplificateur audio. Dans ce cas, combine les deux : descends d'abord à 7–8 V avec le LM2596, puis obtiens un 5 V propre avec un 7805 ou un LDO ; tu gagnes ainsi en rendement et en silence. Pour de petites expériences à faible courant sur breadboard, un module d'alimentation MB102 pour breadboard est une solution pratique.

Mesurer la sortie du LM2596 en charge avec un Arduino

Le meilleur moyen de savoir de combien la tension chute en charge, c'est de mesurer la chute pendant que la charge fonctionne. Le code ci-dessous fait balayer un servo sans arrêt entre 0 et 180 degrés et affiche pendant ce temps, dans le moniteur série, la tension la plus basse et la plus haute relevées en sortie du LM2596. Voici le câblage : le fil rouge du servo va sur OUT+, le marron sur OUT− et le fil de signal sur D9 ; entre OUT+ et la masse, tu montes un pont diviseur de 47 kΩ et 10 kΩ dont tu relies le point milieu à A0. L'Arduino est alimenté par USB, et OUT− doit être relié à la masse de l'Arduino.

1// LM2596 yük testi: servo dönerken çıkış gerilimini izle / LM2596 load test: watch the output while a servo moves
2// Kart: Arduino Uno / Nano (ATmega328P) / Board: Arduino Uno / Nano (ATmega328P)
3#include <Servo.h>
4
5const int SENSE_PIN = A0;          // OUT+ -> 47k -> A0 -> 10k -> GND
6const int SERVO_PIN = 9;           // servo sinyal kablosu / servo signal wire
7const float R_TOP = 47000.0;       // bölücü üst direnç / divider top resistor
8const float R_BOTTOM = 10000.0;    // bölücü alt direnç / divider bottom resistor
9const float AREF_V = 1.1;          // dahili referans, multimetreyle düzelt / internal reference, calibrate with a multimeter
10const float LOW_LIMIT = 4.6;       // 5 V hat için uyarı sınırı / warning limit for a 5 V rail
11
12Servo servo;
13float vMin, vMax;
14
15float readOutput() {
16  long sum = 0;
17  for (int i = 0; i < 8; i++) {
18    sum += analogRead(SENSE_PIN);  // 8 örneğin toplamı / sum of 8 samples
19  }
20  float vPin = (sum / 8.0) * AREF_V / 1023.0;
21  return vPin * (R_TOP + R_BOTTOM) / R_BOTTOM;  // bölücüyü geri hesapla / undo the divider
22}
23
24void track() {
25  float v = readOutput();
26  if (v < vMin) vMin = v;          // en düşük değer / lowest value
27  if (v > vMax) vMax = v;          // en yüksek değer / highest value
28}
29
30void setup() {
31  Serial.begin(9600);
32  analogReference(INTERNAL);       // 1,1 V referans, beslemeden bağımsız / 1.1 V reference, independent of the supply
33  for (int i = 0; i < 10; i++) {   // referans otursun, ilk okumaları at / let the reference settle, drop first readings
34    analogRead(SENSE_PIN);
35    delay(5);
36  }
37  servo.attach(SERVO_PIN);
38}
39
40void loop() {
41  vMin = 99.0;
42  vMax = 0.0;
43  for (int a = 0; a <= 180; a += 2) {     // 0 -> 180 derece / 0 -> 180 degrees
44    servo.write(a);
45    for (int k = 0; k < 5; k++) { track(); delay(2); }
46  }
47  for (int a = 180; a >= 0; a -= 2) {     // 180 -> 0 derece / 180 -> 0 degrees
48    servo.write(a);
49    for (int k = 0; k < 5; k++) { track(); delay(2); }
50  }
51  Serial.print(F("Min: "));
52  Serial.print(vMin, 2);
53  Serial.print(F(" V  Max: "));
54  Serial.print(vMax, 2);
55  Serial.print(F(" V  Dusus / Drop: "));
56  Serial.print(vMax - vMin, 2);
57  Serial.println(F(" V"));
58  if (vMin < LOW_LIMIT) {
59    Serial.println(F("UYARI: gerilim cok dusuyor / WARNING: voltage sags too much"));
60  }
61  delay(1000);
62}

Au lieu de la tension d'alimentation de l'Arduino, le code utilise la référence interne de 1,1 V de l'ATmega328P (analogReference(INTERNAL)) : la mesure ne dépend donc pas du fait que l'USB fournisse 4,7 V ou 5,1 V. Avec le pont 47k/10k, tu peux mesurer au maximum environ 6,2 V ; sur une ligne de servos en 6 V, pour couvrir la tolérance de la référence, passe la résistance du haut à 56 kΩ et modifie la constante R_TOP. Comme la référence interne peut varier d'environ ±10 % d'une puce à l'autre, mesure une fois la sortie au multimètre et corrige AREF_V (par exemple 1,08) jusqu'à ce que les deux résultats concordent. Si la chute dépasse 0,3 V pendant que le servo tourne, raccourcis les fils, prends du fil plus gros et ajoute 470 µF sur la ligne des servos ; sous 0,1 V, ton alimentation est saine.

ESP32 : alimentation sur batterie 12 V et surveillance de la batterie

Alimenter un ESP32 sur une batterie 12 V est un scénario classique pour une station de capteurs au jardin ou un traceur dans une voiture. Règle le LM2596 sur 5,0 V et branche-le sur la broche 5V (VIN) de la carte ESP32 ; le LDO de la carte produit le 3,3 V. Le LM2596 encaisse sans peine les courtes pointes de courant que l'ESP32 tire en émettant en Wi-Fi ; les symptômes d'une alimentation trop faible sont détaillés dans l'article erreur brownout de l'ESP32. Le code ci-dessous lit la tension de la batterie sur GPIO34 via un pont de 100 kΩ / 22 kΩ et met l'ESP32 en sommeil profond pendant 10 minutes dès que la tension atteint la limite basse sûre d'une batterie au plomb.

1// ESP32: LM2596 ile 12 V aküden beslen, aküyü izle / ESP32: run from a 12 V battery via an LM2596, monitor the battery
2#include <Arduino.h>
3#include "esp_sleep.h"
4
5const int BAT_PIN = 34;                           // GPIO34: yalnız giriş, ADC1 / input-only, ADC1
6const float RATIO = (100.0 + 22.0) / 22.0;        // 100k / 22k bölücü (~5,55) / divider (~5.55)
7const float LOW_V = 11.8;                         // kurşun asit akü alt sınırı / lead-acid low limit
8const uint64_t SLEEP_US = 10ULL * 60 * 1000000;   // 10 dakika (mikrosaniye) / 10 minutes (microseconds)
9
10float batteryVolts() {
11  uint32_t mv = 0;
12  for (int i = 0; i < 16; i++) {
13    mv += analogReadMilliVolts(BAT_PIN);          // kalibre edilmiş mV / calibrated mV
14  }
15  return mv / 16.0 / 1000.0 * RATIO;              // bölücüyü geri hesapla / undo the divider
16}
17
18void setup() {
19  Serial.begin(115200);
20  delay(200);
21}
22
23void loop() {
24  float v = batteryVolts();
25  Serial.printf("Aku / Battery: %.2f V\n", v);
26  if (v < LOW_V) {
27    Serial.println("Aku zayif, 10 dk uyku / Battery low, sleeping 10 min");
28    Serial.flush();
29    esp_sleep_enable_timer_wakeup(SLEEP_US);      // zamanlayıcıyla uyan / wake up by timer
30    esp_deep_sleep_start();                       // derin uyku / deep sleep
31  }
32  delay(5000);
33}

Le pont ramène même une tension de charge de 14,4 V à environ 2,6 V : tu restes donc dans la plage de mesure de l'ADC de l'ESP32. Au repos, une batterie au plomb est pleine vers 12,6–12,8 V ; descendre sous 11,8 V la rapproche de la décharge profonde et réduit sa durée de vie. Attention à un point : le LM2596 consomme lui-même 5 à 10 mA, même à vide. Alors que l'ESP32 ne consomme que quelques microampères en sommeil profond, le module avale 120 à 240 mAh par jour, et une batterie de 7 Ah se vide en 1 à 2 mois rien qu'à cause de lui. Tu peux faire le calcul avec tes propres valeurs grâce au calculateur d'autonomie de batterie. Pour les projets qui dorment pendant des mois, il faut un module dont la broche EN (ON/OFF) est accessible pour couper complètement l'alimentation, ou un abaisseur à très faible courant de repos ; les techniques de sommeil sont détaillées dans l'article ESP32 deep sleep.

Assistant de réglage avec la Raspberry Pi Pico (MicroPython)

Si tu veux suivre le réglage sur l'écran de l'ordinateur, tu peux utiliser la Pico comme un voltmètre simple. Comme l'ADC de la Pico lit au maximum 3,3 V, relie la sortie du LM2596 à GP26 via un pont de 100 kΩ et 10 kΩ ; avec ce rapport, tu mesures sans risque jusqu'à 36 V, donc même si le module pas encore réglé sort une tension proche de son entrée, la Pico ne craint rien. La Pico est alimentée par USB et les masses sont reliées. Selon la valeur visée, le code affiche "high" ou "low" et allume la LED de la carte dès que la sortie est à ±1 % près. Si tu découvres la Pico, commence par Qu'est-ce que la Raspberry Pi Pico ?.

1# Pico: LM2596 ayar yardımcısı / Pico: LM2596 adjustment helper
2from machine import ADC, Pin
3import time
4
5adc = ADC(26)                  # GP26 (ADC0): OUT+ -> 100k -> GP26 -> 10k -> GND
6led = Pin("LED", Pin.OUT)      # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
7RATIO = (100 + 10) / 10        # bölücü oranı 11, en fazla ~36 V / divider ratio 11, up to ~36 V
8VREF = 3.3                     # ADC referansı (V) / ADC reference (V)
9CAL = 1.000                    # multimetreyle düzeltme katsayısı / multimeter correction factor
10TARGET = 5.00                  # hedef: 5.00 ya da 3.30 / target: 5.00 or 3.30
11
12def read_volts(n=64):
13    total = 0
14    for _ in range(n):
15        total += adc.read_u16()                    # 0-65535 ham değer / raw value
16    return total / n / 65535 * VREF * RATIO * CAL
17
18while True:
19    v = read_volts()
20    err = (v - TARGET) / TARGET * 100              # hedeften sapma (%) / deviation from target (%)
21    led.value(abs(err) <= 1.0)                     # ±%1 içinde LED yanar / LED on within ±1%
22    if err > 1.0:
23        hint = "yuksek, dusur / high, lower it"
24    elif err < -1.0:
25        hint = "dusuk, artir / low, raise it"
26    else:
27        hint = "tamam / OK"
28    print("{:.2f} V  {:+.1f} %  {}".format(v, err, hint))
29    time.sleep(0.3)

Comme l'ADC de la Pico peut se tromper d'environ 1 à 2 %, corrige une fois le coefficient CAL en comparant avec le multimètre ; le mieux reste de confirmer le réglage final au multimètre. Si tu veux ensuite alimenter aussi la Pico avec le LM2596, relie la sortie 5,0 V à la broche VSYS à travers une diode Schottky 1N5819 ; la diode empêche les deux sources de se contrarier quand l'USB est branché. Ne relie jamais la sortie du module à la broche 3V3 de la Pico.

Idées de projets avec le LM2596

• Voiture robot : un pack 2S de 18650 (7,4 V) alimente directement les moteurs via le L298N, et un LM2596 réglé sur 5 V alimente l'Arduino et les capteurs. Les étapes sont dans l'article fabriquer une voiture robot Arduino.
• Bras robotique : avec un LM2596 réglé sur 6 V, crée une ligne puissante pour les servos MG996R, indépendante de l'Arduino ; détails dans le guide du bras robotique Arduino.
• Serre connectée en 12 V : un seul bloc secteur 12 V alimente le ventilateur et la pompe, et le LM2596 tire de la même ligne le 5 V de l'Arduino, des relais et de l'écran LCD ; voir le projet de serre connectée.
• Alimentation de laboratoire réglable : avec un LM2596, un vieux chargeur d'ordinateur portable et un voltmètre numérique à base d'Arduino, fabrique une petite alimentation de labo qui affiche sa sortie.
• Ruban LED WS2812B : 60 LED en blanc à fond peuvent monter à 3,6 A ; limite la luminosité et reste sous 2 A avec un LM2596 en 5 V. Le calcul du courant est dans l'article WS2812B NeoPixel.
• Boîtier ESP32 pour la voiture : abaisse les 12–14,4 V de la batterie à 5 V ; ajoute un fusible en entrée et une diode TVS contre les pointes de tension du véhicule.

Erreurs fréquentes et solutions

Bien réglé, avec un écart suffisant entre entrée et sortie et sans dépasser sa limite de 2 A, le LM2596 est l'un des composants les plus pratiques pour alimenter un projet à partir d'un seul bloc secteur ou d'une seule batterie. Retiens l'ordre : d'abord régler à vide, ensuite mesurer en charge, et brancher la carte en dernier. Dans l'application BlueGrays, tu trouveras des projets qui demandent une alimentation séparée, comme la voiture Bluetooth à L298N, le robot qui évite les obstacles, les projets à servos, la chorégraphie à 32 servos, la commande de ruban WS2812B, le voltmètre numérique avec écran LCD et la station d'arrosage intelligente, avec schémas de câblage et code pas à pas.