O que é um capacitor? Tipos, código 104 e constante de tempo RC

Um capacitor é um componente básico de circuito que armazena carga elétrica entre duas placas condutoras que nunca se tocam e a libera de novo muito rápido quando é preciso. Pense nele como um reservatório de energia pequeno, mas muito rápido: ele fornece carga quando a tensão cai, engole picos repentinos, bloqueia a corrente contínua (CC) depois de carregado e, mesmo assim, deixa passar a corrente alternada (CA) e o ruído. Até um Arduino Uno tem vários capacitores; eles acalmam a linha de alimentação, evitam o repique dos botões, definem temporizações e transformam um sinal PWM em uma tensão suave.

Neste guia você vai aprender como um capacitor funciona, as unidades pF, nF e µF, a diferença entre os tipos cerâmico, eletrolítico e de tântalo, como ler a polaridade e a tensão nominal, o que significam códigos como 104, a constante de tempo RC (τ = R·C) e como ligar capacitores em série e em paralelo. No final, vamos fazer um experimento com Arduino, ESP32 e Raspberry Pi Pico que traça a curva de carga de um capacitor e mede a sua capacitância.

O que é um capacitor e como ele funciona?

Dentro de todo capacitor há duas superfícies condutoras separadas por uma camada isolante chamada dielétrico. Quando você aplica uma tensão nos terminais, elétrons se acumulam em uma placa e são puxados da outra; forma-se um campo elétrico entre as placas, e a energia fica guardada nesse campo. A carga armazenada é dada por Q = C · V, em que C é a capacitância em farads e V a tensão em volts. A energia armazenada é E = ½ · C · V²; por exemplo, um capacitor de 1000 µF carregado com 16 V guarda 0,128 joule. Corrente e tensão se relacionam por I = C · ΔV/Δt: o capacitor resiste a mudanças repentinas na sua tensão, e é exatamente por isso que ele suaviza a ondulação.

Você pode imaginar um capacitor como uma caixa-d'água: quando está vazia, enche rápido; o fluxo diminui conforme ela enche e, por fim, para. Por isso, em um circuito CC, nenhuma corrente passa pelo capacitor depois que ele está carregado. Conforme a frequência sobe, porém, o capacitor se opõe cada vez menos à corrente; essa oposição se chama reatância capacitiva e é calculada com Xc = 1 / (2π · f · C). Um capacitor de 100 nF apresenta cerca de 1,6 kΩ a 1 kHz, mas só 0,16 Ω a 10 MHz. Ou seja, ele é quase um curto-circuito para ruído de alta frequência, e esse é todo o segredo dos capacitores de desacoplamento.

Unidades de capacitância: pF, nF e µF

O farad é uma unidade enorme, então a eletrônica quase sempre usa os seus submúltiplos. A regra de conversão é simples: cada degrau é um fator de 1000. 1 µF = 1000 nF = 1.000.000 pF, então 0,1 µF, 100 nF e 100.000 pF são o mesmo valor. Quando o símbolo µ não está disponível, escreve-se um u no lugar (10uF), e em esquemas antigos você pode ver MFD para microfarad. Os valores que você mais vai encontrar em projetos com Arduino são 22 pF, 100 nF (0,1 µF), 10 µF, 100 µF e 1000 µF.

Tipos de capacitores: cerâmico, eletrolítico, de tântalo e outros

• Cerâmico: pequeno, barato e não polarizado. A resistência interna (ESR) é muito baixa, então ele é o melhor para filtrar ruído rápido. A estabilidade depende do dielétrico: C0G (NP0) é muito estável, X7R é bom, enquanto Y5V pode perder mais da metade do valor com a temperatura e a tensão aplicada.
• Eletrolítico de alumínio: oferece grande capacitância em pouco volume, mas é polarizado e o líquido interno seca devagar. O corpo mostra um limite de 85 °C ou 105 °C e a vida útil nessa temperatura (ex.: 2000 horas); grosso modo, cada 10 °C a menos dobra a vida útil.
• Tântalo: menor e mais estável que um eletrolítico de mesmo valor, mas sensível a tensão reversa e a surtos de corrente; quando falha, pode entrar em curto e queimar. Escolha um com tensão nominal de pelo menos o dobro da tensão de trabalho.
• Filme: não polarizado, estável e de baixa perda; usado em circuitos de áudio, temporização de precisão e filtros de rede de 230 V (classe X2). A desvantagem é que valores grandes ficam volumosos.
• Supercapacitor: tem capacitância na faixa dos farads, mas aguenta só cerca de 2,7 V por célula. Não guarda tanta energia quanto uma bateria; em compensação, carrega e descarrega em segundos e sobrevive a centenas de milhares de ciclos.

Como ler a polaridade (+/−) e a tensão nominal

• Eletrolítico PTH: o terminal longo é o positivo (+) e o curto, o negativo (−). A faixa clara na capa tem sinais de menos e marca o lado negativo. Se os terminais tiverem sido cortados, oriente-se pela faixa.
• Eletrolítico SMD (tipo lata): a meia-lua preta ou colorida no topo marca o lado negativo.
• Tântalo: cuidado, a regra é invertida: a faixa ou linha em um capacitor de tântalo marca o terminal positivo.
• Cerâmico e filme: não polarizados; podem ser colocados em qualquer sentido.
• Nos esquemas: um capacitor não polarizado é desenhado como duas linhas retas paralelas. Em um polarizado, uma das placas é desenhada curva ou preenchida, e um sinal + marca o lado positivo.

A tensão nominal no corpo (ex.: 16 V, 25 V, 50 V) é a maior tensão CC que o capacitor aguenta continuamente e nunca pode ser ultrapassada. A regra segura é escolher um capacitor com tensão nominal de pelo menos 1,5–2 vezes a maior tensão do circuito: use 10 V ou 16 V em um circuito de Arduino de 5 V, 25 V com uma fonte de 12 V e 35 V ou 50 V em 24 V. Não há problema em usar uma tensão nominal maior que a necessária; a peça só fica maior e um pouco mais cara.

Como ler os códigos de capacitores: o que significa 104?

Para economizar espaço, capacitores cerâmicos e de filme trazem o valor como um código de três dígitos. A unidade é sempre o picofarad: os dois primeiros dígitos são o número, e o terceiro é quantos zeros acrescentar. Então 104 = 10 seguido de 4 zeros = 100.000 pF = 100 nF = 0,1 µF. Códigos de dois dígitos dão o valor direto em pF (22 = 22 pF), e um último dígito 0 não acrescenta zeros (220 = 22 pF). Na notação com letra, a letra é ao mesmo tempo a unidade e a vírgula decimal: 4n7 = 4,7 nF, 2p2 = 2,2 pF. Para decodificar rapidamente, use a ferramenta Código de capacitores.

Uma letra depois do código indica a tolerância: J = ±5%, K = ±10%, M = ±20%, Z = +80% / −20%. Capacitores de filme também podem ter um código de tensão na frente; por exemplo, 2A104J significa 100 V (2A), 100 nF (104) e ±5% (J). Os códigos de tensão comuns são 1C = 16 V, 1H = 50 V, 2A = 100 V e 2J = 630 V. Capacitores eletrolíticos não usam códigos; o valor vem impresso diretamente (470 µF 16 V). Já os capacitores cerâmicos SMD normalmente não têm marcação nenhuma, então você só descobre o valor pela embalagem ou medindo.

Carga, descarga e a constante de tempo RC (τ = R·C)

Quando você carrega um capacitor através de um resistor, a tensão dele não salta na hora, mas sobe seguindo uma curva exponencial: Vc = Vs · (1 − e^(−t/RC)) (Vs é a tensão da fonte e t o tempo decorrido). Ela cai no mesmo ritmo na descarga: Vc = V0 · e^(−t/RC). O produto R·C se chama constante de tempo e é escrito τ (tau); multiplicar ohms por farads dá segundos. Por exemplo, com um resistor de 10 kΩ e um capacitor de 100 µF, τ = 10.000 × 0,0001 = 1 segundo. Com 1 kΩ e 100 nF, τ é só 0,1 milissegundo.

Na prática, um capacitor é considerado totalmente carregado ou descarregado depois de cerca de 5τ; no exemplo de 10 kΩ e 100 µF, isso dá 5 segundos. Esse comportamento é a base de temporizadores, circuitos de debounce de botões, lâmpadas que apagam devagar e do chip 555. Para revisar os valores de resistores, leia O que é um resistor?, e para ver como a curva muda com diferentes valores de R e C, experimente a ferramenta Constante de tempo RC. Explicamos em detalhe a relação entre tensão, corrente e resistência em Lei de Ohm.

Filtragem e desacoplamento: por que há um 100 nF ao lado de cada chip?

Microcontroladores e outros chips puxam pulsos curtos de corrente, de nanossegundos, a cada borda do clock. Se a fonte de alimentação está longe, a indutância dos fios não acompanha essas demandas repentinas; surgem pequenas quedas e ruído na linha de alimentação, e o resultado são resets aleatórios, leituras analógicas instáveis ou travamentos. A solução é colocar um capacitor cerâmico de 100 nF entre os pinos VCC e GND de cada chip, o mais perto possível. Ele age como um pequeno reservatório de energia bem ao lado do chip e desvia o ruído de alta frequência para o GND. Isso se chama capacitor de desacoplamento ou de bypass. Para mudanças de carga lentas e grandes, acrescenta-se um eletrolítico de 10–1000 µF (um capacitor de reserva, ou bulk) na entrada da alimentação.

• 100 nF para cada chip: coloque entre VCC e GND com terminais curtos, o mais perto possível do pino de alimentação do chip.
• Reguladores lineares como o 7805: o fabricante recomenda 0,33 µF na entrada e 0,1 µF na saída; na prática, muitas vezes se acrescentam 10–100 µF na saída também. Detalhes em Regulador de tensão 7805.
• Servo motores: 100–470 µF na alimentação do servo, perto dele, ajudam a evitar que o Arduino reinicie quando o servo se move (O que é um servo motor?).
• Fitas de LED WS2812B: recomenda-se um capacitor de 500–1000 µF com tensão nominal de pelo menos 6,3 V entre os terminais + e − da fonte (WS2812B NeoPixel).
• Motores CC: um cerâmico de 100 nF soldado direto nos terminais do motor reduz muito o ruído elétrico gerado pelas escovas (Motor CC com L298N).
• Módulos sem fio: a corrente salta de repente durante a transmissão. Acrescentar 10 µF nos pinos de alimentação do nRF24L01 e 100–470 µF entre o 3,3 V e o GND do ESP32 reduz as quedas de conexão e os resets por brownout.

Ligar um resistor e um capacitor em série dá um filtro passa-baixa: ele deixa passar as frequências abaixo de um certo ponto e atenua as que ficam acima. A frequência de corte é fc = 1 / (2π · R · C). A saída PWM do Arduino Uno é uma onda quadrada de 490 Hz (980 Hz nos pinos 5 e 6); com um filtro de 10 kΩ e 10 µF (fc ≈ 1,6 Hz), essa onda vira uma tensão CC quase plana, o que dá uma saída analógica simples. O preço é o tempo de resposta: com τ = 0,1 s, leva cerca de meio segundo para assentar em um novo valor. Mais em O que é PWM?. Uma alimentação retificada também é filtrada com um capacitor grande de filtragem, e a ondulação que sobra é aproximadamente ΔV ≈ I / (f · C): com uma carga de 1 A, retificação de onda completa de 100 Hz e 4700 µF, isso dá cerca de 2,1 V.

Como ligar capacitores em série e em paralelo

As fórmulas de capacitores são exatamente o contrário das de resistores. Em paralelo, as capacitâncias se somam: C = C1 + C2 + …, e a tensão nominal é a da peça de menor tensão. Em série, o total fica menor até que o menor capacitor: 1/C = 1/C1 + 1/C2 + … Dois capacitores iguais em série dão metade da capacitância e, no papel, as tensões nominais se somam; mas, como as correntes de fuga são diferentes, a tensão se divide de forma desigual, então resistores de equalização iguais (ex.: 100 kΩ) são colocados em paralelo com cada capacitor. Se você não tem o valor que precisa, pode montá-lo com dois capacitores; use a ferramenta C em série / paralelo para as contas e veja cálculo de resistores em série e em paralelo para o equivalente com resistores.

Experimento da curva de carga com Arduino: meça a capacitância

A melhor forma de ver a teoria com os próprios olhos é medir a tensão de um capacitor enquanto ele carrega. Um pino digital do Arduino vai carregar o capacitor através de um resistor de 10 kΩ, e uma entrada analógica vai ler a tensão do capacitor. O tempo que ele leva para chegar a 63,2% da tensão da fonte é um τ e, a partir dele, calculamos a capacitância com C = τ / R. Você vai precisar de: um Arduino Uno, um capacitor eletrolítico de 100 µF, um resistor de 10 kΩ, uma protoboard e alguns jumpers.

1. Encaixe o capacitor na protoboard: o terminal + em uma fileira e o terminal − no barramento de GND.
2. Ligue uma ponta do resistor de 10 kΩ ao D8 e a outra ponta à fileira do terminal + do capacitor.
3. Passe um fio da mesma fileira até o A0 e ligue o GND do Arduino ao barramento de GND da protoboard.
4. Carregue o código abaixo e abra o Monitor Serial em 115200 baud.
5. O código primeiro descarrega o capacitor e depois o carrega; a cada 20 ms ele mostra o tempo decorrido e a tensão e, no final, exibe o τ e a capacitância medidos.
6. Para ver a curva como gráfico, mude PLOT para true no código, carregue de novo e abra Ferramentas > Plotter Serial.

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}

Veja como o código funciona: quando o pino vai a LOW, o capacitor descarrega pelo mesmo resistor de 10 kΩ. No instante em que o pino vai a HIGH, o millis() começa a contar; quando a leitura analógica chega a 647 (63,2% de 1023), o tempo decorrido é guardado como τ. Quando a leitura chega a 1010 (cerca de 99%), a carga é considerada completa. Com 100 µF e 10 kΩ você deve ver aproximadamente 1000 ms e 100 µF. Capacitores eletrolíticos costumam ter tolerância de ±20%, então resultados entre 80 e 120 µF são normais. Para saber mais sobre temporização, veja millis e delay.

O mesmo experimento com ESP32 e Raspberry Pi Pico

No ESP32, os pinos trabalham em 3,3 V e o ADC é de 12 bits (0–4095). O ADC do ESP32 não é linear perto das pontas da faixa, então, em vez de valores brutos, usamos analogReadMilliVolts(), que retorna milivolts calibrados. Para o pino de leitura escolhemos o GPIO 34, do grupo ADC1, que não é afetado pelo Wi-Fi. Como o ADC não mede com confiança acima de cerca de 3,1 V, detectamos o fim da carga pelo tempo e não pela tensão: depois de encontrar o τ, a medição para em 5τ. Para o básico, veja O que é o 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}

No Raspberry Pi Pico, o mesmo experimento leva só algumas linhas de MicroPython. As entradas analógicas do Pico são GP26, GP27 e GP28; read_u16() retorna a medição de 12 bits escalada para a faixa de 0–65535. O código mostra o tempo decorrido e a tensão em cada linha, então você pode copiar a saída para uma planilha e desenhar a curva você mesmo. Se não sabe como instalar o MicroPython no Pico, comece por O que é o 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")

Ideias de projetos com capacitores

• Debounce por hardware: coloque 100 nF – 1 µF em paralelo com o botão; junto com um pull-up de 10 kΩ isso forma um filtro de τ = 1–10 ms, e os repiques morrem antes de chegar ao seu código.
• Tensão analógica a partir de PWM: use um filtro RC para transformar uma saída PWM em uma tensão suave de 0–5 V e meça-a com um multímetro.
• LED piscante com 555: no temporizador 555, dois resistores e um capacitor definem a frequência: f ≈ 1,44 / ((R1 + 2·R2) · C). Calcule os valores com a ferramenta Temporizador 555.
• Lâmpada que apaga devagar: depois da chave, coloque um capacitor de 1000 µF na alimentação do LED e do seu resistor; quando você corta a alimentação na chave, o LED não apaga na hora, mas vai sumindo devagar conforme o capacitor descarrega. O resistor e a capacitância juntos definem o tempo de apagamento.
• Sensores capacitivos: um sensor capacitivo de umidade do solo mede a capacitância alterada pela água na terra; como os eletrodos não ficam expostos, ele não sofre corrosão.
• Capacímetro simples: combine o experimento acima com um LCD I2C e mostre na tela o valor dos seus capacitores.

Erros comuns e como corrigi-los

• Achar que 104 significa 104 µF: 104 é 100 nF; códigos de três dígitos são sempre em picofarads.
• Montar um eletrolítico ao contrário: o capacitor esquenta, estufa ou estoura; o terminal com a faixa vai para o lado do GND (no tântalo, a faixa é o positivo).
• Escolher uma tensão nominal baixa demais: um capacitor de 10 V em uma linha de 12 V falha rápido; deixe uma margem de pelo menos 1,5–2 vezes.
• Colocar o capacitor de desacoplamento longe: um capacitor de 100 nF a 10 cm do chip perde o efeito por causa da indutância dos fios; mantenha os terminais curtos e coloque-o bem nos pinos de alimentação.
• O Arduino reinicia quando um motor liga: a tensão de alimentação cai por um instante; alimente o motor separadamente, acrescente 100–470 µF à alimentação e ligue os GNDs juntos (Por que o meu Arduino fica reiniciando?).
• “Failed to connect to ESP32: Timed out waiting for packet header” no ESP32: em algumas placas, o circuito de programação automática erra o tempo; acrescentar um capacitor de 1–10 µF entre EN e GND muitas vezes dispensa segurar o botão BOOT.

Depois dos resistores e LEDs, o capacitor é a peça mais fundamental que você precisa aprender; quando você entende τ = R·C e cria o hábito de colocar um 100 nF ao lado de cada chip, os seus circuitos passam a funcionar de forma muito mais confiável. Como próximo passo, passe para o indutor em O que é um indutor?. No app BlueGrays você encontra projetos de LED controlado por botão, medição de luz com LDR, LED com fade por PWM e WS2812B, com esquemas do circuito e código passo a passo, para testar logo em circuitos reais o que aprendeu sobre capacitores.