Cos'è un condensatore? Tipi, codice 104 e costante di tempo RC

Il condensatore è un componente di base che immagazzina carica elettrica tra due armature conduttive che non si toccano e la restituisce molto rapidamente quando serve. Puoi pensarlo come un piccolo serbatoio di energia, ma velocissimo: fornisce carica quando la tensione cala, assorbe i picchi improvvisi, blocca la corrente continua (DC) una volta carico e invece lascia passare la corrente alternata (AC) e i disturbi. Anche su un Arduino Uno ci sono molti condensatori; servono a stabilizzare l'alimentazione, eliminare i rimbalzi dei pulsanti, generare temporizzazioni e trasformare un segnale PWM in una tensione regolare.

In questa guida imparerai come funziona un condensatore, le unità pF, nF e µF, la differenza tra condensatori ceramici, elettrolitici e al tantalio, come leggere polarità e tensione di lavoro, cosa significano codici come 104, la costante di tempo RC (τ = R·C) e come collegare i condensatori in serie e in parallelo. Alla fine faremo con Arduino, ESP32 e Raspberry Pi Pico un esperimento che traccia la curva di carica di un condensatore e ne misura la capacità.

Cos'è un condensatore e come funziona?

All'interno di ogni condensatore ci sono due superfici conduttive separate da uno strato isolante chiamato dielettrico. Quando applichi una tensione ai suoi capi, gli elettroni si accumulano su un'armatura e vengono sottratti all'altra; tra le armature si forma un campo elettrico e l'energia viene immagazzinata in quel campo. La carica immagazzinata si calcola con Q = C · V, dove C è la capacità in farad e V la tensione in volt. L'energia immagazzinata vale E = ½ · C · V²; per esempio, un condensatore da 1000 µF caricato a 16 V contiene 0,128 joule. Corrente e tensione sono legate da I = C · ΔV/Δt: il condensatore si oppone alle variazioni brusche della propria tensione ed è per questo che livella le fluttuazioni.

Puoi immaginare un condensatore come un serbatoio d'acqua: quando è vuoto si riempie in fretta, poi il flusso rallenta man mano che si riempie, fino a fermarsi. Per questo in un circuito in continua, una volta carico, il condensatore non lascia più passare corrente. Al crescere della frequenza, invece, si oppone sempre meno alla corrente; questa opposizione si chiama reattanza capacitiva e si calcola con Xc = 1 / (2π · f · C). Un condensatore da 100 nF presenta circa 1,6 kΩ a 1 kHz, ma solo 0,16 Ω a 10 MHz. In altre parole, per i disturbi ad alta frequenza è quasi un cortocircuito, ed è tutto qui il segreto dei condensatori di disaccoppiamento.

Unità di capacità: pF, nF e µF

Il farad è un'unità enorme, perciò in elettronica si usano quasi sempre i suoi sottomultipli. La conversione è semplice: ogni passaggio vale un fattore 1000. 1 µF = 1000 nF = 1.000.000 pF, quindi 0,1 µF, 100 nF e 100.000 pF sono lo stesso valore. Quando il simbolo µ non è disponibile si scrive una u (10uF), e negli schemi vecchi puoi trovare MFD per microfarad. I valori che incontrerai più spesso nei progetti Arduino sono 22 pF, 100 nF (0,1 µF), 10 µF, 100 µF e 1000 µF.

Tipi di condensatori: ceramici, elettrolitici, al tantalio e altri

• Ceramico: Piccolo, economico e non polarizzato. La sua resistenza interna (ESR) è molto bassa, quindi è il migliore per filtrare i disturbi veloci. La stabilità dipende dal dielettrico: C0G (NP0) è molto stabile, X7R è buono, mentre Y5V può perdere più di metà del suo valore con la temperatura e la tensione applicata.
• Elettrolitico in alluminio: Offre grande capacità in poco volume, ma è polarizzato e il liquido interno si secca col tempo. Sul corpo sono indicati un limite di 85 °C o 105 °C e la durata a quella temperatura (es. 2000 ore); come regola pratica, ogni 10 °C in meno la durata raddoppia.
• Tantalio: Più piccolo e stabile di un elettrolitico dello stesso valore, ma sensibile alla tensione inversa e ai picchi di corrente; quando si guasta può andare in cortocircuito e bruciare. Scegline uno con tensione di lavoro almeno doppia rispetto a quella del circuito.
• A film: Non polarizzato, stabile e a basse perdite; si usa nei circuiti audio, nelle temporizzazioni precise e nei filtri di rete a 230 V (classe X2). Lo svantaggio è che i valori grandi sono ingombranti.
• Supercondensatore: Ha capacità nell'ordine dei farad, ma sopporta solo circa 2,7 V per cella. Non immagazzina tanta energia quanto una batteria; in compenso si carica e si scarica in pochi secondi e regge centinaia di migliaia di cicli.

Come leggere la polarità (+/−) e la tensione di lavoro

• Elettrolitico a reofori: Il terminale lungo è il positivo (+), quello corto il negativo (−). La striscia chiara sull'involucro riporta dei segni meno e indica il lato negativo. Se i terminali sono stati tagliati, affidati alla striscia.
• Elettrolitico SMD (a barilotto): La mezzaluna nera o colorata sulla parte superiore indica il lato negativo.
• Tantalio: Attenzione, qui la regola è al contrario: la striscia o la linea su un condensatore al tantalio indica il terminale positivo.
• Ceramici e a film: Non sono polarizzati; si possono montare in entrambi i versi.
• Negli schemi: Un condensatore non polarizzato si disegna con due linee dritte parallele. In quello polarizzato una delle armature è disegnata curva o piena e un segno + indica il lato positivo.

La tensione di lavoro stampata sul corpo (es. 16 V, 25 V, 50 V) è la tensione continua massima che il condensatore sopporta in modo permanente, e non va mai superata. La regola sicura è scegliere un condensatore con almeno 1,5–2 volte la tensione più alta del circuito: 10 V o 16 V in un circuito Arduino a 5 V, 25 V con un alimentatore da 12 V e 35 V o 50 V a 24 V. Usare una tensione più alta del necessario non ha controindicazioni; il componente è solo più grande e un po' più costoso.

Leggere il codice di un condensatore: cosa significa 104?

Per risparmiare spazio, i condensatori ceramici e a film riportano il valore con un codice a tre cifre. L'unità è sempre il picofarad: le prime due cifre sono il numero e la terza indica quanti zeri aggiungere. Quindi 104 = 10 seguito da 4 zeri = 100.000 pF = 100 nF = 0,1 µF. I codici a due cifre indicano direttamente il valore in pF (22 = 22 pF) e, se la terza cifra è 0, non si aggiunge alcuno zero (220 = 22 pF). Nella notazione con lettera, la lettera fa sia da unità sia da virgola: 4n7 = 4,7 nF, 2p2 = 2,2 pF. Per decifrarlo al volo usa lo strumento Codice condensatore.

La lettera dopo il codice indica la tolleranza: J = ±5%, K = ±10%, M = ±20%, Z = +80% / −20%. Sui condensatori a film può esserci anche un codice di tensione davanti; per esempio 2A104J significa 100 V (2A), 100 nF (104) e ±5% (J). I codici di tensione più comuni sono 1C = 16 V, 1H = 50 V, 2A = 100 V e 2J = 630 V. Gli elettrolitici non usano codici: il valore è stampato in chiaro (470 µF 16 V). I condensatori ceramici SMD, invece, di solito non hanno alcuna marcatura, quindi puoi conoscerne il valore solo dalla confezione o misurandoli.

Carica, scarica e costante di tempo RC (τ = R·C)

Quando carichi un condensatore attraverso una resistenza, la sua tensione non sale di colpo ma segue una curva esponenziale: Vc = Vs · (1 − e^(−t/RC)) (Vs è la tensione della sorgente, t il tempo trascorso). In scarica scende con lo stesso ritmo: Vc = V0 · e^(−t/RC). Il prodotto R·C si chiama costante di tempo e si indica con τ (tau); ohm per farad danno secondi. Per esempio, con una resistenza da 10 kΩ e un condensatore da 100 µF, τ = 10.000 × 0,0001 = 1 secondo. Con 1 kΩ e 100 nF, τ è di appena 0,1 millisecondi.

In pratica un condensatore si considera completamente carico o scarico dopo circa 5τ; nell'esempio con 10 kΩ e 100 µF sono 5 secondi. Questo comportamento è alla base dei temporizzatori, dei circuiti antirimbalzo per pulsanti, delle lampade che si spengono lentamente e dell'integrato 555. Per ripassare i valori delle resistenze leggi Cos'è una resistenza?, e per vedere come cambia la curva con altri valori di R e C prova lo strumento Costante di tempo RC. Il legame tra tensione, corrente e resistenza è spiegato nei dettagli in La legge di Ohm.

Filtraggio e disaccoppiamento: perché c'è un 100 nF accanto a ogni integrato?

Microcontrollori e altri integrati assorbono brevissimi impulsi di corrente, di pochi nanosecondi, a ogni fronte di clock. Se l'alimentatore è lontano, l'induttanza dei fili non riesce a stare dietro a queste richieste improvvise; sull'alimentazione compaiono piccoli cali e disturbi, con il risultato di reset casuali, letture analogiche inaffidabili o blocchi. La soluzione è mettere un condensatore ceramico da 100 nF tra i pin VCC e GND di ogni integrato, il più vicino possibile. Funziona come un minuscolo serbatoio di energia proprio accanto al chip e cortocircuita verso GND i disturbi ad alta frequenza. Si chiama condensatore di disaccoppiamento (decoupling) o di bypass. Per variazioni di carico lente e ampie si aggiunge all'ingresso dell'alimentazione un elettrolitico da 10–1000 µF (condensatore di bulk o serbatoio).

• 100 nF per ogni integrato: Tra VCC e GND, con terminali corti e il più vicino possibile al pin di alimentazione del chip.
• Regolatori lineari come il 7805: Il produttore consiglia 0,33 µF in ingresso e 0,1 µF in uscita; in pratica in uscita si aggiungono spesso anche 10–100 µF. Dettagli in Regolatore di tensione 7805.
• Servomotori: 100–470 µF sull'alimentazione del servo, vicino al servo stesso, aiutano a evitare che Arduino si resetti quando il servo si muove (Cos'è un servomotore?).
• Strisce LED WS2812B: Si consiglia un condensatore da 500–1000 µF, almeno 6,3 V, tra i morsetti + e − dell'alimentatore (WS2812B NeoPixel).
• Motori in corrente continua: Un ceramico da 100 nF saldato direttamente sui morsetti del motore riduce molto i disturbi elettrici prodotti dalle spazzole (Motore DC con L298N).
• Moduli wireless: Durante la trasmissione la corrente sale di colpo. Aggiungere 10 µF sui pin di alimentazione dell'nRF24L01 e 100–470 µF tra 3,3 V e GND sull'ESP32 riduce le disconnessioni e i reset da brownout.

Collegando una resistenza e un condensatore in serie ottieni un filtro passa-basso: lascia passare le frequenze al di sotto di una certa soglia e attenua quelle sopra. La frequenza di taglio è fc = 1 / (2π · R · C). L'uscita PWM di Arduino Uno è un'onda quadra a 490 Hz (980 Hz sui pin 5 e 6); con un filtro da 10 kΩ e 10 µF (fc ≈ 1,6 Hz) quell'onda diventa una tensione continua quasi piatta, e ottieni così una semplice uscita analogica. Il prezzo è il tempo di risposta: con τ = 0,1 s serve circa mezzo secondo per assestarsi su un nuovo valore. Approfondisci in Cos'è il PWM?. Anche un alimentatore raddrizzato si filtra con un grosso condensatore di livellamento, e il ripple residuo vale circa ΔV ≈ I / (f · C): con 1 A di carico, raddrizzamento a doppia semionda a 100 Hz e 4700 µF, circa 2,1 V.

Collegare i condensatori in serie e in parallelo

Le formule dei condensatori sono esattamente l'opposto di quelle delle resistenze. In parallelo le capacità si sommano: C = C1 + C2 + … e la tensione di lavoro è quella del componente più debole. In serie la capacità totale è addirittura minore di quella del condensatore più piccolo: 1/C = 1/C1 + 1/C2 + … Due condensatori uguali in serie danno metà capacità e, sulla carta, le loro tensioni si sommano; ma poiché le correnti di dispersione non sono uguali, la tensione si ripartisce in modo diseguale, perciò su ciascuno si mette in parallelo una resistenza di bilanciamento dello stesso valore (es. 100 kΩ). Se non hai il valore che ti serve, puoi ottenerlo combinando due condensatori; fai il calcolo con lo strumento Serie / parallelo C e consulta calcolo di resistenze in serie e parallelo per l'equivalente con le resistenze.

Esperimento con Arduino: curva di carica e misura della capacità

Il modo migliore per vedere la teoria con i tuoi occhi è misurare la tensione di un condensatore mentre si carica. Un pin digitale di Arduino caricherà il condensatore attraverso una resistenza da 10 kΩ e un ingresso analogico leggerà la sua tensione. Il tempo necessario per raggiungere il 63,2% della tensione della sorgente è un τ, e da lì calcoliamo la capacità con C = τ / R. Ti servono: un Arduino Uno, un condensatore elettrolitico da 100 µF, una resistenza da 10 kΩ, una breadboard e qualche cavetto jumper.

1. Inserisci il condensatore nella breadboard: il terminale + in una fila, il − sulla linea di GND.
2. Collega un capo della resistenza da 10 kΩ a D8 e l'altro alla fila in cui si trova il terminale + del condensatore.
3. Porta un cavetto dalla stessa fila ad A0 e collega il GND di Arduino alla linea di GND della breadboard.
4. Carica il codice qui sotto e apri il Monitor seriale a 115200 baud.
5. Il codice prima scarica il condensatore, poi lo carica; ogni 20 ms stampa il tempo trascorso e la tensione, e alla fine mostra il τ misurato e la capacità.
6. Per vedere la curva come grafico, imposta PLOT a true nel codice, caricalo di nuovo e apri Strumenti > Plotter seriale.

1// Kondansatör şarj eğrisi ve kapasite ölçümü / Capacitor charge curve and capacitance meter
2const int CHARGE_PIN = 8;       // 10 kΩ direnç bu pinden beslenir / the 10 kΩ resistor is driven from this pin
3const int SENSE_PIN = A0;       // kondansatörün + bacağı / capacitor + leg
4const float R_OHM = 10000.0;    // şarj direnci (ohm) / charge resistor (ohms)
5const float VREF = 5.0;         // Uno ADC referansı / Uno ADC reference
6const bool PLOT = false;        // true: Seri Çizici için yalnız gerilim / true: voltage only for the Serial Plotter
7
8void setup() {
9  Serial.begin(115200);
10  pinMode(CHARGE_PIN, OUTPUT);
11}
12
13void loop() {
14  // 1) Boşalt: pin LOW, kondansatör direnç üzerinden boşalır / discharge through the resistor
15  digitalWrite(CHARGE_PIN, LOW);
16  while (analogRead(SENSE_PIN) > 4) { }           // ~20 mV altı; ADC ofsetine pay bırak / below ~20 mV, leaves room for ADC offset
17  delay(1000);                                  // kalan yükü de boşalt / drain what is left
18
19  // 2) Şarj et, eğriyi yazdır, τ'yu yakala / charge, print the curve, catch τ
20  unsigned long t0 = millis();
21  unsigned long lastPrint = 0;
22  unsigned long tauMs = 0;
23  digitalWrite(CHARGE_PIN, HIGH);
24  while (true) {
25    int raw = analogRead(SENSE_PIN);
26    unsigned long t = millis() - t0;
27    if (tauMs == 0 && raw >= 647) tauMs = t;     // 1023 x 0,632 = 647 → bir τ / one τ
28    if (t - lastPrint >= 20) {                   // 20 ms'de bir yazdır / print every 20 ms
29      lastPrint = t;
30      float v = raw * VREF / 1023.0;
31      if (!PLOT) {
32        Serial.print(t);
33        Serial.print('\t');
34      }
35      Serial.println(v, 3);
36    }
37    if (raw >= 1010 || t > 60000) break;         // ~%99 dolu ya da zaman aşımı / ~99% full or timeout
38  }
39
40  // 3) Sonuç: C = τ / R / result: C = τ / R
41  if (!PLOT) {
42    float uF = (tauMs / 1000.0) / R_OHM * 1000000.0;
43    Serial.print(F("tau = "));
44    Serial.print(tauMs);
45    Serial.print(F(" ms   C = "));
46    Serial.print(uF, 1);
47    Serial.println(F(" uF"));
48  }
49  delay(3000);
50}

Ecco come funziona il codice: con il pin a LOW, il condensatore si scarica attraverso la stessa resistenza da 10 kΩ. Appena il pin passa a HIGH, millis() inizia a contare; quando la lettura analogica arriva a 647 (il 63,2% di 1023), il tempo trascorso viene salvato come τ. Quando la lettura raggiunge 1010 (circa il 99%), la carica si considera completata. Con 100 µF e 10 kΩ dovresti vedere circa 1000 ms e 100 µF. Gli elettrolitici hanno di solito una tolleranza di ±20%, quindi risultati tra 80 e 120 µF sono normali. Per saperne di più sulla misura del tempo, leggi millis e delay.

Lo stesso esperimento con ESP32 e Raspberry Pi Pico

Sull'ESP32 i pin lavorano a 3,3 V e l'ADC è a 12 bit (0–4095). L'ADC dell'ESP32 non è lineare vicino agli estremi della scala, perciò invece dei valori grezzi usiamo analogReadMilliVolts(), che restituisce millivolt calibrati. Come pin di misura abbiamo scelto il GPIO 34 del gruppo ADC1, che non risente del Wi-Fi. Poiché l'ADC non misura in modo affidabile oltre circa 3,1 V, riconosciamo la fine della carica dal tempo e non dalla tensione: trovato τ, la misura termina dopo 5τ. Per le basi, leggi Cos'è l'ESP32?.

1// ESP32 ile kondansatör şarj eğrisi / Capacitor charge curve with ESP32
2const int CHARGE_PIN = 25;      // 10 kΩ direnç bu pinden beslenir / the 10 kΩ resistor is driven from this pin
3const int SENSE_PIN = 34;       // ADC1, yalnız giriş / ADC1, input only
4const float R_OHM = 10000.0;    // şarj direnci (ohm) / charge resistor (ohms)
5
6void setup() {
7  Serial.begin(115200);
8  pinMode(CHARGE_PIN, OUTPUT);
9}
10
11void loop() {
12  digitalWrite(CHARGE_PIN, LOW);                       // boşalt / discharge
13  unsigned long d0 = millis();
14  // ADC ~150 mV altını okuyamaz, 200 mV'a inmesini bekle / the ADC cannot read below ~150 mV, wait for 200 mV
15  while (analogReadMilliVolts(SENSE_PIN) > 200 && millis() - d0 < 60000) { }
16  delay(millis() - d0 + 1000);                         // aynı süre kadar daha bekle / wait as long again
17
18  unsigned long t0 = millis();
19  unsigned long tauMs = 0;
20  digitalWrite(CHARGE_PIN, HIGH);                      // şarj et / charge
21  while (true) {
22    unsigned long t = millis() - t0;
23    uint32_t mv = analogReadMilliVolts(SENSE_PIN);     // kalibre edilmiş mV / calibrated mV
24    if (tauMs == 0 && mv >= 2086) tauMs = t;           // 3300 mV x 0,632 → bir τ / one τ
25    Serial.println(mv);                                // Seri Çizici için / for the Serial Plotter
26    if ((tauMs > 0 && t >= 5 * tauMs) || t > 60000) break;   // 5τ ≈ %99 dolu / 5τ ≈ 99% full
27    delay(20);
28  }
29  Serial.printf("tau = %lu ms   C = %.1f uF\n", tauMs, tauMs / 1000.0 / R_OHM * 1000000.0);
30  delay(3000);
31}

Sul Raspberry Pi Pico lo stesso esperimento richiede poche righe di MicroPython. Gli ingressi analogici del Pico sono GP26, GP27 e GP28; read_u16() restituisce la misura a 12 bit scalata nell'intervallo 0–65535. Il codice stampa su ogni riga il tempo trascorso e la tensione, così puoi copiare l'output in un foglio di calcolo e tracciare la curva da solo. Se non sai ancora come installare MicroPython sul Pico, inizia da Cos'è il Raspberry Pi Pico?.

1# Pico ile kondansatör şarj eğrisi / Capacitor charge curve with Pico
2from machine import Pin, ADC
3import time
4
5charge = Pin(15, Pin.OUT)       # 10 kΩ direnç bu pinden beslenir / resistor driven from this pin
6adc = ADC(26)                   # GP26 = ADC0, kondansatörün + bacağı / capacitor + leg
7R = 10000                       # şarj direnci (ohm) / charge resistor (ohms)
8
9def volts():
10    return adc.read_u16() * 3.3 / 65535
11
12charge.value(0)                 # önce boşalt / discharge first
13d0 = time.ticks_ms()
14while volts() > 0.1 and time.ticks_diff(time.ticks_ms(), d0) < 60000:
15    pass                        # ADC sıfırda birkaç on mV gösterebilir / the ADC may read a few tens of mV at 0 V
16time.sleep_ms(time.ticks_diff(time.ticks_ms(), d0) + 1000)   # aynı süre kadar daha bekle / wait as long again
17
18t0 = time.ticks_ms()
19charge.value(1)                 # şarjı başlat / start charging
20tau = None
21while True:
22    t = time.ticks_diff(time.ticks_ms(), t0)
23    v = volts()
24    if tau is None and v >= 3.3 * 0.632:    # 2,086 V → bir τ / one τ
25        tau = t
26    print(t, round(v, 3))
27    if (tau is not None and t >= 5 * tau) or t > 60000:
28        break
29    time.sleep_ms(20)
30
31if tau is not None:
32    print("tau =", tau, "ms  C =", round(tau / 1000 / R * 1e6, 1), "uF")

Idee di progetti con i condensatori

• Antirimbalzo hardware: Metti 100 nF – 1 µF ai capi del pulsante; insieme a una resistenza di pull-up da 10 kΩ si forma un filtro con τ = 1–10 ms e i rimbalzi si spengono prima di arrivare al codice.
• Tensione analogica dal PWM: Con un filtro RC trasforma un'uscita PWM in una tensione regolare tra 0 e 5 V e misurala con il multimetro.
• LED lampeggiante con il 555: Nel timer 555 due resistenze e un condensatore fissano la frequenza: f ≈ 1,44 / ((R1 + 2·R2) · C). Calcola i valori con lo strumento Timer 555.
• Lampada che si spegne lentamente: Dopo l'interruttore, metti un condensatore da 1000 µF in parallelo all'alimentazione del LED e della sua resistenza; quando togli corrente con l'interruttore, il LED non si spegne di colpo ma si affievolisce man mano che il condensatore si scarica. Resistenza e capacità insieme determinano la durata.
• Sensori capacitivi: Un sensore capacitivo di umidità del terreno misura la capacità che cambia con l'acqua nel terreno; poiché gli elettrodi non sono esposti, non si corrode.
• Capacimetro semplice: Unisci l'esperimento qui sopra a un display LCD I2C e mostra sullo schermo il valore dei tuoi condensatori.

Errori comuni e soluzioni

• Credere che 104 sia 104 µF: 104 vale 100 nF; i codici a tre cifre sono sempre in picofarad.
• Montare un elettrolitico al contrario: Il condensatore si scalda, si gonfia o scoppia; il terminale dal lato della striscia va verso GND (nel tantalio la striscia indica il positivo).
• Scegliere una tensione di lavoro troppo bassa: Un condensatore da 10 V su una linea a 12 V si guasta presto; lascia un margine di almeno 1,5–2 volte.
• Mettere il condensatore di disaccoppiamento troppo lontano: A 10 cm dall'integrato, un 100 nF perde efficacia per via dell'induttanza dei fili; tieni corti i terminali e mettilo proprio accanto ai pin di alimentazione.
• Arduino si resetta quando parte un motore: La tensione di alimentazione cala per un istante; alimenta il motore separatamente, aggiungi 100–470 µF sull'alimentazione e collega insieme le masse (Perché Arduino si resetta da solo?).
• Errore "Failed to connect to ESP32: Timed out waiting for packet header" sull'ESP32: Su alcune schede il circuito di programmazione automatica sbaglia i tempi; aggiungere un condensatore da 1–10 µF tra EN e GND spesso elimina la necessità di premere il tasto BOOT.

Dopo resistenza e LED, il condensatore è il componente più fondamentale da conoscere; quando avrai capito τ = R·C e preso l'abitudine di mettere 100 nF accanto a ogni integrato, i tuoi circuiti funzioneranno in modo molto più stabile. Come passo successivo puoi passare all'induttore con Cos'è un induttore?. Nell'app BlueGrays trovi progetti di controllo LED con pulsante, misura della luce con LDR, dissolvenza di LED con PWM e WS2812B con schemi e codice passo dopo passo, così puoi provare subito in circuiti reali ciò che hai imparato sui condensatori.