Regolatore di tensione 7805: schema, condensatori e dissipatore

Il regolatore di tensione 7805 è un integrato economico a tre piedini che prende una tensione alta o instabile compresa tra 7 e 35 V e la trasforma in 5 V stabili. È il modo più semplice per ottenere 5 V puliti per Arduino, sensori e moduli relè da un alimentatore da 12 V, dalla batteria dell'auto o da un pacco di pile: basta aggiungere due piccoli condensatori. Il 7805 però funziona trasformando in calore la tensione in eccesso, quindi conoscere il collegamento corretto, i limiti della tensione di ingresso e quanto si scalderà è la chiave per un circuito che funzioni in sicurezza.

In questa guida imparerai passo dopo passo cos'è un regolatore di tensione, la piedinatura del 7805 e come collegarlo con i condensatori da 0,33 µF e 0,1 µF, cosa significa tensione di dropout, come calcolare il calore con P = (Vin − Vout) · I e come scegliere un dissipatore. Poi vedremo la famiglia 78xx, l'LDO AMS1117-3.3 per i moduli a 3,3 V, la differenza tra regolatori lineari e switching (buck), il regolatore di bordo di Arduino e il limite di Vin, e chiuderemo con il codice che misura il regolatore con Arduino, ESP32 e Raspberry Pi Pico.

Cos'è un regolatore di tensione e come funziona?

Un regolatore di tensione è un circuito che mantiene costante la tensione in uscita anche quando cambiano la tensione di ingresso o la corrente assorbita dal carico. Il 7805 è un regolatore lineare: al suo interno ci sono un transistor di potenza in serie tra ingresso e uscita, una tensione di riferimento interna che non varia con la temperatura e un amplificatore d'errore che confronta di continuo l'uscita con quel riferimento. Se l'uscita scende sotto i 5 V, il transistor conduce un po' di più; se sale, si chiude un po'. In breve, il transistor si comporta come una resistenza che si regola da sola e si fa carico della tensione in eccesso tra ingresso e uscita. Quella tensione moltiplicata per la corrente diventa calore: ecco perché il 7805 è così semplice e allo stesso tempo si scalda.

Le ultime due cifre della famiglia 78 indicano la tensione di uscita: il 7805 dà 5 V, il 7812 dà 12 V. Le lettere davanti identificano solo il produttore; LM7805, L7805CV, MC7805 e KA7805 fanno lo stesso lavoro. Il chip integra la limitazione di corrente, lo spegnimento per sovratemperatura e la protezione dell'area di funzionamento sicuro. Per questo si rompe raramente anche se l'uscita va in cortocircuito: si limita a ridurre la corrente o si spegne finché non si raffredda.

Piedinatura del 7805 e schema di collegamento

Se tieni il 7805 con il lato stampato verso di te e i piedini in basso, da sinistra a destra i pin sono 1: Ingresso (IN), 2: GND e 3: Uscita (OUT). Anche la linguetta metallica con il foro è collegata a GND, quindi puoi avvitare il 7805 senza isolante su un dissipatore o un contenitore metallico collegati alla massa del circuito. La GND del lato ingresso e quella del lato uscita sono lo stesso punto: alimentatore, regolatore e scheda alimentata devono condividere una massa comune. La tabella mostra dove va collegata l'uscita del 7805 su ogni scheda.

Condensatori: perché 0,33 µF e 0,1 µF?

Lo schema standard dei datasheet dei produttori prevede un condensatore da 0,33 µF in ingresso e uno da 0,1 µF in uscita (alcuni produttori indicano 0,22 µF in ingresso). Il condensatore di ingresso evita le oscillazioni dovute all'induttanza dei fili quando il regolatore è lontano dal condensatore di filtro dell'alimentatore. Quello di uscita non è indispensabile per la stabilità, ma rende la tensione più stabile durante le variazioni improvvise del carico. Entrambi devono essere ceramici e montati il più vicino possibile ai piedini. Un condensatore ceramico da 0,33 µF riporta la sigla 334 e uno da 0,1 µF la sigla 104; per decifrare altre sigle usa il calcolatore del codice dei condensatori.

In pratica è una buona abitudine affiancare a ciascuno di questi piccoli condensatori un elettrolitico: 10–100 µF in ingresso attenuano il ripple della sorgente, e 10–47 µF in uscita riducono i cali di tensione con carichi che assorbono corrente all'improvviso, come servo, relè o moduli Wi-Fi. Se metti più di 10 µF in uscita, aggiungi un diodo 1N4001 dall'uscita all'ingresso (in inversa durante il funzionamento normale) nel caso l'ingresso vada in cortocircuito: se l'ingresso crolla di colpo a zero, il condensatore grande si scarica attraverso questo diodo e non attraverso il regolatore. Un secondo 1N4001 in serie all'ingresso protegge dall'inversione di polarità, ma aggiunge una caduta di circa 0,7 V. Per tipi e verso di montaggio, leggi cos'è un condensatore e cos'è un diodo.

Passo dopo passo: alimentazione a 5 V con un 7805 su breadboard

1. Inserisci il 7805 nella breadboard con ogni piedino in una colonna diversa e il lato stampato rivolto verso di te.
2. Collega il positivo della sorgente (per esempio un alimentatore da 9 V) al piedino 1, l'ingresso, e il negativo al piedino 2, GND. Se vuoi, aggiungi un 1N4001 in serie sul positivo per proteggere dall'inversione di polarità.
3. Inserisci il condensatore ceramico da 0,33 µF (334) tra ingresso e GND, nei fori più vicini ai piedini.
4. Inserisci il condensatore ceramico da 0,1 µF (104) e, se vuoi, un elettrolitico da 10–47 µF tra l'uscita (3) e GND; il piedino lungo dell'elettrolitico va al positivo.
5. Prima di collegare un carico, misura l'uscita con il multimetro: dovresti leggere tra 4,8 e 5,2 V.
6. Collega l'uscita al pin 5V di Arduino e GND alla GND di Arduino. Evita di usare insieme USB e alimentazione esterna mentre carichi lo sketch.
7. Dopo qualche minuto di funzionamento controlla la temperatura del regolatore; se scalda molto, aggiungi un dissipatore in base al calcolo del calore più sotto o abbassa la tensione di ingresso.

Tensione di dropout: quanti volt servono come minimo in ingresso?

Perché un regolatore lineare mantenga stabile l'uscita, l'ingresso deve superare l'uscita di una certa quantità; questa differenza minima si chiama tensione di dropout. Nel 7805 il dropout tipico è di 2 V a 1 A, quindi per avere 5 V in uscita servono almeno 7 V in ingresso, e anche le condizioni di prova del datasheet partono da 7–7,5 V. Se la differenza scende sotto questo valore, il regolatore non riesce più a regolare e l'uscita segue l'ingresso circa 2 V più in basso: con 6 V in ingresso l'uscita scende a circa 4 V, Arduino si resetta o le letture analogiche si spostano.

Quello che conta non è il valore medio, ma il punto più basso dell'ingresso. In un alimentatore classico con trasformatore, ponte di diodi e condensatore di filtro, la tensione oscilla a ogni semiperiodo; il ripple si stima con ΔV = I / (100 · C) (rete a 50 Hz, raddrizzamento a doppia semionda). Con un carico di 500 mA e 2200 µF, ΔV ≈ 2,3 V. Un trasformatore da 9 V in alternata, una volta raddrizzato, arriva a circa 11,3 V di picco, quindi il fondo del ripple resta intorno ai 9 V; è sopra i 7 V e basta. Con la stessa logica, una pila da 9 V scende presto sotto i 7 V sotto carico, ed è per questo che alimentare un 7805 con una pila da 9 V dura poco. Per le opzioni a batteria, leggi la guida su come alimentare Arduino con una batteria.

Calcolo del calore: P = (Vin − Vout) · I

La corrente che il 7805 assorbe in ingresso è quasi uguale a quella che eroga in uscita; la differenza è solo una corrente di riposo di pochi milliampere. Per questo la potenza trasformata in calore nel regolatore è P = (Vin − Vout) · I, e il rendimento è circa Vout / Vin. Esempio: se alimenti un circuito da 500 mA con un alimentatore da 12 V, si sviluppano P = (12 − 5) × 0,5 = 3,5 W di calore. A fronte di 2,5 W che arrivano al carico se ne sprecano 3,5, e il rendimento è solo del 42 %. Alimenta lo stesso circuito a 7,5 V e la perdita scende a 1,25 W. In altre parole, una tensione di ingresso più alta del necessario serve solo a caricare il regolatore di calore in più. Per ripassare il legame tra corrente, tensione e potenza, dai un'occhiata all'articolo sulla legge di Ohm.

Come scegliere il dissipatore

La temperatura di giunzione si ricava da Tj = Tambiente + P · θ; θ (theta) è la resistenza termica, in °C/W. Un contenitore TO-220 senza dissipatore ha una resistenza termica giunzione-aria di 50–65 °C/W: 1 W di perdita porta il chip 50–65 °C sopra la temperatura ambiente. In un progetto sicuro la giunzione resta sotto i 125 °C, il che in una stanza a 25 °C significa al massimo circa 1,5 W senza dissipatore. Se l'interno del contenitore arriva a 50–60 °C, il limite scende a 1 W. Ogni caso della tabella precedente che supera 1 W dovrebbe farti pensare a un dissipatore.

Per potenze maggiori, calcola la resistenza termica del dissipatore: θtotale = θJC + θCS + θSA. Nel 7805, θJC (giunzione-contenitore) vale circa 5 °C/W e θCS (contenitore-dissipatore) con pasta termica circa 0,5–1 °C/W. Nell'esempio da 3,5 W, per tenere la giunzione a 110 °C in un contenitore a 40 °C serve θtotale ≤ (110 − 40) / 3,5 = 20 °C/W, quindi il dissipatore deve avere θSA ≤ 20 − 5 − 1 = 14 °C/W. I piccoli dissipatori a clip per TO-220 hanno di solito 20–30 °C/W e non bastano; serve un dissipatore alettato in alluminio di media grandezza. I produttori indicano questo valore in °C/W nei loro cataloghi.

• Usa la pasta termica: il sottile strato d'aria tra contenitore e dissipatore riduce molto il passaggio di calore; basta un velo di pasta.
• La linguetta è GND: nei 78xx la linguetta metallica è collegata a GND, quindi il dissipatore non va isolato e più 78xx possono condividerlo. Nei 79xx la linguetta è collegata all'ingresso e va isolata con un foglietto di mica e una rondella isolante.
• Non contare sulla protezione termica: un 7805 surriscaldato si spegne e si riaccende quando si raffredda. L'uscita si interrompe ogni pochi secondi e Arduino si resetta di continuo; è una protezione di ultima istanza, non un funzionamento normale.
• Dividi il calore: la soluzione più efficace è abbassare l'ingresso. Per ricavare 5 V da 24 V, scendi prima a 7–8 V con un convertitore buck e usa il 7805 solo come ultimo stadio.

La serie 78xx: 7805, 7809, 7812 e gli altri

Se ti serve una tensione regolabile, usa il cugino della famiglia, l'LM317: con due resistenze fornisce qualsiasi uscita da 1,25 a 37 V, data da Vout = 1,25 × (1 + R2 / R1) (R1 di solito è 240 Ω). Le regole su calore e dropout sono le stesse del 7805. Il 78M05 da 500 mA è la versione di media potenza che si vede spesso sulle schede a montaggio superficiale. Qualunque modello tu scelga, la regola non cambia: l'ingresso minimo deve superare l'uscita di circa 2–3 V.

LDO AMS1117-3.3: per i moduli a 3,3 V

ESP32, Raspberry Pi Pico, nRF24L01 e molti sensori funzionano a 3,3 V. Con un 7805 non puoi ottenere 3,3 V; la scelta più comune per questo è l'AMS1117-3.3. L'AMS1117 è un regolatore LDO (low dropout, a bassa caduta): a 800 mA il suo dropout è tipicamente di 1,1 V e al massimo di 1,3 V, quindi ricava senza problemi 3,3 V da 5 V. Può erogare fino a 1 A, accetta al massimo 15 V in ingresso e a riposo assorbe circa 5 mA. È anche il regolatore che abbassa i 5 V a 3,3 V sulla maggior parte delle schede di sviluppo ESP32.

Nel contenitore SOT-223 dell'AMS1117 la piedinatura è diversa da quella del 7805: 1: GND/ADJ, 2: Uscita, 3: Ingresso, e la linguetta grande è collegata all'uscita. Il datasheet consiglia un condensatore al tantalio da 22 µF in uscita per la stabilità; i moduli già pronti hanno condensatori da 10 µF e con carichi normali funzionano bene, ma se costruisci il tuo circuito metti 22 µF in uscita. È più sensibile al calore: la resistenza termica del SOT-223 va da 46 a 90 °C/W secondo l'area di rame sulla scheda, e il produttore non garantisce la regolazione oltre circa 1,2 W. Da 5 V a 3,3 V con 300 mA, P = 1,7 × 0,3 = 0,51 W, nessun problema; ma da 12 V a 3,3 V la stessa corrente significa 2,6 W e il modulo entra presto in protezione termica.

In un progetto che deve durare mesi a batteria, la corrente di riposo conta quanto il dropout: l'AMS1117 assorbe circa 5 mA anche quando non alimenta nulla, centinaia di volte il consumo di un ESP32 in deep sleep. Anche per ricavare 3,3 V da una singola cella Li-ion (3,0–4,2 V) la caduta di 1,1 V dell'AMS1117 è eccessiva: perfino con la cella carica a 4,2 V l'uscita si ferma intorno a 3,1 V e scende man mano che la batteria si scarica. In questi progetti si preferiscono LDO come l'MCP1700, con corrente di riposo nell'ordine dei microampere e meno di 0,2 V di dropout.

Lineare o switching (buck)?

Un regolatore switching buck (step-down) non brucia la tensione in eccesso sotto forma di calore: commuta l'ingresso decine di migliaia di volte al secondo e trasferisce l'energia all'uscita immagazzinandola in un induttore e in un condensatore. Così il rendimento sale all'80–95 % e la corrente prelevata in ingresso è minore di quella in uscita. Per esempio, i moduli basati sull'LM2596 forniscono un'uscita regolabile fino a 3 A da 4,5–40 V e commutano a 150 kHz. Il prezzo da pagare è un ripple di commutazione di qualche decina di millivolt in uscita, disturbi elettromagnetici e più componenti. La regolazione e il collegamento del modulo sono spiegati nell'articolo sul riduttore di tensione LM2596.

La regola pratica è questa: se la differenza tra ingresso e uscita è piccola (2–4 V) e la corrente resta sotto qualche centinaio di milliampere, un 7805 o un LDO è semplice, silenzioso ed economico. Se la differenza è grande, la corrente supera i 500 mA o il progetto va a batteria, scegli un convertitore buck. Quando alimenti misure analogiche, audio o sensori delicati è comune anche combinare i due: prima scendi a 7–8 V con un buck e poi ricavi 5 V poco rumorosi con un 7805. Così ottieni insieme rendimento e alimentazione pulita.

Il regolatore di bordo di Arduino e il limite di Vin

La tensione che applichi al jack DC o al pin Vin di Arduino Uno R3 passa attraverso un LDO da 5 V della famiglia 1117 montato sulla scheda (un NCP1117 sulla scheda originale, quasi sempre un AMS1117 sui cloni), e dietro il jack c'è un diodo tipo 4007 che protegge dall'inversione di polarità. Arduino consiglia 7–12 V, e il limite della scheda è 6–20 V. Il limite inferiore dipende dal dropout: diodo e regolatore insieme si mangiano circa 2 V, e sotto i 7 V la linea 5V cala. Quello superiore dipende dal calore: con 12 V su Vin e 200 mA di assorbimento, il piccolo regolatore SOT-223 dissipa (12 − 5) × 0,2 = 1,4 W e diventa troppo caldo da toccare. A 20 V lo stesso carico significa 3 W.

Puoi prelevare corrente anche dal pin 5V della scheda, ma quella corrente passa per lo stesso regolatore. Con l'alimentazione USB la linea 5V arriva direttamente dall'USB ed è limitata da un fusibile da 500 mA; alimentando dal jack, il limite lo fissa il calore del regolatore. Per questo è meglio alimentare carichi come servo, strisce LED o motori con un 7805 o un modulo buck separato, non dal pin 5V di Arduino, e unire le masse. Il pin 3.3V eroga solo 50 mA; per moduli assetati di corrente come l'ESP-01 o un nRF24L01 con antenna usa un AMS1117-3.3 separato. Per la posizione dei pin, leggi l'articolo sulla piedinatura di Arduino Uno.

Testare il regolatore con Arduino: ingresso, uscita e calore

Il codice qui sotto misura la tensione di ingresso e di uscita del 7805, scrive sul monitor seriale la differenza, la potenza dissipata e la temperatura di giunzione stimata, e ti avvisa quando ti avvicini al dropout o serve un dissipatore. La tensione di ingresso supera i 5 V e non può andare direttamente su un pin analogico: collega l'ingresso ad A0 tramite un partitore di tensione da 100 kΩ e 22 kΩ (misura fino a circa 27 V) e l'uscita ad A1 con due resistenze da 10 kΩ. Puoi verificare i rapporti per le tue resistenze con il calcolatore del partitore di tensione. Tutte le masse devono essere in comune.

1// 7805 test istasyonu: giriş, çıkış ve ısı / 7805 test bench: input, output and heat
2// Kart: Arduino Uno / Nano (ATmega328P) / Board: Arduino Uno / Nano (ATmega328P)
3
4const float R1_IN  = 100000.0;  // giriş bölücü üst direnç / input divider top resistor
5const float R2_IN  = 22000.0;   // giriş bölücü alt direnç / input divider bottom resistor
6const float R1_OUT = 10000.0;   // çıkış bölücü üst direnç / output divider top resistor
7const float R2_OUT = 10000.0;   // çıkış bölücü alt direnç / output divider bottom resistor
8
9const float LOAD_A    = 0.30;   // multimetreyle ölçtüğün yük akımı (A) / load current measured with a multimeter (A)
10const float THETA_JA  = 60.0;   // soğutucusuz TO-220, °C/W / TO-220 without heatsink, °C/W
11const float T_AMBIENT = 30.0;   // ortam sıcaklığı (°C) / ambient temperature (°C)
12const float DROPOUT_V = 2.0;    // 7805 için gereken en az fark (V) / minimum headroom for the 7805 (V)
13
14// Gerçek besleme gerilimini dahili 1,1 V referansla ölçer (mV)
15// Measures the real supply voltage with the internal 1.1 V reference (mV)
16long readVcc() {
17  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);  // referans AVcc, kanal 1,1 V / AVcc reference, 1.1 V channel
18  delay(2);                                               // referansın oturmasını bekle / let the reference settle
19  ADCSRA |= _BV(ADSC);                                    // dönüşümü başlat / start a conversion
20  while (bit_is_set(ADCSRA, ADSC));                       // bitmesini bekle / wait until it finishes
21  long raw = ADCL;                                        // önce ADCL okunmalı / ADCL must be read first
22  raw |= ADCH << 8;
23  return 1125300L / raw;                                  // 1,1 x 1023 x 1000
24}
25
26// Bölücünün arkasındaki gerçek gerilimi hesaplar / Calculates the real voltage behind a divider
27float readVolts(uint8_t pin, float vcc, float r1, float r2) {
28  analogRead(pin);                                        // ilk okumayı at / discard the first reading
29  long sum = 0;
30  for (int i = 0; i < 16; i++) sum += analogRead(pin);    // 16 örneğin ortalaması / average of 16 samples
31  float vPin = (sum / 16.0) * vcc / 1023.0;
32  return vPin * (r1 + r2) / r2;
33}
34
35void setup() {
36  Serial.begin(9600);
37}
38
39void loop() {
40  float vcc  = readVcc() / 1000.0;
41  float vin  = readVolts(A0, vcc, R1_IN, R2_IN);
42  float vout = readVolts(A1, vcc, R1_OUT, R2_OUT);
43
44  float headroom = vin - vout;                    // regülatör üzerindeki gerilim / voltage across the regulator
45  float heatW    = headroom * LOAD_A;             // P = (Vin - Vout) x I
46  float tj       = T_AMBIENT + heatW * THETA_JA;  // tahmini yonga sıcaklığı / estimated junction temperature
47  float eff      = (vin > 1.0) ? 100.0 * vout / vin : 0.0;  // verim (%) / efficiency (%)
48
49  Serial.print(F("Vin "));      Serial.print(vin, 2);
50  Serial.print(F(" V | Vout ")); Serial.print(vout, 2);
51  Serial.print(F(" V | Fark ")); Serial.print(headroom, 2);
52  Serial.print(F(" V | Isi "));  Serial.print(heatW, 2);
53  Serial.print(F(" W | Tj ~"));  Serial.print(tj, 0);
54  Serial.print(F(" C | Verim %")); Serial.println(eff, 0);
55
56  if (headroom < DROPOUT_V) Serial.println(F("UYARI: giris dusuk, dropout / WARNING: input too low, dropout"));
57  if (tj > 125.0)           Serial.println(F("UYARI: sogutucu gerekli / WARNING: heatsink required"));
58  delay(1000);
59}

Invece di dare per scontata la tensione di alimentazione che fa da riferimento alle letture analogiche, il codice la misura con la funzione readVcc(): legge il riferimento interno fisso di circa 1,1 V dell'ATmega328P e ne ricava la Vcc reale. Così le letture restano corrette sia che Arduino sia alimentato via USB sia dal 7805 stesso. Il metodo vale per le schede con ATmega328P come Uno e Nano; dato che il riferimento interno può variare di circa ±10 % da un chip all'altro, confronta una volta il risultato con il multimetro e correggi la costante 1125300. In LOAD_A scrivi la corrente di carico misurata con il multimetro; se hai montato un dissipatore, sostituisci THETA_JA con la resistenza termica totale del tuo calcolo.

ESP32: l'AMS1117 e i picchi di corrente del Wi-Fi

Le schede di sviluppo ESP32 abbassano i 5 V in ingresso a 3,3 V con un LDO di bordo. Normalmente la scheda assorbe 50–100 mA, ma durante la trasmissione Wi-Fi la corrente sale per un istante a circa 300 mA; per questo Espressif consiglia una sorgente in grado di fornire almeno 500 mA. Una sorgente debole, un cavo USB sottile e lungo o un regolatore caldo fanno crollare la linea 3V3 durante quel picco, e l'ESP32 scrive "Brownout detector was triggered" sul monitor seriale e si riavvia. Il codice qui sotto ti dice se l'ultimo riavvio è stato causato da un brownout e registra la tensione più bassa che la linea 3V3 vede durante la connessione al Wi-Fi. Collega il pin 3V3 al GPIO 34 tramite un partitore di due resistenze da 10 kΩ.

1// ESP32: 3V3 hattını ve brownout resetini izle / ESP32: watch the 3V3 rail and brownout resets
2#include <WiFi.h>
3#include "esp_system.h"
4
5const char* WIFI_SSID = "AgAdi";   // Wi-Fi ağ adı / Wi-Fi network name
6const char* WIFI_PASS = "Sifre";   // Wi-Fi şifresi / Wi-Fi password
7const int SENSE_PIN = 34;          // 3V3 -> 10k -> GPIO34 -> 10k -> GND (yalnız giriş, ADC1) / input-only ADC1 pin
8
9int minMv = 9999;                  // görülen en düşük gerilim (mV) / lowest voltage seen (mV)
10
11int rail3v3() {
12  return analogReadMilliVolts(SENSE_PIN) * 2;  // bölücü yarıya indirir / the divider halves it
13}
14
15void setup() {
16  Serial.begin(115200);
17  delay(300);
18  if (esp_reset_reason() == ESP_RST_BROWNOUT) {
19    Serial.println("Son reset: BROWNOUT, besleme yetersiz / Last reset: BROWNOUT, weak supply");
20  }
21  Serial.printf("Wi-Fi oncesi 3V3: %d mV\n", rail3v3());
22
23  WiFi.begin(WIFI_SSID, WIFI_PASS);
24  unsigned long t0 = millis();
25  while (WiFi.status() != WL_CONNECTED && millis() - t0 < 15000) {
26    int mv = rail3v3();                        // bağlanırken sürekli ölç / keep sampling while connecting
27    if (mv < minMv) minMv = mv;
28    delay(1);
29  }
30  Serial.printf("Baglanirken en dusuk 3V3: %d mV\n", minMv);
31}
32
33void loop() {
34  int mv = rail3v3();
35  if (mv < minMv) minMv = mv;
36  Serial.printf("3V3: %d mV | en dusuk / min: %d mV\n", mv, minMv);
37  delay(1000);
38}

Se il minimo durante la connessione scende sotto 3,0 V, l'alimentazione non è sufficiente. L'ADC non cattura tutti i cali brevissimi, ma mostra chiaramente la tendenza. Di solito la soluzione è semplice: un cavo USB corto e spesso, un condensatore elettrolitico da 470 µF tra 5V e GND vicino alla scheda, oppure una sorgente che fornisca almeno 500 mA. Se vuoi alimentare l'ESP32 da 12 V, non dare i 12 V all'AMS1117 della scheda; abbassali prima a 5 V con un modulo buck. Per una diagnosi dettagliata, leggi l'articolo sugli errori brownout e Guru Meditation dell'ESP32.

Raspberry Pi Pico: VSYS e il 7805

Il Raspberry Pi Pico ha un efficiente convertitore buck-boost al posto di un regolatore lineare, e il suo pin VSYS accetta qualsiasi tensione tra 1,8 e 5,5 V. Per far funzionare un Pico in un sistema a 12 V puoi collegare l'uscita del 7805 a VSYS; se userai anche l'USB nello stesso momento, metti in mezzo un diodo Schottky come l'1N5819, altrimenti i 5 V dell'USB e il 7805 lavoreranno uno contro l'altro. Non collegare mai l'uscita del 7805 al pin 3V3; quel pin non sopporta più di 3,3 V. Il codice MicroPython qui sotto misura l'ingresso del 7805 tramite un partitore su GP26 e VSYS tramite il canale GP29 della scheda.

1# Pico: 7805 girişini ve VSYS'i ölç / Pico: measure the 7805 input and VSYS
2from machine import ADC
3import time
4
5adc_in = ADC(26)            # GP26 (ADC0): 100k/22k bölücü / 100k/22k divider
6adc_vsys = ADC(29)          # GP29 (ADC3): kart üzerinde VSYS/3 / VSYS/3 on the board
7
8K_IN = (100 + 22) / 22      # bölücü oranı (~5,55) / divider ratio (~5.55)
9V_OUT = 5.0                 # 7805 çıkışı (V) / 7805 output (V)
10LOAD_A = 0.30               # ölçtüğün yük akımı (A) / load current you measured (A)
11
12def volts(adc, ratio, n=16):
13    total = 0
14    for _ in range(n):
15        total += adc.read_u16()          # 0-65535 arası ham değer / raw value 0-65535
16    return total / n * 3.3 / 65535 * ratio
17
18while True:
19    vin = volts(adc_in, K_IN)
20    vsys = volts(adc_vsys, 3)
21    heat = (vin - V_OUT) * LOAD_A        # P = (Vin - Vout) x I
22    print("Vin {:.2f} V | VSYS {:.2f} V | 7805 isi {:.2f} W".format(vin, vsys, heat))
23    if vin - V_OUT < 2.0:
24        print("UYARI: dropout / WARNING: dropout")
25    time.sleep(1)

L'ADC del Pico legge al massimo 3,3 V, quindi con il partitore 100k/22k puoi misurare fino a circa 18 V. Il valore di VSYS risulta un po' più basso dell'uscita del 7805 per la caduta di circa 0,3 V del diodo Schottky; è normale. Sul Pico W il GP29 è condiviso con il chip wireless e la misura di VSYS richiede impostazioni aggiuntive; in quel caso usa solo la lettura su GP26. Se sei alle prime armi con il Pico, l'articolo Cos'è il Raspberry Pi Pico? è un buon punto di partenza.

Idee di progetto con il 7805 e altri regolatori

• Alimentatore da banco a 5 V: costruisci una scatoletta con un alimentatore da 12 V, un 7805, un dissipatore e un interruttore che dia 5 V stabili ai tuoi progetti su breadboard.
• Alimentatore con indicatore di tensione e calore: porta il codice di prova qui sopra su un display LCD e mostra in tempo reale ingresso, uscita e perdite; il principio di misura è spiegato nell'articolo su come costruire un voltmetro con Arduino.
• Arduino in auto: abbassa i 12–14,4 V della batteria prima a 7–8 V con un buck e poi a 5 V con un 7805; aggiungi un diodo TVS in ingresso contro i picchi di tensione del veicolo.
• Striscia LED a 12 V e controllo con relè: alimenta la striscia direttamente a 12 V, e Arduino e il modulo relè dall'uscita del 7805.
• Linea separata per servo e NeoPixel: alimenta i servomotori e i LED WS2812B da una linea a 5 V separata con massa comune, usando un 7805 sotto 1 A e un buck oltre.
• Scheda sensori a 3,3 V: alimenta moduli a 3,3 V come BME280 e nRF24L01 con un AMS1117-3.3, indipendentemente da Arduino; per i livelli dei segnali usa un convertitore di livelli logici.

Errori comuni e soluzioni

Con la giusta tensione di ingresso, due piccoli condensatori e un dissipatore quando serve, il 7805 è uno dei componenti più affidabili dell'elettronica e funziona per anni. Ricorda la regola: più grande è la differenza tra ingresso e uscita, più calore. Per grandi differenze scegli un buck, per i 3,3 V un AMS1117 e per una lunga durata a batteria un LDO con bassa corrente di riposo. Nell'app BlueGrays trovi il voltmetro digitale con LCD, l'auto L298N comandata via Bluetooth, il robot che evita gli ostacoli, la stazione di irrigazione intelligente e i progetti ESP32 in deep sleep, con schemi e codice passo dopo passo, e puoi costruire da solo la loro alimentazione con i calcoli di questa guida.