Was ist ein Kondensator? Arten, 104-Code und RC-Zeitkonstante

Ein Kondensator ist ein grundlegendes Bauteil, das elektrische Ladung zwischen zwei sich nicht berührenden leitenden Platten speichert und bei Bedarf sehr schnell wieder abgibt. Stell ihn dir als kleinen, aber extrem schnellen Energiespeicher vor: Er liefert Ladung nach, wenn die Spannung einbricht, schluckt plötzliche Spitzen, sperrt Gleichstrom (DC), sobald er geladen ist, lässt aber Wechselstrom (AC) und Störungen durch. Schon auf einem Arduino Uno sitzen etliche Kondensatoren; sie beruhigen die Versorgungsspannung, entprellen Taster, bestimmen Zeiten und machen aus einem PWM-Signal eine glatte Spannung.

In diesem Leitfaden lernst du, wie ein Kondensator funktioniert, was die Einheiten pF, nF und µF bedeuten, worin sich Keramik-, Elektrolyt- und Tantalkondensatoren unterscheiden, wie du Polung und Spannungsfestigkeit abliest, was Aufdrucke wie 104 bedeuten, wie die RC-Zeitkonstante (τ = R·C) funktioniert und wie man Kondensatoren in Reihe und parallel schaltet. Zum Schluss bauen wir mit Arduino, ESP32 und Raspberry Pi Pico einen Versuch, der die Ladekurve aufzeichnet und die Kapazität misst.

Was ist ein Kondensator und wie funktioniert er?

In jedem Kondensator befinden sich zwei leitende Flächen, getrennt durch eine isolierende Schicht, das Dielektrikum. Legst du eine Spannung an, sammeln sich auf einer Platte Elektronen, von der anderen werden Elektronen abgezogen; zwischen den Platten entsteht ein elektrisches Feld, in dem die Energie gespeichert wird. Die gespeicherte Ladung berechnet sich mit Q = C · U, wobei C die Kapazität in Farad und U die Spannung in Volt ist. Die gespeicherte Energie beträgt E = ½ · C · U²; ein auf 16 V geladener 1000-µF-Kondensator speichert zum Beispiel 0,128 Joule. Strom und Spannung hängen über I = C · ΔU/Δt zusammen: Ein Kondensator wehrt sich gegen schnelle Spannungsänderungen und glättet deshalb Schwankungen.

Du kannst dir einen Kondensator wie einen Wassertank vorstellen: Leer füllt er sich schnell, je voller er wird, desto langsamer fließt es nach, bis der Fluss ganz stoppt. Deshalb fließt in einem Gleichstromkreis kein Strom mehr durch den Kondensator, sobald er geladen ist. Mit steigender Frequenz setzt er dem Strom dagegen immer weniger Widerstand entgegen; diesen Widerstand nennt man kapazitiven Blindwiderstand, berechnet mit Xc = 1 / (2π · f · C). Ein 100-nF-Kondensator hat bei 1 kHz etwa 1,6 kΩ, bei 10 MHz aber nur noch 0,16 Ω. Für hochfrequente Störungen ist er also fast ein Kurzschluss, und genau darauf beruht die Wirkung von Abblockkondensatoren.

Kapazitätseinheiten: pF, nF und µF

Ein Farad ist eine riesige Einheit, deshalb verwendet die Elektronik fast immer kleine Bruchteile davon. Die Umrechnung ist einfach: Jede Stufe ist Faktor 1000. 1 µF = 1000 nF = 1.000.000 pF, also sind 0,1 µF, 100 nF und 100.000 pF derselbe Wert. Wenn kein µ verfügbar ist, schreibt man stattdessen u (10uF); auf alten Schaltplänen findest du für Mikrofarad manchmal MFD. Die häufigsten Werte in Arduino-Projekten sind 22 pF, 100 nF (0,1 µF), 10 µF, 100 µF und 1000 µF.

Kondensatorarten: Keramik, Elko, Tantal und mehr

• Keramik: Klein, günstig und ungepolt. Ihr Innenwiderstand (ESR) ist sehr niedrig, deshalb filtern sie schnelle Störungen am besten. Die Stabilität hängt vom Dielektrikum ab: C0G (NP0) ist sehr stabil, X7R gut, während Y5V durch Temperatur und angelegte Spannung mehr als die Hälfte seiner Kapazität verlieren kann.
• Aluminium-Elko: Viel Kapazität auf kleinem Raum, aber gepolt, und der flüssige Elektrolyt trocknet mit der Zeit aus. Auf dem Gehäuse stehen eine Grenze von 85 °C oder 105 °C und die Lebensdauer bei dieser Temperatur (z. B. 2000 Stunden); als Faustregel verdoppelt sich die Lebensdauer pro 10 °C weniger.
• Tantal: Kleiner und stabiler als ein Elko gleicher Kapazität, aber empfindlich gegen Verpolung und Stromstöße; im Fehlerfall kann er durchlegieren und abbrennen. Wähle mindestens die doppelte Betriebsspannung als Nennspannung.
• Folie: Ungepolt, stabil und verlustarm; eingesetzt in Audioschaltungen, präzisen Zeitgliedern und 230-V-Netzfiltern (Klasse X2). Nachteil: Große Werte sind sperrig.
• Superkondensator: Kapazität im Farad-Bereich, aber nur etwa 2,7 V pro Zelle. Er speichert weniger Energie als ein Akku, lässt sich dafür in Sekunden laden und entladen und übersteht hunderttausende Zyklen.

Polung (+/−) und Spannungsfestigkeit ablesen

• Bedrahteter Elko: Das lange Bein ist Plus (+), das kurze Minus (−). Der helle Streifen auf der Hülle trägt Minuszeichen und markiert die Minusseite. Sind die Beine gekürzt, richte dich nach dem Streifen.
• SMD-Elko (Becherbauform): Der schwarze oder farbige Halbmond auf der Oberseite markiert den Minuspol.
• Tantal: Achtung, hier ist es umgekehrt: Der Streifen oder Strich auf einem Tantalkondensator kennzeichnet den Pluspol.
• Keramik und Folie: Ungepolt; die Einbaurichtung ist egal.
• Im Schaltplan: Ein ungepolter Kondensator wird als zwei gerade, parallele Striche gezeichnet. Beim gepolten ist eine Platte gebogen oder gefüllt dargestellt, und ein + markiert die Plusseite.

Die Nennspannung auf dem Gehäuse (z. B. 16 V, 25 V, 50 V) ist die höchste Gleichspannung, die der Kondensator dauerhaft verträgt, und darf nie überschritten werden. Als sichere Regel wählst du mindestens das 1,5- bis 2-Fache der höchsten Spannung in der Schaltung: 10 V oder 16 V in einer 5-V-Arduino-Schaltung, 25 V an einem 12-V-Netzteil und 35 V oder 50 V bei 24 V. Eine höhere Nennspannung als nötig schadet nicht; das Bauteil ist nur größer und etwas teurer.

Kondensator-Code lesen: Was bedeutet 104?

Um Platz zu sparen, tragen Keramik- und Folienkondensatoren ihren Wert als dreistelligen Code. Die Einheit ist immer Pikofarad: Die ersten beiden Ziffern sind der Zahlenwert, die dritte gibt an, wie viele Nullen angehängt werden. Also 104 = 10 und 4 Nullen = 100.000 pF = 100 nF = 0,1 µF. Zweistellige Codes geben den Wert direkt in pF an (22 = 22 pF), und eine 0 als letzte Ziffer hängt keine Nullen an (220 = 22 pF). Bei der Buchstabenschreibweise ist der Buchstabe Einheit und Komma zugleich: 4n7 = 4,7 nF, 2p2 = 2,2 pF. Zum schnellen Entschlüsseln nutze den Kondensatorcode-Rechner.

Ein Buchstabe hinter dem Code gibt die Toleranz an: J = ±5 %, K = ±10 %, M = ±20 %, Z = +80 % / −20 %. Bei Folienkondensatoren kann davor noch ein Spannungscode stehen; 2A104J bedeutet zum Beispiel 100 V (2A), 100 nF (104) und ±5 % (J). Häufige Spannungscodes sind 1C = 16 V, 1H = 50 V, 2A = 100 V und 2J = 630 V. Elkos tragen keinen Code, der Wert ist direkt aufgedruckt (470 µF 16 V). SMD-Keramikkondensatoren haben dagegen meist überhaupt keine Beschriftung; ihren Wert erfährst du nur über die Verpackung oder durch Messen.

Laden, Entladen und die RC-Zeitkonstante (τ = R·C)

Lädst du einen Kondensator über einen Widerstand, springt seine Spannung nicht sofort, sondern steigt entlang einer Exponentialkurve: Uc = Uq · (1 − e^(−t/RC)) (Uq ist die Quellenspannung, t die vergangene Zeit). Beim Entladen fällt sie im gleichen Tempo: Uc = U0 · e^(−t/RC). Das Produkt R·C heißt Zeitkonstante und wird τ (Tau) geschrieben; Ohm mal Farad ergibt Sekunden. Mit einem 10-kΩ-Widerstand und einem 100-µF-Kondensator ist τ = 10.000 × 0,0001 = 1 Sekunde. Mit 1 kΩ und 100 nF sind es nur 0,1 Millisekunden.

In der Praxis gilt ein Kondensator nach etwa 5τ als voll geladen bzw. entladen; im Beispiel mit 10 kΩ und 100 µF sind das 5 Sekunden. Dieses Verhalten ist die Grundlage von Zeitgliedern, Entprellschaltungen für Taster, langsam ausgehenden Lampen und dem 555-Timer. Widerstandswerte frischst du im Artikel Was ist ein Widerstand? auf, und wie sich die Kurve mit anderen R- und C-Werten ändert, zeigt dir der Rechner RC-Zeitkonstante. Den Zusammenhang zwischen Spannung, Strom und Widerstand erklären wir ausführlich im Artikel Ohmsches Gesetz.

Siebung und Abblockung: Warum sitzt neben jedem IC ein 100-nF-Kondensator?

Mikrocontroller und andere ICs ziehen bei jeder Taktflanke kurze Stromspitzen von wenigen Nanosekunden. Ist das Netzteil weit weg, kommt die Induktivität der Leitungen diesen plötzlichen Anforderungen nicht hinterher; auf der Versorgung entstehen kleine Einbrüche und Störungen, und die Folge sind zufällige Resets, unzuverlässige Analogwerte oder Abstürze. Die Lösung: zwischen VCC und GND jedes ICs, so nah wie möglich, einen 100-nF-Keramikkondensator setzen. Er wirkt wie ein winziger Energiespeicher direkt neben dem Chip und schließt hochfrequente Störungen nach GND kurz. Man nennt ihn Abblock- oder Entkopplungskondensator. Für langsame, große Laständerungen kommt am Versorgungseingang ein 10–1000-µF-Elko als Pufferkondensator hinzu.

• 100 nF für jeden IC: Zwischen VCC und GND, mit kurzen Anschlussbeinen und so nah wie möglich am Versorgungspin des Chips.
• Linearregler wie der 7805: Der Hersteller empfiehlt 0,33 µF am Eingang und 0,1 µF am Ausgang; in der Praxis kommen am Ausgang oft noch 10–100 µF dazu. Details im Artikel Spannungsregler 7805.
• Servomotoren: 100–470 µF an der Servoversorgung, nah am Servo, helfen zu verhindern, dass der Arduino beim Bewegen des Servos neu startet (Was ist ein Servomotor?).
• WS2812B-LED-Streifen: Empfohlen wird ein Kondensator mit 500–1000 µF und mindestens 6,3 V zwischen + und − des Netzteils (WS2812B NeoPixel).
• Gleichstrommotoren: Ein direkt an die Motoranschlüsse gelöteter 100-nF-Keramikkondensator verringert die von den Bürsten erzeugten Störungen deutlich (DC-Motor mit L298N).
• Funkmodule: Beim Senden steigt der Strom schlagartig an. 10 µF an den Versorgungspins des nRF24L01 und 100–470 µF zwischen 3,3 V und GND beim ESP32 verringern Verbindungsabbrüche und Brownout-Resets.

Schaltest du einen Widerstand und einen Kondensator hintereinander, erhältst du einen Tiefpass: Er lässt Frequenzen unterhalb einer Grenze durch und dämpft die darüber. Die Grenzfrequenz ist fc = 1 / (2π · R · C). Der PWM-Ausgang des Arduino Uno ist ein Rechtecksignal mit 490 Hz (an den Pins 5 und 6 mit 980 Hz); mit einem Filter aus 10 kΩ und 10 µF (fc ≈ 1,6 Hz) wird daraus eine nahezu glatte Gleichspannung, also ein einfacher Analogausgang. Der Preis ist die Reaktionszeit: Bei τ = 0,1 s dauert es etwa eine halbe Sekunde, bis sich ein neuer Wert einstellt. Mehr dazu in Was ist PWM?. Ein gleichgerichtetes Netzteil wird ebenfalls mit einem großen Ladekondensator geglättet; die verbleibende Restwelligkeit beträgt etwa ΔU ≈ I / (f · C): Bei 1 A Last, 100 Hz Vollweggleichrichtung und 4700 µF sind das rund 2,1 V.

Kondensatoren in Reihe und parallel schalten

Die Formeln für Kondensatoren sind genau umgekehrt wie bei Widerständen. Parallel addieren sich die Kapazitäten: C = C1 + C2 + … Die Spannungsfestigkeit entspricht der des schwächsten Bauteils. In Reihe ist die Gesamtkapazität sogar kleiner als der kleinste Kondensator: 1/C = 1/C1 + 1/C2 + … Zwei gleiche Kondensatoren in Reihe ergeben die halbe Kapazität, und auf dem Papier addieren sich ihre Nennspannungen; weil die Leckströme aber unterschiedlich sind, teilt sich die Spannung ungleich auf, deshalb setzt man parallel zu jedem Kondensator gleich große Symmetrierwiderstände (z. B. 100 kΩ). Fehlt dir ein Wert, kannst du ihn aus zwei Kondensatoren zusammensetzen; rechne mit dem Rechner Reihe / parallel C, und das Gegenstück für Widerstände findest du unter Widerstände in Reihe und parallel berechnen.

Ladekurve mit Arduino aufzeichnen: Kapazität messen

Am besten verstehst du die Theorie, wenn du die Spannung eines Kondensators beim Laden misst. Ein digitaler Pin des Arduino lädt den Kondensator über einen 10-kΩ-Widerstand, ein Analogeingang liest die Kondensatorspannung. Die Zeit, bis 63,2 % der Quellenspannung erreicht sind, ist ein τ; daraus berechnen wir die Kapazität mit C = τ / R. Du brauchst: einen Arduino Uno, einen 100-µF-Elko, einen 10-kΩ-Widerstand, ein Steckbrett (Breadboard) und ein paar Jumperkabel.

1. Stecke den Kondensator ins Steckbrett: das Plusbein in eine Reihe, das Minusbein an die GND-Schiene.
2. Verbinde ein Ende des 10-kΩ-Widerstands mit D8 und das andere mit der Reihe, in der das Plusbein des Kondensators steckt.
3. Ziehe aus derselben Reihe ein Kabel zu A0 und verbinde GND des Arduino mit der GND-Schiene des Steckbretts.
4. Lade den Code unten hoch und öffne den seriellen Monitor mit 115200 Baud.
5. Der Code entlädt den Kondensator zuerst und lädt ihn dann; alle 20 ms gibt er die vergangene Zeit und die Spannung aus und zeigt am Ende das gemessene τ und die Kapazität an.
6. Um die Kurve als Grafik zu sehen, setze PLOT im Code auf true, lade ihn erneut hoch und öffne Werkzeuge > Serieller Plotter.

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}

So funktioniert der Code: Ist der Pin LOW, entlädt sich der Kondensator über denselben 10-kΩ-Widerstand. Sobald der Pin HIGH wird, startet millis() die Zeitmessung; erreicht der Analogwert 647 (63,2 % von 1023), wird die vergangene Zeit als τ gespeichert. Bei 1010 (etwa 99 %) gilt der Ladevorgang als abgeschlossen. Mit 100 µF und 10 kΩ solltest du ungefähr 1000 ms und 100 µF sehen. Elkos haben meist eine Toleranz von ±20 %, Ergebnisse zwischen 80 und 120 µF sind also normal. Mehr zur Zeitmessung findest du unter millis und delay.

Derselbe Versuch mit ESP32 und Raspberry Pi Pico

Beim ESP32 arbeiten die Pins mit 3,3 V, und der ADC hat 12 Bit (0–4095). Der ADC des ESP32 ist an den Bereichsenden nicht linear, deshalb nutzen wir statt Rohwerten analogReadMilliVolts(), das kalibrierte Millivolt zurückgibt. Als Messpin haben wir GPIO 34 aus der ADC1-Gruppe gewählt, die nicht von WLAN beeinflusst wird. Weil der ADC oberhalb von etwa 3,1 V nicht zuverlässig misst, erkennen wir das Ende des Ladens über die Zeit statt über die Spannung: Sobald τ gefunden ist, endet die Messung nach 5τ. Die Grundlagen findest du in Was ist der 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}

Auf dem Raspberry Pi Pico ist derselbe Versuch mit MicroPython in wenigen Zeilen erledigt. Die Analogeingänge des Pico sind GP26, GP27 und GP28; read_u16() liefert die 12-Bit-Messung auf den Bereich 0–65535 skaliert. Der Code gibt in jeder Zeile Zeit und Spannung aus, sodass du die Ausgabe in eine Tabellenkalkulation kopieren und die Kurve selbst zeichnen kannst. Wenn du noch nicht weißt, wie man MicroPython auf den Pico bringt, starte mit Was ist der 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")

Projektideen mit Kondensatoren

• Hardware-Entprellung: Setze 100 nF – 1 µF parallel zum Taster; zusammen mit einem 10-kΩ-Pull-up entsteht ein Filter mit τ = 1–10 ms, und das Prellen klingt ab, bevor es deinen Code erreicht.
• Analogspannung aus PWM: Mach mit einem RC-Filter aus einem PWM-Ausgang eine glatte Spannung zwischen 0 und 5 V und miss sie mit dem Multimeter.
• Blinkende LED mit dem 555: Beim 555-Timer bestimmen zwei Widerstände und ein Kondensator die Frequenz: f ≈ 1,44 / ((R1 + 2·R2) · C). Berechne die Werte mit dem Rechner 555-Timer.
• Langsam ausgehende Lampe: Setze hinter dem Schalter einen 1000-µF-Kondensator parallel zur Versorgung von LED und Vorwiderstand; schaltest du ab, geht die LED nicht schlagartig aus, sondern wird langsam dunkler, während sich der Kondensator entlädt. Widerstand und Kapazität bestimmen gemeinsam die Dauer.
• Kapazitive Sensoren: Ein kapazitiver Bodenfeuchtesensor misst die Kapazitätsänderung durch Wasser im Boden; da seine Elektroden nicht frei liegen, korrodiert er nicht.
• Einfaches Kapazitätsmessgerät: Kombiniere den Versuch oben mit einem I2C-LCD und zeige die Werte deiner Kondensatoren auf dem Display an.

Häufige Fehler und Lösungen

• 104 für 104 µF halten: 104 sind 100 nF; dreistellige Codes sind immer in Pikofarad angegeben.
• Elko verpolt einbauen: Der Kondensator wird heiß, bläht sich auf oder platzt; das Bein mit dem Streifen gehört auf die GND-Seite (bei Tantal ist der Streifen Plus).
• Zu niedrige Nennspannung wählen: Ein 10-V-Kondensator an einer 12-V-Leitung fällt schnell aus; lass mindestens das 1,5- bis 2-Fache Reserve.
• Abblockkondensator zu weit weg setzen: 10 cm vom IC entfernt verliert ein 100-nF-Kondensator durch die Leitungsinduktivität seine Wirkung; halte die Beine kurz und setze ihn direkt an die Versorgungspins.
• Arduino startet neu, wenn der Motor anläuft: Die Versorgungsspannung bricht kurz ein; versorge den Motor separat, ergänze 100–470 µF an der Versorgung und verbinde die Massen (Warum startet mein Arduino ständig neu?).
• "Failed to connect to ESP32: Timed out waiting for packet header" beim ESP32: Bei manchen Boards trifft die automatische Programmierschaltung das Timing nicht; ein 1–10-µF-Kondensator zwischen EN und GND macht das Drücken der BOOT-Taste oft überflüssig.

Nach Widerstand und LED ist der Kondensator das wichtigste Grundbauteil; wenn du τ = R·C verstanden hast und dir angewöhnst, neben jeden IC 100 nF zu setzen, laufen deine Schaltungen deutlich stabiler. Als nächsten Schritt kannst du mit der Spule in Was ist eine Spule? weitermachen. In der BlueGrays-App findest du Projekte wie die LED-Steuerung per Taster, Lichtmessung mit LDR, PWM-LED-Dimmen und WS2812B mit Schaltplänen und Code Schritt für Schritt, sodass du dein Wissen über Kondensatoren gleich in echten Schaltungen ausprobieren kannst.