Regolare lo step down LM2596: 5 V e 3,3 V con il multimetro

Regolare l'LM2596 significa alimentare l'ingresso del modulo e girare la vite in ottone del trimmer blu mentre misuri l'uscita con il multimetro, finché non leggi il valore che ti serve, per esempio 5 V o 3,3 V. Il modulo step down (buck) LM2596 è un convertitore economico e diffusissimo che ricava in modo efficiente una tensione più bassa da un alimentatore da 12 V, dalla batteria dell'auto o da un pacco Li-ion 2S per alimentare Arduino, ESP32, servo e strisce LED. Accetta da 4,5 a 40 V in ingresso, li abbassa a qualsiasi valore tra circa 1,25 V e 35 V e può erogare fino a 3 A. La regola d'oro sta in una frase: regola e misura sempre l'uscita prima di collegare un carico.

In questa guida scoprirai come funziona un convertitore buck, quali sono i pin e i componenti del modulo, come regolare passo passo 5 V e 3,3 V con il trimmer e il multimetro e la formula Vout = 1,23 × (1 + R2 / R1) che stabilisce l'uscita. Poi vedremo come alimentare Arduino e servo da 12 V, il limite di corrente e il riscaldamento, l'efficienza e la differenza con il 7805 e gli errori più comuni (inversione di polarità, calo di tensione sotto carico), per arrivare al codice che misura l'uscita con Arduino, ESP32 e Raspberry Pi Pico.

Che cos'è l'LM2596 e come funziona?

L'LM2596 è un integrato regolatore abbassatore a commutazione, sviluppato in origine da National Semiconductor e prodotto oggi da Texas Instruments. I regolatori lineari come il 7805 si liberano della tensione in eccesso trasformandola in calore; l'LM2596 invece accende e spegne il suo transistor di potenza interno circa 150.000 volte al secondo (150 kHz). Quando il transistor conduce, la corrente attraversa l'induttore verso il carico e l'induttore immagazzina energia nel suo campo magnetico; quando il transistor si interdice, l'induttore continua a cedere quell'energia al carico attraverso un diodo Schottky. Il condensatore di uscita livella questi impulsi. La frazione di tempo in cui il transistor resta acceso si chiama duty cycle (ciclo di lavoro) e vale circa D ≈ Vout / Vin: per ottenere 5 V da 12 V, l'interruttore è acceso per circa il 42% del tempo.

Poiché l'energia non viene bruciata, l'efficienza è intorno all'80–90% e la corrente assorbita in ingresso è minore di quella erogata in uscita: un modulo che fornisce 2 A a 5 V partendo da 12 V assorbe solo circa 1 A in ingresso. A mantenere stabile la tensione d'uscita ci pensa il pin FB (feedback, retroazione). Il chip confronta la tensione su FB con il suo riferimento interno di 1,23 V e regola il duty cycle di conseguenza. Sul modulo già pronto, un ramo del partitore di tensione collegato al pin FB è un trimmer multigiro; girando la vite cambi il rapporto del partitore e quindi la tensione d'uscita. Esistono anche versioni fisse dell'LM2596 da 3,3 V, 5 V e 12 V, ma nel mondo Arduino la più diffusa è il modulo blu con la versione regolabile (ADJ).

Pin del modulo e componenti sulla scheda

Il modulo blu LM2596 ha quattro punti di collegamento: IN+ e IN− sono l'ingresso, OUT+ e OUT− l'uscita. IN− e OUT− sono collegati tra loro sulla scheda; un convertitore buck non isola l'ingresso dall'uscita, quindi sorgente, modulo e scheda alimentata condividono la stessa massa (GND). Sulla scheda trovi il chip LM2596S a cinque piedini (contenitore TO-263: VIN, uscita, GND, FB e ON/OFF), un grosso induttore da 33–47 µH di solito marcato 330 o 470, un diodo Schottky da 3 A come l'SS34, un condensatore elettrolitico in ingresso e uno in uscita (di solito 100–220 µF) e un trimmer multigiro marcato 103 (10 kΩ). Puoi decifrare la sigla dell'induttore con il calcolatore del codice degli induttori. Nella maggior parte dei moduli il pin ON/OFF del chip è collegato a GND, quindi il modulo parte appena riceve tensione.

Regolare l'LM2596 passo passo: 5 V o 3,3 V con il multimetro

1. Non collegare nulla all'uscita. Il modulo si regola a vuoto; Arduino o ESP32 si collegano solo dopo aver visto la tensione giusta.
2. Collega all'ingresso la sorgente reale che userai nel progetto (per esempio un alimentatore da 12 V 2 A): il positivo su IN+, il negativo su IN−. Se la scheda ha un LED, si accende.
3. Imposta il multimetro su tensione continua (portata 20 V o automatica); appoggia il puntale rosso su OUT+ e quello nero su OUT−. La prima lettura può essere vicina alla tensione d'ingresso, perché la taratura di fabbrica è sconosciuta.
4. Con un piccolo cacciavite a taglio, gira la vite in ottone del trimmer di 2–3 giri in un verso e guarda il display. Se la tensione scende, stai girando nel verso giusto; se sale, gira al contrario. Il verso può cambiare da un modulo all'altro a seconda di come è collegato il trimmer.
5. In un trimmer multigiro da circa 25 giri, percorrere tutta la corsa può richiedere 20 giri e oltre. La vite non ha un fine corsa; arrivata in fondo gira a vuoto con un leggero clic e la tensione non cambia più. In quel caso torna indietro.
6. Quando ti avvicini al valore, procedi a quarti di giro e poi a passi ancora più piccoli. Per 5 V lascialo tra 5,00 e 5,10 V, per 3,3 V tra 3,30 e 3,35 V; con schede a 3,3 V come ESP32 e Pico non superare mai i 3,6 V.
7. Collega il carico, oppure prova con una resistenza da 10 Ω / 5 W che a 5 V assorbe circa 500 mA, e ripeti la misura sotto carico. Se la tensione cala di più di 0,1–0,2 V, controlla sorgente e cablaggio.
8. Finita la regolazione, metti una goccia di smalto per unghie o di colla a caldo sulla vite del trimmer; sui robot che vibrano la taratura può spostarsi col tempo.

La formula dell'uscita: Vout = 1,23 × (1 + R2 / R1)

L'LM2596 regola l'uscita in modo che sul pin FB ci siano 1,23 V. Chiamando R2 la resistenza tra uscita e FB e R1 quella tra FB e GND, l'uscita vale Vout = 1,23 × (1 + R2 / R1). Sul modulo il trimmer da 10 kΩ prende il posto di R2, mentre R1 è una piccola resistenza fissa sulla scheda. Dalla formula derivano due conseguenze importanti: anche con R2 vicina a zero l'uscita non può scendere sotto 1,23 V; e per quanto cresca R2, l'uscita non può superare l'ingresso. Se alzi troppo il trimmer, il chip tiene l'interruttore sempre acceso e l'uscita resta bloccata circa 1–2 V sotto l'ingresso. È la causa più comune della lamentela "il mio modulo non abbassa la tensione".

Se in un progetto soggetto a vibrazioni o destinato a durare preferisci resistenze fisse al posto del trimmer, segui il datasheet e scegli R1 tra 240 Ω e 1,5 kΩ. Con R1 = 1 kΩ, per 5 V si ottiene R2 = 1 kΩ × (5 / 1,23 − 1) ≈ 3,07 kΩ; con una 3,09 kΩ all'1% l'uscita è 5,03 V. Per 3,3 V risulta R2 ≈ 1,68 kΩ, e una 1,69 kΩ all'1% dà 3,31 V. In fondo è un partitore di tensione; puoi controllare i rapporti con il calcolatore del partitore di tensione.

I valori minimi della tabella valgono per un carico di 2–3 A: l'interruttore dell'LM2596 ha una caduta tipica di 1,16 V a 3 A, e induttore e cavi aggiungono qualche centinaio di millivolt. Con carico leggero (circa 1 A) la differenza scende a circa 1,5 V. Un pacco Li-ion 2S da 7,4 V scende intorno a 6,4 V mentre si scarica; basta ancora per una linea a 5 V da 1 A, ma non per una linea servo a 6 V. Per regolare un modulo GSM che richiede 4 V, leggi l'articolo sul SIM800L.

Alimentare Arduino da un alimentatore o una batteria da 12 V

Ci sono due modi corretti per alimentare Arduino con un LM2596. Il primo è regolare il modulo a 5,0 V e collegare l'uscita direttamente al pin 5V. Poiché così si salta il regolatore della scheda, non si produce quasi calore ed è la soluzione più efficiente; però non resta nulla a proteggere la scheda. Se il trimmer si sposta o il modulo si guasta e passa l'ingresso all'uscita, i 12 V arrivano direttamente al microcontrollore. Se con questo collegamento inserisci anche il cavo USB, l'alimentazione USB del computer e l'uscita del modulo si ritrovano collegate; la cosa più sicura è scollegare il modulo mentre carichi lo sketch.

Il secondo modo è regolare il modulo a 7,5–9 V e collegarlo al jack DC o al pin Vin. In questo caso la regolazione finale la fa il regolatore della scheda, e il diodo sul jack protegge dall'inversione di polarità. Anche mandare 12 V direttamente nel jack funziona, ma con un carico di 200 mA il piccolo regolatore della scheda produce (12 − 5) × 0,2 = 1,4 W di calore; regolando l'LM2596 a 7,5 V questa perdita scende a (7,5 − 5) × 0,2 = 0,5 W. Trovi tutte le opzioni di alimentazione nell'articolo alimentare Arduino e la posizione dei pin in pinout di Arduino Uno.

Alimentare servo e motori: calcolo della corrente

L'uso più frequente dell'LM2596 è la linea dei servo. Un SG90 assorbe 100–250 mA in movimento e sale a 600–700 mA all'avvio e sotto sforzo. Un MG996R arriva a circa 2,5 A in stallo a 6 V. Nella scelta del modulo non contare la media: somma la corrente di tutti i servo che possono essere sotto sforzo contemporaneamente. Aspettarsi 2 A continui da un LM2596 senza dissipatore è realistico: 3 SG90 funzionano tranquillamente, ma alimentare un braccio robotico con 4–6 MG996R da un solo modulo significa andare incontro a reset e tremolii. In quel caso usa un modulo separato ogni uno o due servo, oppure un modulo da 5 A come l'XL4015.

Devi calcolare anche la corrente d'ingresso, perché se l'alimentatore non ce la fa l'uscita cala, per quanto buono sia il modulo. La formula è Iin = (Vout × Iout) / (Vin × η). Per 2 A a 5 V da 12 V con l'85% di efficienza, Iin = 10 W / (12 V × 0,85) ≈ 0,98 A: basta un alimentatore da 12 V 2 A. Lo stesso carico assorbe circa 1,6 A da un pacco batterie 2S da 7,4 V. Mettere un condensatore elettrolitico da 470–1000 µF vicino alla linea dei servo fa sì che le correnti di spunto le fornisca il condensatore invece del modulo. Per tutte le soluzioni ai reset causati dai servo vedi Arduino si resetta da solo, e per il collegamento dei servo cos'è un servomotore e servo MG996R.

Limite di corrente, riscaldamento e dissipatore

Un convertitore buck è efficiente, ma non privo di perdite. La potenza persa vale circa Pperdita = Puscita × (1/η − 1) e si divide tra chip, diodo Schottky e induttore. Con un'uscita di 5 V 2 A (10 W) e un'efficienza dell'85% si producono circa 1,8 W di calore. L'LM2596S del modulo è in un contenitore TO-263 saldato su una piccola area di rame; secondo il datasheet la sua resistenza termica verso l'aria è di 30–50 °C/W a seconda dell'area di rame. Per questo a 2 A il chip diventa troppo caldo per tenerci sopra il dito, e a 3 A sono indispensabili un piccolo dissipatore in alluminio adesivo e un flusso d'aria. In una scatola chiusa questi limiti scendono ancora.

Il limite di corrente dell'LM2596 non è regolabile dall'utente. Quando la corrente di picco dell'interruttore raggiunge circa 4,5 A (3,6–6,9 A a seconda della dispersione di produzione), il chip accorcia gli impulsi, abbassa la frequenza in sovraccarico e si spegne se si surriscalda. Queste protezioni di solito salvano il modulo in un cortocircuito, ma non sostituiscono un fusibile. Per i lavori in cui devi impostare la corrente, come pilotare un LED di potenza o costruire un alimentatore di prova a corrente limitata, esistono moduli LM2596 CC/CV (corrente costante / tensione costante) con un secondo trimmer per la corrente. Se vuoi una linea robusta contro i cortocircuiti, aggiungi anche un fusibile adeguato sull'ingresso.

Efficienza e confronto con il 7805

Confrontandolo con il regolatore di tensione 7805, che fa lo stesso lavoro, la differenza diventa evidente. Per fornire 1 A a 5 V da 12 V, il 7805 assorbe 1 A anche in ingresso e trasforma (12 − 5) × 1 = 7 W in calore; la sua efficienza è solo del 42% e richiede un grosso dissipatore. L'LM2596 con lo stesso carico assorbe circa 0,49 A in ingresso e perde meno di 1 W. Nei progetti a batteria questa differenza si traduce direttamente in autonomia: se l'efficienza raddoppia, la batteria dura circa il doppio.

Il prezzo del buck è il rumore. Secondo il datasheet, il ripple a dente di sega in uscita è tipicamente lo 0,5–3% della tensione d'uscita, cioè 25–150 mV a 5 V, a cui si aggiunge il rumore di commutazione a 150 kHz. Per Arduino, servo, relè e LED non è un problema, ma si nota quando alimenti misure analogiche precise, un microfono o un amplificatore audio. In questi casi combina le due cose: scendi prima a 7–8 V con l'LM2596, poi ottieni 5 V puliti con un 7805 o un LDO; così guadagni sia efficienza sia silenzio. Per piccoli esperimenti a bassa corrente su breadboard, un modulo di alimentazione MB102 per breadboard è una soluzione pratica.

Misurare l'uscita dell'LM2596 sotto carico con Arduino

Il modo migliore per capire quanto cala la tensione sotto carico è misurare il calo mentre il carico lavora. Il codice qui sotto fa oscillare di continuo un servo tra 0 e 180 gradi e intanto scrive nel Monitor seriale la tensione più bassa e quella più alta viste all'uscita dell'LM2596. Il collegamento è questo: il filo rosso del servo va su OUT+, quello marrone su OUT− e quello del segnale su D9; tra OUT+ e GND costruisci un partitore di tensione da 47 kΩ e 10 kΩ e colleghi il punto centrale ad A0. Arduino è alimentato via USB e OUT− deve essere unito alla GND di 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}

Invece della tensione di alimentazione di Arduino, il codice usa il riferimento interno da 1,1 V dell'ATmega328P (analogReference(INTERNAL)), così la misura non dipende dal fatto che l'USB dia 4,7 V o 5,1 V. Con il partitore 47k/10k puoi misurare al massimo circa 6,2 V; su una linea servo a 6 V, per coprire la tolleranza del riferimento, porta la resistenza superiore a 56 kΩ e modifica la costante R_TOP. Poiché il riferimento interno può variare di circa ±10% da un chip all'altro, misura l'uscita una volta con il multimetro e correggi AREF_V (per esempio 1,08) finché i due risultati coincidono. Se il calo supera 0,3 V mentre il servo si muove, accorcia i cavi, usa cavi più grossi e aggiungi 470 µF alla linea dei servo; sotto 0,1 V la tua alimentazione è in salute.

ESP32: alimentarlo da una batteria da 12 V e controllare la batteria

Alimentare un ESP32 da una batteria da 12 V è uno scenario tipico per una stazione di sensori in giardino o un localizzatore in auto. Regola l'LM2596 a 5,0 V e collegalo al pin 5V (VIN) della scheda ESP32; l'LDO della scheda genera i 3,3 V. L'LM2596 copre senza fatica i brevi picchi di corrente che l'ESP32 assorbe quando trasmette in Wi-Fi; i sintomi di un'alimentazione debole sono spiegati nel dettaglio nell'articolo errore brownout dell'ESP32. Il codice qui sotto legge la tensione della batteria su GPIO34 tramite un partitore da 100 kΩ / 22 kΩ e manda l'ESP32 in deep sleep per 10 minuti quando la tensione raggiunge il limite inferiore sicuro di una batteria al piombo.

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}

Il partitore riduce anche una tensione di carica di 14,4 V a circa 2,6 V, quindi resti dentro il campo di misura dell'ADC dell'ESP32. Una batteria al piombo a riposo è carica intorno a 12,6–12,8 V; scendere sotto 11,8 V la avvicina alla scarica profonda e ne accorcia la vita. C'è però un dettaglio: l'LM2596 da solo assorbe 5–10 mA anche a vuoto. Mentre l'ESP32 in deep sleep consuma solo microampere, il modulo consuma 120–240 mAh al giorno, e una batteria da 7 Ah si scarica in 1–2 mesi solo per questo. Puoi rifare il calcolo con i tuoi valori usando il calcolatore di durata della batteria. Nei progetti che devono dormire per mesi serve un modulo con il pin EN (ON/OFF) accessibile per togliere del tutto l'alimentazione, oppure un abbassatore con corrente di riposo molto bassa; le tecniche di sospensione sono spiegate nel dettaglio nell'articolo ESP32 deep sleep.

Assistente di regolazione con Raspberry Pi Pico (MicroPython)

Se vuoi seguire la regolazione sullo schermo del computer, puoi usare il Pico come un semplice voltmetro. Dato che l'ADC del Pico legge al massimo 3,3 V, collega l'uscita dell'LM2596 a GP26 tramite un partitore da 100 kΩ e 10 kΩ; con questo rapporto misuri in sicurezza fino a 36 V, quindi anche se il modulo non ancora regolato dà una tensione vicina a quella d'ingresso, il Pico non si danneggia. Il Pico è alimentato via USB e le GND sono unite. In base al valore desiderato, il codice scrive "high" o "low" e accende il LED della scheda quando l'uscita entra nel margine di ±1%. Se sei alle prime armi con il Pico, parti da Cos'è il 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)

Poiché l'ADC del Pico può sbagliare di circa l'1–2%, correggi una volta il fattore CAL confrontandolo con il multimetro; resta comunque meglio confermare la regolazione finale con il multimetro. Se poi vuoi alimentare anche il Pico dall'LM2596, collega l'uscita a 5,0 V al pin VSYS attraverso un diodo Schottky 1N5819; il diodo evita che le due sorgenti si contrastino quando l'USB è collegato. Non collegare mai l'uscita del modulo al pin 3V3 del Pico.

Idee di progetto con l'LM2596

• Auto robot: un pacco 2S di 18650 (7,4 V) alimenta direttamente i motori tramite l'L298N, e un LM2596 regolato a 5 V alimenta Arduino e sensori. I passaggi sono nell'articolo costruire un'auto robot con Arduino.
• Braccio robotico: con un LM2596 regolato a 6 V crea una linea robusta per i servo MG996R, indipendente da Arduino; i dettagli sono nella guida al braccio robotico con Arduino.
• Serra intelligente a 12 V: un solo alimentatore da 12 V alimenta ventola e pompa, e l'LM2596 ricava dalla stessa linea i 5 V per Arduino, relè e LCD; vedi il progetto di serra intelligente.
• Alimentatore da banco regolabile: con un LM2596, un vecchio alimentatore da portatile e un voltmetro digitale fatto con Arduino, costruisci un piccolo alimentatore da laboratorio che mostra l'uscita su un display.
• Striscia LED WS2812B: 60 LED al massimo del bianco possono arrivare a 3,6 A; limita la luminosità e resta sotto i 2 A con un LM2596 a 5 V. Il calcolo della corrente è nell'articolo WS2812B NeoPixel.
• Dispositivo ESP32 per l'auto: abbassa i 12–14,4 V della batteria a 5 V; aggiungi un fusibile sull'ingresso e un diodo TVS contro i picchi di tensione del veicolo.

Errori comuni e soluzioni

Ben regolato, con un margine sufficiente tra ingresso e uscita e senza superare il limite di 2 A, l'LM2596 è uno dei componenti più pratici per alimentare un progetto da un solo alimentatore o una sola batteria. Ricorda l'ordine: prima regola a vuoto, poi misura sotto carico e solo alla fine collega la scheda. Nell'app BlueGrays trovi progetti che richiedono un'alimentazione separata, come l'auto Bluetooth con L298N, il robot che evita gli ostacoli, i progetti con servo, la coreografia con 32 servo, il controllo di strisce WS2812B, il voltmetro digitale con LCD e la stazione di irrigazione intelligente, con schemi elettrici e codice passo passo.