Wat is een condensator? Typen, 104-code en RC-tijdconstante
Wat is een condensator en wat doet hij? Eenheden pF, nF en µF, keramisch of elco, de 104-code, τ = R·C, 100 nF-ontkoppeling en een oplaadtest met Arduino.
Een condensator is een basiscomponent in schakelingen die elektrische lading opslaat tussen twee geleidende platen die elkaar nooit raken, en die lading als het nodig is razendsnel weer afgeeft. Zie hem als een klein maar heel snel energiereservoir: hij levert lading wanneer de spanning inzakt, vangt plotselinge pieken op, blokkeert gelijkstroom (DC) zodra hij is opgeladen en laat wisselstroom (AC) en ruis toch door. Zelfs een Arduino Uno bevat veel condensatoren; ze kalmeren de voedingslijn, voorkomen dat knoppen dender veroorzaken, bepalen timing en maken van een PWM-signaal een gladde spanning.
In deze gids leer je hoe een condensator werkt, wat de eenheden pF, nF en µF zijn, wat het verschil is tussen keramische, elektrolytische en tantaalcondensatoren, hoe je polariteit en nominale spanning afleest, wat codes zoals 104 betekenen, wat de RC-tijdconstante (τ = R·C) is en hoe je condensatoren in serie en parallel schakelt. Aan het eind doen we een experiment met Arduino, ESP32 en Raspberry Pi Pico dat de oplaadcurve van een condensator tekent en zijn capaciteit meet.

Wat is een condensator en hoe werkt hij?
In elke condensator zitten twee geleidende oppervlakken die gescheiden zijn door een isolerende laag, het diëlektricum. Als je een spanning over de pootjes zet, hopen elektronen zich op op de ene plaat en worden ze van de andere weggetrokken; tussen de platen ontstaat een elektrisch veld en de energie wordt in dat veld opgeslagen. De opgeslagen lading is Q = C · V, waarbij C de capaciteit in farad is en V de spanning in volt. De opgeslagen energie is E = ½ · C · V²; een condensator van 1000 µF die is opgeladen tot 16 V bevat bijvoorbeeld 0,128 joule. Stroom en spanning hangen samen via I = C · ΔV/Δt: een condensator verzet zich tegen plotselinge spanningsveranderingen, en dat is precies waarom hij rimpel gladstrijkt.
Je kunt een condensator zien als een watertank: als hij leeg is, loopt hij snel vol, de stroom neemt af naarmate hij vol raakt en uiteindelijk stopt hij. Daarom loopt er in een gelijkstroomschakeling geen stroom meer door een condensator als hij eenmaal is opgeladen. Bij een hogere frequentie biedt de condensator echter steeds minder weerstand tegen stroom; die weerstand heet capacitieve reactantie en wordt berekend met Xc = 1 / (2π · f · C). Een condensator van 100 nF heeft bij 1 kHz ongeveer 1,6 kΩ, maar bij 10 MHz slechts 0,16 Ω. Voor hoogfrequente ruis is hij dus bijna een kortsluiting, en dat is het hele geheim achter ontkoppelcondensatoren.
Capaciteitseenheden: pF, nF en µF
| Eenheid | Symbool | In farad | Typisch gebruik |
|---|---|---|---|
| Picofarad | pF | 10⁻¹² F | 22 pF naast een kristal, hf-schakelingen |
| Nanofarad | nF | 10⁻⁹ F | 100 nF ontkoppeling, 10 nF ruisfilter |
| Microfarad | µF | 10⁻⁶ F | 10–1000 µF voedings- en motorcondensatoren |
| Farad | F | 1 F | Supercondensatoren, back-upenergie |
De farad is een enorme eenheid, dus in de elektronica gebruikt men bijna altijd de kleinere veelvouden. De omrekenregel is simpel: elke stap is een factor 1000. 1 µF = 1000 nF = 1.000.000 pF, dus 0,1 µF, 100 nF en 100.000 pF zijn dezelfde waarde. Als het µ-symbool niet beschikbaar is, schrijft men een u (10uF), en op oude schema's zie je soms MFD voor microfarad. De waarden die je het vaakst tegenkomt in Arduino-projecten zijn 22 pF, 100 nF (0,1 µF), 10 µF, 100 µF en 1000 µF.
Typen condensatoren: keramisch, elco, tantaal en meer
| Type | Capaciteitsbereik | Gepolariseerd? | Toepassing |
|---|---|---|---|
| Keramisch (MLCC, schijfje) | 1 pF – 100 µF | Nee | Ontkoppeling, kristallen, hoogfrequentfilters |
| Aluminium elco | 0,1 µF – tienduizenden µF | Ja | Voedingsfiltering, motoren, servo's, ledstrips |
| Tantaal | 0,1 µF – enkele honderden µF | Ja | Stabiele voeding op kleine boards |
| Folie (polyester, polypropyleen) | Ca. 1 nF – 10 µF | Nee | Audio, timing, netfilters |
| Supercondensator | 0,1 F – honderden F | Ja | Back-up van de klok (RTC), kortstondige energie |
- Keramisch: klein, goedkoop en niet gepolariseerd. Hun interne weerstand (ESR) is erg laag, dus ze filteren snelle ruis het best. De stabiliteit hangt af van het diëlektricum: C0G (NP0) is zeer stabiel, X7R is goed, terwijl Y5V door temperatuur en aangelegde spanning meer dan de helft van zijn waarde kan verliezen.
- Aluminium elco: biedt een grote capaciteit in een klein volume, maar is gepolariseerd en de vloeistof binnenin droogt langzaam op. Op de behuizing staat een limiet van 85 °C of 105 °C en de levensduur bij die temperatuur (bijv. 2000 uur); grofweg verdubbelt elke 10 °C koeler de levensduur.
- Tantaal: kleiner en stabieler dan een elco met dezelfde waarde, maar gevoelig voor omgekeerde spanning en stroompieken; als hij defect raakt, kan hij kortsluiten en verbranden. Kies er een met een nominale spanning van minstens twee keer je werkspanning.
- Folie: niet gepolariseerd, stabiel en met weinig verlies; wordt gebruikt in audioschakelingen, nauwkeurige timing en 230 V-netfilters (klasse X2). Het nadeel is dat grote waarden omvangrijk zijn.
- Supercondensator: heeft een capaciteit in het bereik van farads, maar verdraagt slechts ongeveer 2,7 V per cel. Hij bevat minder energie dan een batterij; in ruil daarvoor kan hij binnen enkele seconden laden en ontladen en overleeft hij honderdduizenden cycli.
Zo lees je polariteit (+/−) en nominale spanning af
- Elco met draadpootjes: het lange pootje is positief (+), het korte negatief (−). De lichte streep op de mantel heeft minstekens en markeert de negatieve kant. Als de pootjes zijn ingekort, ga dan af op de streep.
- SMD-elco (bekertype): de zwarte of gekleurde halve maan op de bovenkant markeert de negatieve kant.
- Tantaal: pas op, de regel is omgekeerd: de streep of lijn op een tantaalcondensator markeert het positieve pootje.
- Keramisch en folie: niet gepolariseerd; je kunt ze in beide richtingen plaatsen.
- Op schema's: een niet-gepolariseerde condensator wordt getekend als twee rechte evenwijdige lijnen. Bij een gepolariseerde is één plaat gebogen of gevuld getekend en een +-teken markeert de positieve kant.
De nominale spanning op de behuizing (bijv. 16 V, 25 V, 50 V) is de hoogste gelijkspanning die de condensator continu kan verdragen en mag nooit worden overschreden. De veilige regel is een condensator te kiezen met een nominale spanning van minstens 1,5–2 keer de hoogste spanning in de schakeling: gebruik 10 V of 16 V in een Arduino-schakeling van 5 V, 25 V bij een adapter van 12 V en 35 V of 50 V bij 24 V. Een hogere nominale spanning dan nodig is niet erg; het onderdeel is dan alleen groter en iets duurder.
Condensatorcodes lezen: wat betekent 104?
Om ruimte te besparen dragen keramische en foliecondensatoren hun waarde als code van drie cijfers. De eenheid is altijd de picofarad: de eerste twee cijfers vormen het getal en het derde geeft aan hoeveel nullen erachter komen. Dus 104 = 10 gevolgd door 4 nullen = 100.000 pF = 100 nF = 0,1 µF. Codes van twee cijfers geven de waarde direct in pF (22 = 22 pF) en een laatste cijfer 0 voegt geen nullen toe (220 = 22 pF). In lettercodes is de letter zowel de eenheid als het decimaalteken: 4n7 = 4,7 nF, 2p2 = 2,2 pF. Om er snel een te ontcijferen, gebruik je de tool Condensatorcode.
| Code | Berekening | Waarde |
|---|---|---|
| 22 / 220 | 22 × 1 pF | 22 pF |
| 101 | 10 × 10 pF | 100 pF |
| 102 | 10 × 100 pF | 1 nF |
| 103 | 10 × 1.000 pF | 10 nF |
| 104 | 10 × 10.000 pF | 100 nF (0,1 µF) |
| 105 | 10 × 100.000 pF | 1 µF |
| 223 | 22 × 1.000 pF | 22 nF |
| 474 | 47 × 10.000 pF | 470 nF (0,47 µF) |
| 4n7 | De letter fungeert als decimaalteken | 4,7 nF |
Een letter na de code geeft de tolerantie: J = ±5%, K = ±10%, M = ±20%, Z = +80% / −20%. Foliecondensatoren kunnen ook een spanningscode vooraan hebben; 2A104J betekent bijvoorbeeld 100 V (2A), 100 nF (104) en ±5% (J). Gangbare spanningscodes zijn 1C = 16 V, 1H = 50 V, 2A = 100 V en 2J = 630 V. Elco's gebruiken geen codes; de waarde staat er direct op (470 µF 16 V). SMD-keramische condensatoren hebben daarentegen meestal helemaal geen opdruk, dus hun waarde haal je alleen uit de verpakking of door te meten.
Opladen, ontladen en de RC-tijdconstante (τ = R·C)
Als je een condensator oplaadt via een weerstand, springt zijn spanning niet meteen omhoog maar stijgt hij langs een exponentiële curve: Vc = Vs · (1 − e^(−t/RC)) (Vs is de bronspanning, t de verstreken tijd). Bij ontladen daalt hij in hetzelfde tempo: Vc = V0 · e^(−t/RC). Het product R·C heet de tijdconstante en wordt geschreven als τ (tau); ohm maal farad geeft seconden. Met een weerstand van 10 kΩ en een condensator van 100 µF is τ bijvoorbeeld 10.000 × 0,0001 = 1 seconde. Met 1 kΩ en 100 nF is τ slechts 0,1 milliseconde.
| Verstreken tijd | Bereikte spanning bij opladen | Resterende spanning bij ontladen |
|---|---|---|
| 1 τ | 63,2% | 36,8% |
| 2 τ | 86,5% | 13,5% |
| 3 τ | 95,0% | 5,0% |
| 4 τ | 98,2% | 1,8% |
| 5 τ | 99,3% | 0,7% |
In de praktijk geldt een condensator na ongeveer 5τ als volledig opgeladen of ontladen; in het voorbeeld met 10 kΩ en 100 µF is dat 5 seconden. Dit gedrag ligt ten grondslag aan timers, schakelingen tegen knopdender, lampen die langzaam doven en de 555-chip. Om je kennis over weerstandswaarden op te frissen, lees je Wat is een weerstand?, en om te zien hoe de curve verandert bij andere waarden van R en C, probeer je de tool RC-tijdconstante. Het verband tussen spanning, stroom en weerstand leggen we uitgebreid uit in De wet van Ohm.
Filteren en ontkoppelen: waarom zit er naast elke chip een 100 nF?
Microcontrollers en andere chips trekken bij elke klokflank korte stroompulsen van enkele nanoseconden. Als de voeding ver weg zit, kan de inductie van de draden deze plotselinge vragen niet bijhouden; er ontstaan kleine dips en ruis op de voedingslijn, met willekeurige resets, onbetrouwbare analoge metingen of vastlopers als gevolg. De oplossing is een keramische condensator van 100 nF tussen de VCC- en GND-pin van elke chip te plaatsen, zo dicht mogelijk erbij. Hij werkt als een klein energiereservoir vlak naast de chip en sluit hoogfrequente ruis kort naar GND. Dit heet een ontkoppel- of bypasscondensator. Voor langzame, grote belastingswisselingen komt er bij de voedingsingang een elco van 10–1000 µF bij (een bufferncondensator).

- 100 nF bij elke chip: plaats hem met korte pootjes tussen VCC en GND, zo dicht mogelijk bij de voedingspin van de chip.
- Lineaire regelaars zoals de 7805: de fabrikant adviseert 0,33 µF aan de ingang en 0,1 µF aan de uitgang; in de praktijk wordt aan de uitgang vaak ook 10–100 µF toegevoegd. Meer details in 7805-spanningsregelaar.
- Servomotoren: 100–470 µF op de servovoeding, dicht bij de servo, helpt voorkomen dat de Arduino reset wanneer de servo beweegt (Wat is een servomotor?).
- WS2812B-ledstrips: een condensator van 500–1000 µF met een nominale spanning van minstens 6,3 V wordt aanbevolen over de + en − aansluitingen van de adapter (WS2812B NeoPixel).
- DC-motoren: een keramische condensator van 100 nF die direct over de motoraansluitingen is gesoldeerd, vermindert de elektrische ruis van de koolborstels sterk (DC-motor met L298N).
- Draadloze modules: de stroom springt plotseling omhoog tijdens het zenden. Als je 10 µF over de voedingspinnen van de nRF24L01 zet en 100–470 µF tussen 3,3 V en GND van de ESP32, krijg je minder verbroken verbindingen en minder brownout-resets.
Een weerstand en een condensator in serie vormen een laagdoorlaatfilter: het laat frequenties onder een bepaald punt door en dempt die erboven. De afsnijfrequentie is fc = 1 / (2π · R · C). De PWM-uitgang van de Arduino Uno is een blokgolf van 490 Hz (980 Hz op pin 5 en 6); met een filter van 10 kΩ en 10 µF (fc ≈ 1,6 Hz) wordt die golf een bijna vlakke gelijkspanning, zodat je een eenvoudige analoge uitgang hebt. De prijs is de reactietijd: met τ = 0,1 s duurt het ongeveer een halve seconde voordat hij op een nieuwe waarde is uitgekomen. Meer in Wat is PWM?. Een gelijkgerichte voeding wordt eveneens gefilterd met een grote afvlakcondensator en de resterende rimpel is ongeveer ΔV ≈ I / (f · C): bij een belasting van 1 A, dubbelfasige gelijkrichting van 100 Hz en 4700 µF is dat circa 2,1 V.
Condensatoren in serie en parallel schakelen
De formules voor condensatoren zijn precies het tegenovergestelde van die voor weerstanden. In parallel worden de capaciteiten opgeteld: C = C1 + C2 + … terwijl de nominale spanning die van het onderdeel met de laagste waarde is. In serie is het totaal kleiner dan zelfs de kleinste condensator: 1/C = 1/C1 + 1/C2 + … Twee gelijke condensatoren in serie geven de helft van de capaciteit en op papier worden hun nominale spanningen opgeteld; maar doordat hun lekstromen verschillen, verdeelt de spanning zich ongelijk, dus plaatst men gelijke balanceerweerstanden (bijv. 100 kΩ) over elke condensator. Als je de waarde die je nodig hebt niet hebt, kun je hem opbouwen uit twee condensatoren; gebruik de tool Serie / parallel C voor het rekenwerk en zie serie- en parallelschakeling van weerstanden berekenen voor het equivalent bij weerstanden.
| Verbinding | Voorbeeld | Totale capaciteit | Nominale spanning |
|---|---|---|---|
| Parallel | 100 µF 16 V + 220 µF 25 V | 320 µF | 16 V (de laagste) |
| Serie | 100 µF 16 V + 100 µF 16 V | 50 µF | Tot 32 V (met balanceerweerstanden) |
| Serie | 10 µF + 22 µF | Ca. 6,9 µF | De spanning verdeelt zich omgekeerd evenredig met de capaciteit |
| Parallel | 10 µF + 100 nF | 10,1 µF | Die van het onderdeel met de laagste waarde |
Arduino-experiment met de oplaadcurve: de capaciteit meten
De beste manier om de theorie zelf te zien, is de spanning van een condensator te meten terwijl hij oplaadt. Een van de digitale pins van de Arduino laadt de condensator op via een weerstand van 10 kΩ en een analoge ingang leest de condensatorspanning. De tijd die nodig is om 63,2% van de bronspanning te bereiken is één τ, en daaruit berekenen we de capaciteit met C = τ / R. Je hebt nodig: een Arduino Uno, een elco van 100 µF, een weerstand van 10 kΩ, een breadboard en een paar jumperdraden.
| Verbinding | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Eén kant van de 10 kΩ-weerstand (oplaadpin) | D8 | GPIO 25 | GP15 |
| Knooppunt van de weerstand en het +pootje van de condensator | A0 | GPIO 34 (ADC1) | GP26 (ADC0) |
| −pootje van de condensator | GND | GND | GND |
| ADC-resolutie en referentie | 10 bits, 5 V | 12 bits, ca. 3,3 V | 12 bits, 3,3 V |
| 63,2%-drempel | 647 (ruwe waarde) | 2086 mV | 2,086 V |
- Plaats de condensator in de breadboard: het +pootje in de ene rij, het −pootje op de GND-rail.
- Verbind één kant van de weerstand van 10 kΩ met D8 en de andere kant met de rij waarin het +pootje van de condensator zit.
- Leg een draad van dezelfde rij naar A0 en verbind GND van de Arduino met de GND-rail van de breadboard.
- Upload de onderstaande code en open de Serial Monitor op 115200 baud.
- De code ontlaadt eerst de condensator en laadt hem daarna op; elke 20 ms drukt hij de verstreken tijd en de spanning af en aan het eind toont hij de gemeten τ en capaciteit.
- Om de curve als grafiek te zien, zet je PLOT in de code op true, upload je opnieuw en open je Tools › Serial 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}Zo werkt de code: als de pin LOW wordt gezet, ontlaadt de condensator via dezelfde weerstand van 10 kΩ. Zodra de pin HIGH wordt, begint millis() te tellen; als de analoge waarde 647 bereikt (63,2% van 1023), wordt de verstreken tijd opgeslagen als τ. Als de waarde 1010 bereikt (ongeveer 99%), geldt het opladen als voltooid. Met 100 µF en 10 kΩ zie je ongeveer 1000 ms en 100 µF. Elco's hebben meestal een tolerantie van ±20%, dus resultaten tussen 80 en 120 µF zijn normaal. Meer over timing vind je in millis en delay.
Hetzelfde experiment met ESP32 en Raspberry Pi Pico
Op de ESP32 werken de pins op 3,3 V en is de ADC 12 bits (0–4095). De ADC van de ESP32 is aan de randen van zijn bereik niet lineair, dus gebruiken we in plaats van ruwe waarden analogReadMilliVolts(), dat gekalibreerde millivolts teruggeeft. Voor de meetpin kozen we GPIO 34 uit de ADC1-groep, die niet wordt beïnvloed door Wi-Fi. Omdat de ADC boven ongeveer 3,1 V niet betrouwbaar meet, bepalen we het einde van het opladen op tijd in plaats van op spanning: zodra τ is gevonden, stopt de meting na 5τ. Voor de basis, zie Wat is 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}Op de Raspberry Pi Pico kost hetzelfde experiment slechts een paar regels MicroPython. De analoge ingangen van de Pico zijn GP26, GP27 en GP28; read_u16() geeft de 12-bits meting geschaald naar het bereik 0–65535. De code drukt op elke regel de verstreken tijd en de spanning af, zodat je de uitvoer in een spreadsheet kunt kopiëren en de curve zelf kunt tekenen. Als je niet weet hoe je MicroPython op de Pico installeert, begin dan met Wat is de 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")Projectideeën met condensatoren
- Hardwarematige dender-onderdrukking: zet 100 nF – 1 µF over de knop; samen met een pull-up van 10 kΩ vormt dit een filter met τ = 1–10 ms en sterven de dendersignalen uit voordat ze je code bereiken.
- Analoge spanning uit PWM: gebruik een RC-filter om een PWM-uitgang om te zetten in een gladde spanning van 0–5 V en meet die met een multimeter.
- Knipperende led met een 555: in de 555-timer bepalen twee weerstanden en één condensator de frequentie: f ≈ 1.44 / ((R1 + 2·R2) · C). Bereken de waarden met de tool 555-timer.
- Langzaam dovende lamp: zet na de schakelaar een condensator van 1000 µF over de voeding van de led en zijn weerstand; als je de stroom met de schakelaar onderbreekt, gaat de led niet meteen uit maar dooft hij langzaam terwijl de condensator ontlaadt. De weerstand en de capaciteit samen bepalen de dooftijd.
- Capacitieve sensoren: een capacitieve bodemvochtsensor meet de capaciteit die door water in de grond verandert; omdat de elektroden niet blootliggen, corrodeert hij niet.
- Eenvoudige capaciteitsmeter: combineer het bovenstaande experiment met een I2C-LCD en toon de waarde van je condensatoren op het scherm.
Veelgemaakte fouten en hoe je ze oplost
- Denken dat 104 gelijk is aan 104 µF: 104 is 100 nF; codes van drie cijfers zijn altijd in picofarad.
- Een elco omgekeerd plaatsen: de condensator wordt heet, bolt op of barst; het pootje met de streep gaat naar de GND-kant (bij tantaal is de streep positief).
- Een te lage nominale spanning kiezen: een condensator van 10 V op een lijn van 12 V faalt snel; laat een marge van minstens 1,5–2 keer.
- De ontkoppelcondensator ver weg plaatsen: een condensator van 100 nF op 10 cm van de chip verliest zijn werking door de inductie van de draad; houd de pootjes kort en plaats hem direct bij de voedingspins.
- Arduino reset als een motor start: de voedingsspanning zakt even in; voed de motor apart, voeg 100–470 µF toe aan de voeding en verbind de massa's met elkaar (Waarom blijft mijn Arduino resetten?).
- "Failed to connect to ESP32: Timed out waiting for packet header" op de ESP32: op sommige boards klopt de timing van de automatische programmeerschakeling niet; een condensator van 1–10 µF tussen EN en GND maakt het vasthouden van de BOOT-knop vaak overbodig.
Na weerstanden en leds is de condensator het belangrijkste onderdeel dat je moet leren kennen; zodra je τ = R·C begrijpt en er een gewoonte van maakt om naast elke chip een 100 nF te plaatsen, werken je schakelingen veel betrouwbaarder. Ga als volgende stap verder met de spoel in Wat is een spoel?. In de BlueGrays-app vind je projecten met een led die je met een knop bedient, lichtmeting met een LDR, PWM-ledfading en WS2812B, met schakelschema's en code stap voor stap, zodat je meteen in echte schakelingen kunt uitproberen wat je over condensatoren hebt geleerd.
Veelgestelde vragen
Wat doet een condensator?
Een condensator slaat elektrische lading kort op en geeft die snel weer af als dat nodig is. In elektronische schakelingen gebruikt men hem om de voedingsspanning af te vlakken, ruis te filteren, timing in te stellen, gelijkstroom te blokkeren terwijl wisselstroomsignalen doorgaan en knoppen te laten ophouden met denderen. Bijna elk elektronisch board bevat tientallen condensatoren.
Wat is het verschil tussen een condensator en een batterij?
Een batterij slaat energie chemisch op, levert lange tijd een vrijwel constante spanning en bevat veel meer energie. Een condensator slaat energie op in een elektrisch veld; hij kan binnen milliseconden laden en ontladen, maar zijn spanning blijft dalen naarmate hij ontlaadt. Daarom is een condensator geen langdurige stroombron, maar een snelle buffer voor plotselinge vragen.
Hoeveel nF is een condensator met code 104?
De code 104 betekent 10 gevolgd door 4 nullen, dus 100.000 pF. Dat is gelijk aan 100 nF of 0,1 µF. Het is de meest gangbare ontkoppelwaarde bij Arduino en in geïntegreerde schakelingen.
Hoe herken je het positieve en negatieve pootje van een elco?
Bij een nieuwe elco is het lange pootje positief (+) en het korte negatief (−). De lichte streep met minstekens op de behuizing markeert ook de negatieve kant. Bij tantaalcondensatoren is de regel omgekeerd: de streep markeert het positieve pootje.
Wat gebeurt er als je een condensator verkeerd om aansluit?
Bij niet-gepolariseerde keramische en foliecondensatoren gebeurt er niets. Als een elco of tantaalcondensator verkeerd om wordt aangesloten, loopt er een grote lekstroom doorheen; hij wordt heet, bolt op en kan barsten, en tantaalcondensatoren kunnen zelfs vlam vatten. Als je een omgekeerde condensator opmerkt, haal dan direct de stroom eraf en vervang het onderdeel.
Kan ik een condensator met een hogere nominale spanning gebruiken?
Ja, een condensator met dezelfde capaciteit en een hogere nominale spanning kun je altijd gebruiken; je kunt bijvoorbeeld 25 V of 50 V plaatsen in plaats van 16 V. Het enige verschil is een grotere behuizing en een iets hogere prijs. Het omgekeerde is gevaarlijk: een condensator met een nominale spanning onder de schakelingsspanning gaat al snel kapot.
Projecten om hierna te bouwen
Alle projecten bekijken
LED aansturen met een drukknop (Push)
Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

LED schakelen met een knop (aan/uit)
Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

Lichtsterkte meten met een LDR
Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

Raspberry Pi Pico-knop ontdenderen: IRQ vs software-polling
Als één druk op een knop je code 3-4 keer liet tellen, is contactdender de boosdoener: de metalen contacten van de knop gaan binnen microseconden vele malen open en dicht als ze elkaar raken! In dit project tellen we dezelfde knop op 2 manieren en vergelijken we ze naast elkaar in Serial: RAW-polling (vangt de dender op en telt fout) en IRQ + software-ontdendering (telt goed).

Raspberry Pi Pico PWM-led-fade (ademeffect)
De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

ESP32-led dimmen met PWM
De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

Een WS2812B-ledstrip gebruiken
Maak kennis met een slimme ledstrip waarvan je elk lampje apart kunt kleuren. De Arduino laat eerst de eerste vijf leds rood branden, zet een seconde later de andere vijf blauw, schakelt dan alles…

Digitale voltmeter met lcd-scherm
Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.
Meer artikelen
- Wat is een weerstand? Kleurcodes, de wet van Ohm en weerstanden gebruiken met Arduino
- De wet van Ohm uitgelegd: V = I × R, vermogen en led-weerstand berekenen
- Wat is PWM? Een gids voor analogWrite, duty cycle en frequentie op Arduino
- Een drukknop aansluiten op Arduino: pull-up, pull-down en contactdender
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

