Apa Itu Kapasitor? Jenis, Kode 104, dan Konstanta Waktu RC

Kapasitor adalah komponen dasar rangkaian yang menyimpan muatan listrik di antara dua pelat konduktif yang tidak pernah bersentuhan, lalu melepaskannya lagi dengan sangat cepat ketika dibutuhkan. Bayangkan kapasitor sebagai tandon energi yang kecil tapi sangat cepat: ia memberi muatan ketika tegangan turun, menelan lonjakan mendadak, memblokir arus searah (DC) setelah terisi, tapi tetap melewatkan arus bolak-balik (AC) dan noise. Bahkan Arduino Uno membawa banyak kapasitor; kapasitor-kapasitor itu menenangkan jalur catu daya, mencegah tombol memantul, mengatur waktu, dan mengubah sinyal PWM menjadi tegangan yang halus.

Di panduan ini kamu akan mempelajari cara kerja kapasitor, satuan pF, nF, dan µF, perbedaan jenis keramik, elektrolit, dan tantalum, cara membaca polaritas dan rating tegangan, arti kode seperti 104, konstanta waktu RC (τ = R·C), dan cara menyambungkan kapasitor secara seri dan paralel. Di bagian akhir kita akan menjalankan percobaan dengan Arduino, ESP32, dan Raspberry Pi Pico yang menggambar kurva pengisian kapasitor dan mengukur kapasitansinya.

Apa itu kapasitor dan bagaimana cara kerjanya?

Di dalam setiap kapasitor ada dua permukaan konduktif yang dipisahkan lapisan isolator yang disebut dielektrik. Ketika kamu memberi tegangan pada kakinya, elektron menumpuk di satu pelat dan tertarik dari pelat lainnya; medan listrik terbentuk di antara pelat dan energinya tersimpan di medan itu. Muatan yang tersimpan dihitung dengan Q = C · V, di mana C adalah kapasitansi dalam farad dan V tegangan dalam volt. Energi yang tersimpan adalah E = ½ · C · V²; misalnya, kapasitor 1000 µF yang diisi sampai 16 V menyimpan 0,128 joule. Arus dan tegangan dihubungkan oleh I = C · ΔV/Δt: kapasitor melawan perubahan mendadak pada tegangannya, dan karena itulah ia meratakan riak (ripple).

Kamu bisa membayangkan kapasitor seperti tangki air: ketika kosong ia terisi dengan cepat, alirannya melambat seiring terisi, dan akhirnya berhenti. Karena itu, di rangkaian DC, tidak ada arus yang mengalir lewat kapasitor setelah ia terisi. Namun ketika frekuensi naik, kapasitor makin sedikit melawan arus; perlawanan ini disebut reaktansi kapasitif dan dihitung dengan Xc = 1 / (2π · f · C). Kapasitor 100 nF menunjukkan sekitar 1,6 kΩ pada 1 kHz tapi hanya 0,16 Ω pada 10 MHz. Dengan kata lain, ia hampir seperti hubungan singkat untuk noise berfrekuensi tinggi, dan itulah seluruh rahasia di balik kapasitor decoupling.

Satuan kapasitansi: pF, nF, dan µF

Farad adalah satuan yang sangat besar, jadi elektronika hampir selalu memakai kelipatan kecilnya. Aturan konversinya sederhana: setiap langkah adalah faktor 1000. 1 µF = 1000 nF = 1.000.000 pF, jadi 0,1 µF, 100 nF, dan 100.000 pF adalah nilai yang sama. Ketika simbol µ tidak tersedia, ditulis u sebagai gantinya (10uF), dan di skema lama kamu mungkin melihat MFD untuk mikrofarad. Nilai yang paling sering kamu temui di proyek Arduino adalah 22 pF, 100 nF (0,1 µF), 10 µF, 100 µF, dan 1000 µF.

Jenis kapasitor: keramik, elektrolit, tantalum, dan lainnya

• Keramik: Kecil, murah, dan tidak berpolaritas. Hambatan internalnya (ESR) sangat rendah, jadi kapasitor ini paling baik untuk menyaring noise cepat. Stabilitasnya bergantung pada dielektriknya: C0G (NP0) sangat stabil, X7R baik, sedangkan Y5V bisa kehilangan lebih dari setengah nilainya karena suhu dan tegangan yang diberikan.
• Elektrolit aluminium: Menawarkan kapasitansi besar dalam volume kecil, tapi berpolaritas dan cairan di dalamnya perlahan mengering. Badannya menunjukkan batas 85 °C atau 105 °C dan umur pada suhu itu (mis. 2000 jam); kira-kira, setiap 10 °C lebih dingin, umurnya dua kali lipat.
• Tantalum: Lebih kecil dan lebih stabil daripada elektrolit bernilai sama, tapi sensitif terhadap tegangan balik dan lonjakan arus; ketika rusak ia bisa terhubung singkat dan terbakar. Pilih yang rating-nya minimal dua kali tegangan kerjamu.
• Film: Tidak berpolaritas, stabil, dan rendah rugi-rugi; dipakai di rangkaian audio, pengaturan waktu presisi, dan filter listrik PLN 230 V (kelas X2). Kekurangannya, nilai besar memakan tempat.
• Superkapasitor: Punya kapasitansi dalam orde farad tapi hanya tahan sekitar 2,7 V per sel. Energinya tidak sebanyak baterai; sebagai gantinya ia bisa diisi dan dikosongkan dalam hitungan detik dan bertahan ratusan ribu siklus.

Cara membaca polaritas (+/−) dan rating tegangan

• Elektrolit through-hole: Kaki yang panjang positif (+), kaki yang pendek negatif (−). Garis berwarna terang di selubung berisi tanda minus dan menandai sisi negatif. Jika kakinya sudah dipotong, berpeganglah pada garis itu.
• Elektrolit SMD (tipe kaleng): Setengah lingkaran hitam atau berwarna di bagian atas menandai sisi negatif.
• Tantalum: Hati-hati, aturannya terbalik: garis atau strip pada kapasitor tantalum menandai kaki positif.
• Keramik dan film: Tidak berpolaritas; bisa dipasang ke arah mana pun.
• Di skema rangkaian: Kapasitor tanpa polaritas digambar sebagai dua garis lurus sejajar. Pada kapasitor berpolaritas, satu pelat digambar melengkung atau terisi, dan tanda + menandai sisi positif.

Rating tegangan di badannya (mis. 16 V, 25 V, 50 V) adalah tegangan DC tertinggi yang bisa ditahan kapasitor terus-menerus, dan tidak boleh pernah dilampaui. Aturan amannya adalah memilih kapasitor dengan rating minimal 1,5–2 kali tegangan tertinggi di rangkaian: pakai 10 V atau 16 V di rangkaian Arduino 5 V, 25 V dengan adaptor 12 V, dan 35 V atau 50 V pada 24 V. Tidak ada salahnya memakai rating yang lebih tinggi dari kebutuhan; komponennya hanya lebih besar dan sedikit lebih mahal.

Membaca kode kapasitor: apa arti 104?

Untuk menghemat tempat, kapasitor keramik dan film membawa nilainya sebagai kode tiga digit. Satuannya selalu pikofarad: dua digit pertama adalah angkanya dan digit ketiga adalah berapa nol yang ditambahkan. Jadi 104 = 10 diikuti 4 nol = 100.000 pF = 100 nF = 0,1 µF. Kode dua digit memberi nilai langsung dalam pF (22 = 22 pF), dan digit terakhir 0 tidak menambahkan nol (220 = 22 pF). Pada notasi huruf, hurufnya sekaligus menjadi satuan dan tanda desimal: 4n7 = 4,7 nF, 2p2 = 2,2 pF. Untuk memecahkan kode dengan cepat, pakai alat Kode kapasitor.

Huruf setelah kode menunjukkan toleransi: J = ±5%, K = ±10%, M = ±20%, Z = +80% / −20%. Kapasitor film juga bisa punya kode tegangan di depannya; misalnya 2A104J berarti 100 V (2A), 100 nF (104), dan ±5% (J). Kode tegangan yang umum adalah 1C = 16 V, 1H = 50 V, 2A = 100 V, dan 2J = 630 V. Kapasitor elektrolit tidak memakai kode; nilainya dicetak langsung (470 µF 16 V). Sebaliknya, kapasitor keramik SMD biasanya sama sekali tidak bertanda, jadi kamu hanya bisa mengetahui nilainya dari kemasan atau dengan mengukur.

Pengisian, pengosongan, dan konstanta waktu RC (τ = R·C)

Ketika kamu mengisi kapasitor lewat resistor, tegangannya tidak langsung melompat, melainkan naik mengikuti kurva eksponensial: Vc = Vs · (1 − e^(−t/RC)) (Vs adalah tegangan sumber, t waktu yang berlalu). Tegangannya turun dengan laju yang sama ketika dikosongkan: Vc = V0 · e^(−t/RC). Hasil kali R·C disebut konstanta waktu dan ditulis τ (tau); ohm dikali farad menghasilkan detik. Misalnya, dengan resistor 10 kΩ dan kapasitor 100 µF, τ = 10.000 × 0,0001 = 1 detik. Dengan 1 kΩ dan 100 nF, τ hanya 0,1 milidetik.

Dalam praktiknya, kapasitor dianggap terisi atau kosong sepenuhnya setelah sekitar 5τ; pada contoh 10 kΩ dan 100 µF itu berarti 5 detik. Perilaku ini menjadi dasar timer, rangkaian debounce tombol, lampu yang padam perlahan, dan chip 555. Untuk mengulang nilai resistor, baca Apa Itu Resistor?, dan untuk melihat bagaimana kurva berubah dengan nilai R dan C yang berbeda, coba alat Konstanta waktu RC. Kami menjelaskan hubungan tegangan, arus, dan hambatan secara rinci di Hukum Ohm.

Filter dan decoupling: kenapa ada 100 nF di samping setiap chip?

Mikrokontroler dan chip lain menarik pulsa arus pendek yang berlangsung nanodetik di setiap tepi clock. Jika catu daya letaknya jauh, induktansi kabel tidak bisa mengikuti permintaan mendadak ini; penurunan kecil dan noise muncul di jalur catu daya, dan akibatnya reset acak, pembacaan analog yang tidak bisa diandalkan, atau macet. Solusinya adalah memasang kapasitor keramik 100 nF di antara pin VCC dan GND setiap chip, sedekat mungkin. Kapasitor ini bertindak sebagai tandon energi mungil tepat di samping chip dan mengalirkan noise berfrekuensi tinggi ke GND. Ini disebut kapasitor decoupling atau bypass. Untuk perubahan beban yang lambat dan besar, elektrolit 10–1000 µF (kapasitor bulk) ditambahkan di input catu daya.

• 100 nF untuk setiap chip: Pasang di antara VCC dan GND dengan kaki pendek, sedekat mungkin dengan pin catu daya chip.
• Regulator linear seperti 7805: Produsen menganjurkan 0,33 µF di input dan 0,1 µF di output; dalam praktiknya sering juga ditambahkan 10–100 µF di output. Detailnya di regulator tegangan 7805.
• Motor servo: 100–470 µF di catu daya servo, dekat dengan servo, membantu mencegah Arduino reset ketika servo bergerak (Apa Itu Motor Servo?).
• LED strip WS2812B: Kapasitor 500–1000 µF dengan rating minimal 6,3 V dianjurkan di antara terminal + dan − adaptor (WS2812B NeoPixel).
• Motor DC: Keramik 100 nF yang disolder langsung di terminal motor sangat mengurangi noise listrik yang dihasilkan sikatnya (motor DC dengan L298N).
• Modul nirkabel: Arus melonjak tiba-tiba ketika mengirim. Menambahkan 10 µF di pin catu daya nRF24L01 dan 100–470 µF di antara 3,3 V dan GND ESP32 mengurangi koneksi yang putus dan reset brownout.

Menyambungkan resistor dan kapasitor secara seri menghasilkan filter low-pass: filter ini melewatkan frekuensi di bawah titik tertentu dan meredam yang di atasnya. Frekuensi cutoff-nya adalah fc = 1 / (2π · R · C). Output PWM Arduino Uno adalah gelombang kotak 490 Hz (980 Hz di pin 5 dan 6); dengan filter 10 kΩ dan 10 µF (fc ≈ 1,6 Hz), gelombang itu menjadi tegangan DC yang hampir rata, sehingga kamu mendapat output analog sederhana. Harganya adalah waktu respons: dengan τ = 0,1 dtk, butuh sekitar setengah detik untuk stabil di nilai baru. Selengkapnya di Apa Itu PWM?. Catu daya yang disearahkan juga disaring dengan kapasitor perata yang besar, dan riak yang tersisa kira-kira ΔV ≈ I / (f · C): dengan beban 1 A, penyearahan gelombang penuh 100 Hz, dan 4700 µF, riaknya sekitar 2,1 V.

Menyambungkan kapasitor secara seri dan paralel

Rumus kapasitor kebalikan persis dari rumus resistor. Pada sambungan paralel, kapasitansinya dijumlahkan: C = C1 + C2 + … sedangkan rating tegangannya mengikuti komponen dengan rating terendah. Pada sambungan seri, totalnya lebih kecil bahkan dari kapasitor terkecil: 1/C = 1/C1 + 1/C2 + … Dua kapasitor sama besar yang diseri menghasilkan setengah kapasitansinya, dan di atas kertas rating tegangannya dijumlahkan; tapi karena arus bocornya berbeda, tegangannya terbagi tidak merata, jadi resistor penyeimbang yang sama (mis. 100 kΩ) dipasang melintasi setiap kapasitor. Jika kamu tidak punya nilai yang dibutuhkan, kamu bisa membuatnya dari dua kapasitor; pakai alat C seri / paralel untuk perhitungannya, dan lihat perhitungan resistor seri dan paralel untuk padanan resistornya.

Percobaan kurva pengisian dengan Arduino: mengukur kapasitansi

Cara terbaik untuk melihat teorinya sendiri adalah mengukur tegangan kapasitor selagi ia terisi. Salah satu pin digital Arduino akan mengisi kapasitor lewat resistor 10 kΩ, dan input analog akan membaca tegangan kapasitor. Waktu yang dibutuhkan untuk mencapai 63,2% tegangan sumber adalah satu τ, dan dari situ kita menghitung kapasitansinya dengan C = τ / R. Yang kamu butuhkan: Arduino Uno, kapasitor elektrolit 100 µF, resistor 10 kΩ, breadboard, dan beberapa kabel jumper.

1. Pasang kapasitor di breadboard: kaki + di satu baris, kaki − di jalur GND.
2. Sambungkan satu ujung resistor 10 kΩ ke D8 dan ujung lainnya ke baris tempat kaki + kapasitor.
3. Tarik kabel dari baris yang sama ke A0, dan sambungkan GND Arduino ke jalur GND breadboard.
4. Upload kode di bawah dan buka Serial Monitor di 115200 baud.
5. Kode mengosongkan kapasitor dulu, lalu mengisinya; setiap 20 ms kode mencetak waktu yang berlalu dan tegangannya, dan di akhir menampilkan τ dan kapasitansi yang terukur.
6. Untuk melihat kurvanya sebagai grafik, atur PLOT menjadi true di kode, upload lagi, lalu buka 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}

Begini cara kerja kodenya: ketika pin diatur LOW, kapasitor dikosongkan lewat resistor 10 kΩ yang sama. Begitu pin menjadi HIGH, millis() mulai menghitung waktu; ketika pembacaan analog mencapai 647 (63,2% dari 1023), waktu yang berlalu disimpan sebagai τ. Ketika pembacaan mencapai 1010 (sekitar 99%), pengisian dianggap selesai. Dengan 100 µF dan 10 kΩ kamu seharusnya melihat kira-kira 1000 ms dan 100 µF. Kapasitor elektrolit biasanya punya toleransi ±20%, jadi hasil antara 80 dan 120 µF itu normal. Untuk lebih banyak tentang pengaturan waktu, lihat millis dan delay.

Percobaan yang sama dengan ESP32 dan Raspberry Pi Pico

Di ESP32 pin bekerja di 3,3 V dan ADC-nya 12 bit (0–4095). ADC ESP32 tidak linear di dekat ujung rentangnya, jadi alih-alih nilai mentah kita memakai analogReadMilliVolts(), yang mengembalikan milivolt yang sudah dikalibrasi. Untuk pin pembaca kita memilih GPIO 34 dari kelompok ADC1, yang tidak terpengaruh Wi-Fi. Karena ADC tidak bisa mengukur dengan andal di atas sekitar 3,1 V, kita mendeteksi akhir pengisian berdasarkan waktu, bukan tegangan: begitu τ ditemukan, pengukuran berhenti setelah 5τ. Untuk dasar-dasarnya, lihat Apa Itu 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}

Di Raspberry Pi Pico, percobaan yang sama hanya butuh beberapa baris MicroPython. Input analog Pico adalah GP26, GP27, dan GP28; read_u16() mengembalikan pengukuran 12 bit yang diskalakan ke rentang 0–65535. Kode mencetak waktu yang berlalu dan tegangan di setiap baris, jadi kamu bisa menyalin output-nya ke spreadsheet dan menggambar kurvanya sendiri. Jika kamu belum tahu cara menginstal MicroPython di Pico, mulailah dari Apa Itu 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")

Ide proyek dengan kapasitor

• Debounce hardware: Pasang 100 nF – 1 µF melintasi tombol; bersama pull-up 10 kΩ ini membentuk filter τ = 1–10 ms, dan pantulannya hilang sebelum mencapai kodemu.
• Tegangan analog dari PWM: Pakai filter RC untuk mengubah output PWM menjadi tegangan 0–5 V yang halus dan ukur dengan multimeter.
• LED berkedip dengan 555: Pada timer 555, dua resistor dan satu kapasitor menentukan frekuensinya: f ≈ 1,44 / ((R1 + 2·R2) · C). Hitung nilainya dengan alat timer 555.
• Lampu yang padam perlahan: Setelah saklar, pasang kapasitor 1000 µF melintasi catu daya LED dan resistornya; ketika kamu memutus daya dengan saklar, LED tidak langsung padam tapi meredup perlahan seiring kapasitor dikosongkan. Resistor dan kapasitansi bersama-sama menentukan lama meredupnya.
• Sensor kapasitif: Sensor kelembapan tanah kapasitif mengukur kapasitansi yang berubah karena air di dalam tanah; karena elektrodanya tidak terbuka, sensor ini tidak berkarat.
• Pengukur kapasitansi sederhana: Gabungkan percobaan di atas dengan LCD I2C dan tampilkan nilai kapasitormu di layar.

Kesalahan umum dan cara memperbaikinya

• Mengira 104 berarti 104 µF: 104 adalah 100 nF; kode tiga digit selalu dalam pikofarad.
• Memasang elektrolit terbalik: Kapasitor jadi panas, menggembung, atau meledak; kaki bergaris ke sisi GND (pada tantalum, garisnya positif).
• Memilih rating tegangan yang terlalu rendah: Kapasitor 10 V di jalur 12 V cepat rusak; sisakan margin minimal 1,5–2 kali.
• Memasang kapasitor decoupling terlalu jauh: Kapasitor 100 nF yang berjarak 10 cm dari chip kehilangan efeknya karena induktansi kabel; buat kakinya pendek dan pasang tepat di pin catu daya.
• Arduino reset ketika motor mulai berputar: Tegangan catu turun sesaat; beri daya motor secara terpisah, tambahkan 100–470 µF ke catu daya, dan satukan ground-nya (Kenapa Arduino-ku terus reset?).
• “Failed to connect to ESP32: Timed out waiting for packet header” di ESP32: Di beberapa board, rangkaian pemrograman otomatis salah mengatur waktu; menambahkan kapasitor 1–10 µF di antara EN dan GND sering membuatmu tidak perlu lagi menahan tombol BOOT.

Setelah resistor dan LED, kapasitor adalah komponen paling dasar yang perlu kamu pelajari; begitu kamu memahami τ = R·C dan membiasakan diri memasang 100 nF di samping setiap chip, rangkaianmu akan bekerja jauh lebih andal. Sebagai langkah berikutnya, lanjutkan ke induktor di Apa Itu Induktor?. Di aplikasi BlueGrays kamu akan menemukan proyek LED yang dikendalikan tombol, pengukuran cahaya dengan LDR, LED fade dengan PWM, dan WS2812B, lengkap dengan skema rangkaian dan kode langkah demi langkah, sehingga kamu bisa langsung mencoba apa yang kamu pelajari tentang kapasitor di rangkaian sungguhan.