Conversão de nF para µF: códigos de capacitores e unidades da eletrônica
Conversão de nF para µF sem complicação: tabela pF-nF-µF, códigos de capacitor 104 e 2n2, kΩ, mA, mV e mAh para Wh, além dos erros de unidade mais comuns em código para Arduino e ESP32.
A conversão de nF para µF se resume a uma regra: 1 µF = 1000 nF e 1 nF = 1000 pF. Para ir de nF para µF você divide por 1000, e para ir de µF para nF você multiplica por 1000: 100 nF = 0,1 µF, 4,7 µF = 4700 nF. O 104 impresso em um capacitor cerâmico significa exatamente esses mesmos 100 nF, ou 0,1 µF. Quase toda conversão de unidades na eletrônica funciona nesses degraus de mil, então, quando os prefixos fazem sentido, as contas com resistores, corrente, tensão e baterias também ficam mais fáceis.
Neste guia, reunimos os prefixos p, n, µ, m, k e M em uma única tabela. Você vai aprender a ler códigos de capacitores (104, 2n2, 474J), a notação 4K7 e R47 dos resistores, a passar de mA para A ou de mV para V, a converter a capacidade de baterias de mAh para Wh e os atalhos de unidades que permitem fazer a lei de Ohm de cabeça. Na última parte, vamos ver os erros de unidade mais comuns em código para Arduino, ESP32 e Raspberry Pi Pico, e como escrevê-los do jeito certo.

Prefixos do SI: o que significam p, n, µ, m, k e M?
Os valores na eletrônica cobrem uma faixa enorme: a corrente de um microcontrolador em modo sleep é de alguns microampères, enquanto um motor consome alguns ampères, e um capacitor ao lado de um cristal pode ter 22 picofarads, enquanto o da saída de uma fonte tem 2200 microfarads. Por isso usamos um prefixo em vez de escrever longas fileiras de zeros. Cada prefixo multiplica a unidade base por uma potência de 10, e os que se usam na eletrônica ficam todos a 1000 vezes um do outro. As regras são as mesmas para volts, ampères, ohms, farads, henrys, watts e hertz.
| Prefixo | Símbolo | Multiplicador | Exemplo na eletrônica |
|---|---|---|---|
| pico | p | 10⁻¹² (0,000 000 000 001) | Capacitor de carga de cristal de 22 pF |
| nano | n | 10⁻⁹ (0,000 000 001) | Capacitor de desacoplamento de 100 nF, período de clock de 62,5 ns |
| micro | µ (u) | 10⁻⁶ (0,000 001) | Capacitor de 10 µF, corrente de 10 µA em modo sleep |
| mili | m | 10⁻³ (0,001) | Corrente de LED de 20 mA, passo do ADC de 4,88 mV |
| (unidade base) | - | 1 | 5 V, 1 A, 1 Ω, 1 F |
| quilo | k | 10³ (1000) | Resistor de pull-up de 10 kΩ, portadora IR de 38 kHz |
| mega | M | 10⁶ (1 000 000) | Resistência de entrada de 1 MΩ, clock de 16 MHz |
| giga | G | 10⁹ | Wi-Fi e Bluetooth em 2,4 GHz |
Tabela de conversão de pF, nF e µF
O que mais confunde nos capacitores é que o mesmo valor pode ser escrito em três unidades diferentes. Um esquema diz 0,1 µF, uma loja online diz 100 nF, o próprio componente diz 104, e os três são o mesmo capacitor. Para converter nF em µF, divida por 1000; para converter pF em nF, divida por 1000 de novo. No sentido contrário, multiplique por 1000. A tabela abaixo lista os valores mais comuns junto com os códigos que você vai encontrar impressos neles; vale a pena imprimir e pendurar acima da bancada.
| pF | nF | µF | Código |
|---|---|---|---|
| 10 pF | 0,01 nF | 0,00001 µF | 100 |
| 22 pF | 0,022 nF | 0,000022 µF | 220 |
| 100 pF | 0,1 nF | 0,0001 µF | 101 |
| 1000 pF | 1 nF | 0,001 µF | 102 |
| 2200 pF | 2,2 nF (2n2) | 0,0022 µF | 222 |
| 4700 pF | 4,7 nF (4n7) | 0,0047 µF | 472 |
| 10.000 pF | 10 nF | 0,01 µF | 103 |
| 47.000 pF | 47 nF | 0,047 µF | 473 |
| 100.000 pF | 100 nF | 0,1 µF | 104 |
| 220.000 pF | 220 nF | 0,22 µF | 224 |
| 470.000 pF | 470 nF | 0,47 µF | 474 |
| 1.000.000 pF | 1000 nF | 1 µF | 105 |
| 10.000.000 pF | 10.000 nF | 10 µF | 106 |
Como ler códigos de capacitores: quanto é 104 em nF?
Os pequenos capacitores cerâmicos e de filme não têm espaço para o valor completo, então trazem um código de três dígitos, e a unidade desse código é sempre o picofarad. Os dois primeiros dígitos são o valor em si, e o terceiro é a quantidade de zeros a acrescentar. No 104, você coloca quatro zeros depois do 10: 100.000 pF, ou seja, 100 nF ou 0,1 µF. Se você prefere não decodificar de cabeça, a calculadora de código de capacitor faz isso em um segundo; como os capacitores realmente funcionam está no nosso guia O que é um capacitor?.
- Anote os dois primeiros dígitos: 47 no caso de 474.
- Acrescente tantos zeros quanto o terceiro dígito indicar: 47 mais 4 zeros dá 470.000 pF.
- Divida por 1000 para chegar em nF: 470.000 pF = 470 nF.
- Divida por 1000 mais uma vez para chegar em µF: 470 nF = 0,47 µF.
- Confira a letra depois do código: J significa tolerância de ±5%, K de ±10% e M de ±20%. Um 474J é um capacitor de 0,47 µF com tolerância de ±5%.
- Um prefixo como 2A ou 1H na frente do código é a tensão nominal: 1H = 50 V, 2A = 100 V, 2J = 630 V.
| Marcação | Significado | Valor |
|---|---|---|
| 2n2 | O n fica no lugar da vírgula | 2,2 nF = 2200 pF |
| 4n7 | O n fica no lugar da vírgula | 4,7 nF = 4700 pF |
| µ1 ou u1 | O µ fica no lugar da vírgula | 0,1 µF = 100 nF |
| 4µ7 | O µ fica no lugar da vírgula | 4,7 µF |
| p68 | O p fica no lugar da vírgula | 0,68 pF |
| 109 | Terceiro dígito 9 = ×0,1 | 1,0 pF |
| 104Z | Z = tolerância de +80% / -20% | 100 nF |
| 35 MFD | Notação antiga: MFD = microfarad | 35 µF |
Unidades de resistores: Ω, kΩ, MΩ e a notação 4K7
A unidade base dos resistores é o ohm (Ω), mas a maioria dos valores que você vai ver em circuitos com Arduino fica na faixa dos quilo-ohms: um resistor de 220 Ω para LED, um pull-up de 10 kΩ, uma entrada de alta impedância de 1 MΩ. Esquemas e listas de componentes usam uma letra no lugar do separador decimal, porque um sinal minúsculo pode sumir na impressão, e uma letra não. R significa ohms, K quilo-ohms e M megaohms, e a posição da letra é a posição da vírgula. Para decifrar as faixas coloridas do corpo do componente, veja o nosso guia de código de cores dos resistores ou a calculadora de código de cores; para códigos como 103 e 4701 em componentes SMD, leia códigos de resistores SMD.
| Notação | Valor | Em ohms |
|---|---|---|
| R47 | 0,47 Ω | 0,47 Ω |
| 2R2 | 2,2 Ω | 2,2 Ω |
| 220R | 220 Ω | 220 Ω |
| 1K | 1 kΩ | 1000 Ω |
| 4K7 | 4,7 kΩ | 4700 Ω |
| 47K | 47 kΩ | 47.000 Ω |
| 1M0 | 1 MΩ | 1.000.000 Ω |
| 103 (SMD) | 10 mais 3 zeros | 10.000 Ω = 10 kΩ |
| 4701 (SMD, 4 dígitos) | 470 mais 1 zero | 4700 Ω = 4,7 kΩ |
O código de três dígitos funciona do mesmo jeito em resistores e indutores, mas a unidade base muda: picofarads em um capacitor, ohms em um resistor SMD e microhenrys em um indutor. Assim, 101 em um capacitor são 100 pF, 101 em um resistor SMD são 100 Ω e 101 em um indutor são 100 µH. Nunca interprete um código sem saber em que tipo de componente ele está.
Corrente e tensão: como converter mA em A, µA e mV em V
Com corrente, você vai passar quase sempre de mA para A e vice-versa: 1 A = 1000 mA e 1 mA = 1000 µA. Um LED que consome 20 mA está consumindo 0,02 A; os 10 µA que um ESP32 consome em deep sleep são 0,01 mA, ou 0,00001 A. A tensão usa os mesmos degraus: 1 V = 1000 mV. O ADC de 10 bits do Arduino Uno divide 5 V em 1024 partes, então cada passo vale 5 / 1024 = 0,00488 V, ou 4,88 mV. Os datasheets de sensores trazem relações como mV por grau (10 mV/°C no LM35) ou mV por ampère (185 mV/A no ACS712-5A), e usar essas relações na unidade certa define a precisão da sua medição. A leitura analógica é explicada em detalhes em O que é ADC?.
| Situação | Valor típico | Em unidades base |
|---|---|---|
| Corrente por pino do Arduino Uno (recomendada / máxima absoluta) | 20 mA / 40 mA | 0,02 A / 0,04 A |
| Corrente de operação de um LED vermelho | 10-20 mA | 0,01-0,02 A |
| ESP32 durante uma transmissão Wi-Fi | até 250 mA | 0,25 A |
| Corrente do chip ESP32 em deep sleep | cerca de 10 µA | 0,00001 A |
| Passo do ADC do Arduino Uno (5 V, 10 bits) | 4,88 mV | 0,00488 V |
| Passo do ADC do ESP32 e do Pico (3,3 V, 12 bits) | cerca de 0,8 mV | 0,0008 V |
| Corrente de travamento do servo SG90 | 650-700 mA | cerca de 0,7 A |
Atalhos de unidades para a lei de Ohm: V, mA e kΩ
Você não precisa converter todos os valores para as unidades base antes de calcular. Se você combinar os prefixos de modo que eles se cancelem, o resultado já sai na unidade certa. A combinação mais prática é esta: volts divididos por quilo-ohms dão miliampères. Aplique 5 V sobre um resistor de pull-up de 10 kΩ e passam 5 / 10 = 0,5 mA, sem zeros para administrar. Pela mesma lógica, miliampères vezes quilo-ohms dão volts, e volts vezes miliampères dão miliwatts. Isso vale também para o tempo de carga de um capacitor: quilo-ohms vezes microfarads dão milissegundos. Para relembrar o básico, leia Lei de Ohm, ou use a calculadora da lei de Ohm para uma resposta rápida.
| Fórmula | Combinação de unidades | Exemplo |
|---|---|---|
| I = V / R | V / kΩ = mA | 5 V / 10 kΩ = 0,5 mA |
| R = V / I | V / mA = kΩ | (5 V - 2 V) / 20 mA = 0,15 kΩ = 150 Ω |
| V = I × R | mA × kΩ = V | 2 mA × 4,7 kΩ = 9,4 V |
| P = V × I | V × mA = mW | 5 V × 20 mA = 100 mW |
| τ = R × C | kΩ × µF = ms | 10 kΩ × 100 µF = 1000 ms = 1 s |
| τ = R × C | kΩ × nF = µs | 10 kΩ × 100 nF = 1000 µs = 1 ms |
| τ = R × C | MΩ × µF = s | 1 MΩ × 10 µF = 10 s |
mAh e Wh: como converter a capacidade da bateria
O mAh (miliampère-hora) diz quanta corrente uma bateria consegue fornecer e por quantas horas, enquanto o Wh (watt-hora) diz quanta energia existe de fato dentro dela. Você precisa do Wh para comparar baterias de tensões diferentes, porque uma pilha AA de 2000 mAh e uma célula de lítio de 2000 mAh não guardam a mesma energia. A fórmula de conversão é simples: Wh = mAh × V / 1000. Uma célula 18650 de 2600 mAh e 3,7 V guarda 2600 × 3,7 / 1000 = 9,62 Wh. O limite de 100 Wh que as companhias aéreas impõem aos power banks na bagagem de mão equivale a cerca de 27.000 mAh em 3,7 V.
Para estimar a autonomia, divida a capacidade pela corrente média: horas = mAh / mA. Na prática, não dá para usar a bateria inteira e o regulador desperdiça parte da energia, então multiplicar o resultado por 0,7 a 0,8 é mais realista. Um projeto com ESP32 que consome 80 mA em média funciona por cerca de 2600 / 80 × 0,8 = 26 horas com uma célula de 2600 mAh. Os 10.000 mAh impressos em um power bank se referem às suas células de 3,7 V; depois de elevada para 5 V com cerca de 85% de eficiência, sobram em torno de 10.000 × 3,7 × 0,85 / 5 ≈ 6300 mAh de capacidade útil. Para a conta detalhada, leia O que significa mAh? ou experimente a calculadora de autonomia da bateria.
| Bateria | Capacidade | Tensão | Energia |
|---|---|---|---|
| Bateria tipo moeda CR2032 | 220 mAh | 3 V | 0,66 Wh |
| Pilha AA alcalina | cerca de 2500 mAh | 1,5 V | cerca de 3,75 Wh |
| Bateria alcalina de 9 V | cerca de 500 mAh | 9 V | cerca de 4,5 Wh |
| LiPo de 1000 mAh | 1000 mAh | 3,7 V | 3,7 Wh |
| Li-ion 18650 | 2600 mAh | 3,7 V | 9,62 Wh |
| Power bank de 10.000 mAh | 10.000 mAh | 3,7 V (célula) | 37 Wh |
Tempo e frequência: ms, µs, Hz, kHz e MHz
Frequência e período são o inverso um do outro: T = 1 / f. Como um hertz é uma vez por segundo, o inverso de kHz sai em ms e o inverso de MHz, em µs. Os servomotores são acionados a 50 Hz, então chega um pulso a cada 1 / 50 = 0,02 s = 20 ms. A maioria dos pinos PWM do Arduino Uno trabalha em cerca de 490 Hz, com período de 2,04 ms; os pinos 5 e 6 trabalham em 980 Hz, com período de 1,02 ms (mais em O que é PWM?). Com um clock de 16 MHz, um ciclo de clock dura 62,5 ns. Também não confunda as duas funções de tempo do Arduino: millis() retorna milissegundos, micros() retorna microssegundos, e delayMicroseconds() só é precisa até 16.383 µs; para esperas mais longas, use a temporização com millis.
As unidades de velocidade dependem das mesmas conversões. No sensor de distância HC-SR04, a velocidade do som é de 343 m/s; convertida para cm/µs, isso dá 34.300 cm / 1.000.000 µs = 0,0343 cm/µs. Como o sensor informa o tempo de ida e volta do eco, distância = tempo (µs) × 0,0343 / 2, de modo que um eco de 1000 µs significa 17,15 cm. Depois que você sabe de onde vem esse 0,0343, consegue calcular sozinho o fator certo quando quiser o resultado em metros ou em polegadas.
Erros de unidade no código Arduino: como converter leituras do ADC em mV e V
Mesmo quando a conversão está certa no papel, duas armadilhas esperam no código. A primeira é o estouro de int: no Arduino Uno, um int guarda no máximo 32.767, mas 1023 × 5000 dá 5.115.000, então o resultado é lixo. A segunda é a divisão inteira: 4700 / 1000 dá 4, e não 4,7, porque dividir dois inteiros joga fora a parte fracionária. A solução é fazer a multiplicação como long e escrever 1000.0 em vez de 1000 quando você quiser um resultado decimal. O sketch abaixo converte corretamente a tensão em A0 para mV e V e depois calcula a tensão real de entrada de um divisor de tensão de 10 kΩ e 4,7 kΩ.
1// ADC değerini mV ve V'a çevirme / Converting ADC readings to mV and V
2const int SENSOR_PIN = A0;
3const long VREF_MV = 5000; // Uno referansı 5000 mV / Uno reference 5000 mV
4const float R1_KOHM = 10.0; // üst direnç 10 kΩ / top resistor 10 kΩ
5const float R2_KOHM = 4.7; // alt direnç 4,7 kΩ / bottom resistor 4.7 kΩ
6
7void setup() {
8 Serial.begin(9600);
9}
10
11void loop() {
12 int raw = analogRead(SENSOR_PIN); // 0-1023
13
14 // YANLIŞ: int ile raw * 5000 taşar / WRONG: raw * 5000 overflows an int
15 // int wrongMv = raw * 5000 / 1024;
16
17 long mv = (long)raw * VREF_MV / 1024; // doğru: long ile mV / correct: mV using long
18 float volts = mv / 1000.0; // mV -> V, 1000.0 ondalıklı böler / 1000.0 keeps decimals
19 float vin = volts * (R1_KOHM + R2_KOHM) / R2_KOHM; // kΩ / kΩ birimsizdir / kΩ over kΩ is unitless
20
21 Serial.print("ham / raw: "); Serial.print(raw);
22 Serial.print(" mV: "); Serial.print(mv);
23 Serial.print(" V: "); Serial.print(volts, 3);
24 Serial.print(" Vin: "); Serial.println(vin, 2);
25 delay(500);
26}O cast (long)raw faz a multiplicação acontecer em 32 bits, então nada estoura. Dividimos por 1024 porque essa é a fórmula do datasheet do ATmega328P; a diferença em relação a 1023 fica em torno de 0,1 por cento. Escrever os resistores do divisor em kΩ não é problema, porque as unidades se cancelam na razão. Com esse divisor, A0 recebe no máximo 5 V, enquanto você consegue medir até cerca de 15,6 V na entrada.
Decodificador de código de capacitor: digite 104 no Monitor Serial
Para que a decodificação vire algo automático, vamos escrever uma pequena ferramenta. O programa abaixo lê o código de três dígitos que você digita no Monitor Serial e mostra o valor em pF, nF e µF. Ele também trata os casos especiais em que o terceiro dígito é 8 ou 9 (×0,01 e ×0,1). Basta definir o final de linha do Monitor Serial como “Nova linha”.
1// Kondansatör kodu çözücü / Capacitor code decoder
2// Seri Monitör'e 104, 222, 475 gibi bir kod yaz / Type a code such as 104, 222 or 475
3
4void printValue(float pf) {
5 Serial.print(pf, 1); Serial.print(F(" pF = "));
6 Serial.print(pf / 1000.0, 3); Serial.print(F(" nF = "));
7 Serial.print(pf / 1000000.0, 6); Serial.println(F(" uF"));
8}
9
10void setup() {
11 Serial.begin(9600);
12 Serial.println(F("Kod yaz (or. 104) / Type a code (e.g. 104)"));
13}
14
15void loop() {
16 if (!Serial.available()) return;
17 String code = Serial.readStringUntil('\n');
18 code.trim();
19
20 if (code.length() != 3 || !isDigit(code[0]) || !isDigit(code[1]) || !isDigit(code[2])) {
21 Serial.println(F("3 haneli kod yaz / Enter a 3-digit code"));
22 return;
23 }
24
25 int digits = (code[0] - '0') * 10 + (code[1] - '0'); // ilk iki hane / first two digits
26 int mult = code[2] - '0'; // üçüncü hane / third digit
27 float pf = digits;
28
29 if (mult == 9) pf *= 0.1; // 9 = ×0,1 / 9 means ×0.1
30 else if (mult == 8) pf *= 0.01; // 8 = ×0,01 / 8 means ×0.01
31 else for (int i = 0; i < mult; i++) pf *= 10; // sıfır ekle / append zeros
32
33 Serial.print(code); Serial.print(F(" -> "));
34 printValue(pf);
35}Conversões de unidades no ESP32 e no Raspberry Pi Pico
O ADC do ESP32 é de 12 bits e retorna 0-4095, mas os pinos trabalham em 3,3 V e o ADC desvia um pouco de forma diferente em cada placa. Por isso, é melhor usar a função analogReadMilliVolts() do core do que converter o valor bruto por conta própria: ela usa a calibração gravada no chip na fábrica e retorna milivolts diretamente. Com a atenuação padrão de 11 dB, a faixa mensurável vai até cerca de 3,1 V, e os resultados mais precisos ficam entre 0,15 e 2,45 V.
1// ESP32: ham ADC değeri ve kalibrasyonlu mV / raw ADC value and calibrated mV
2const int ADC_PIN = 34; // yalnız giriş pini, ADC1 / input-only pin, ADC1
3
4void setup() {
5 Serial.begin(115200);
6 analogReadResolution(12); // 0-4095
7}
8
9void loop() {
10 int raw = analogRead(ADC_PIN);
11 unsigned long mv = analogReadMilliVolts(ADC_PIN); // fabrika kalibrasyonu / factory calibration
12 float volts = mv / 1000.0; // mV -> V
13 Serial.printf("ham/raw: %d mV: %lu V: %.3f\n", raw, mv, volts);
14 delay(500);
15}No Raspberry Pi Pico, o read_u16() do MicroPython escala o valor para 0-65535, embora o ADC seja de 12 bits. Portanto, o fator de conversão tem de ser 3.3 / 65535, e não 3.3 / 4095; usar o errado deixa o seu resultado 16 vezes maior. A resolução real continua sendo 3,3 V / 4096 ≈ 0,8 mV.
1# Pico: ADC değerini mV ve V'a çevirme / converting ADC readings to mV and V
2from machine import ADC
3import time
4
5adc = ADC(26) # GP26 = ADC0
6CONV = 3.3 / 65535 # read_u16() 0-65535 aralığı / range of read_u16()
7
8while True:
9 raw = adc.read_u16()
10 volts = raw * CONV
11 mv = volts * 1000 # V -> mV
12 print("ham/raw:", raw, " mV:", round(mv), " V:", round(volts, 3))
13 time.sleep(0.5)Erros de unidade comuns e como corrigi-los
- Confundir m com M: 1 mΩ (miliohm) e 1 MΩ (megaohm) estão a um bilhão de vezes um do outro. O m minúsculo é mili e o M maiúsculo é mega, então preste atenção ao tamanho da letra no esquema.
- Ler 104 como 104 pF: o terceiro dígito é a quantidade de zeros, então o valor é 100.000 pF. Só as marcações de dois dígitos, como 22 e 47, são picofarads diretos; nos códigos de três dígitos, até 220 significa 22 pF, e não 220 pF.
- Comparar mAh entre tensões diferentes: converta para Wh ao comparar baterias de tensões diferentes, senão uma bateria de 9 V vai parecer mais fraca e uma pilha AA mais forte do que realmente são.
- Divisão inteira: no Arduino, 3 / 2 dá 1. Se você precisa de um resultado decimal, escreva um dos números como decimal, por exemplo 3.0, ou use float.
- Estouro de int: produtos como analogRead() × 5000 passam do limite de 32.767 do Uno. Faça o cast para (long) antes de multiplicar.
- Confundir W com Wh: W é a potência instantânea, enquanto Wh é a energia consumida quando essa potência atua durante uma hora. Um circuito que consome 2 W funciona por 5 horas com uma bateria de 10 Wh, sem contar as perdas.
- Esquecer a potência do resistor: 1/4 W significa 250 mW. Um resistor de 100 Ω ligado em 12 V dissipa 1,44 W e vai torrar um componente comum de um quarto de watt, então sempre faça o cálculo de potência.
Quando os prefixos e os atalhos de unidades viram algo automático, ler datasheets, escolher componentes e escrever o fator certo no código ficam muito mais rápidos. Se você quer colocar isso em prática, os projetos de voltímetro digital com LCD, leitura do nível de luz com LDR, medição de temperatura com NTC e deep sleep do ESP32 no app BlueGrays mostram passo a passo, com esquema do circuito e código, como são calculados os valores do ADC, as correntes e a autonomia da bateria.
Perguntas frequentes
Qual é o valor de um capacitor 104 em nF?
O código 104 é lido como 10 seguido de quatro zeros: 100.000 pF. Isso equivale a 100 nF ou 0,1 µF. É o capacitor de desacoplamento que você encontra na linha de alimentação da maioria dos circuitos com Arduino.
Quantos nF tem 1 µF?
1 µF equivale a 1000 nF. Para converter nF em µF, divida por 1000; por exemplo, 470 nF = 0,47 µF e 22 nF = 0,022 µF.
O que significa 2n2 em um capacitor?
No 2n2, a letra n indica tanto a unidade (nanofarads) quanto a vírgula decimal, então o valor é 2,2 nF, ou 2200 pF. O mesmo capacitor também pode vir marcado com o código de três dígitos 222.
Qual é o código de um capacitor de 10 µF?
10 µF são 10.000.000 pF, ou seja, 10 seguido de seis zeros, então o código de três dígitos é 106. Os capacitores eletrolíticos costumam dispensar o código e trazer 10 µF impresso por extenso, junto com a tensão nominal.
Como converter mAh em Wh?
Multiplique o valor em mAh pela tensão nominal da bateria e divida por 1000: Wh = mAh × V / 1000. Uma célula 18650 de 3,7 V e 2600 mAh guarda cerca de 9,6 Wh de energia.
MFD é a mesma coisa que µF?
Sim. MFD é uma notação mais antiga para microfarads, então um capacitor marcado com 35 MFD em um ar-condicionado, ventilador ou motor tem 35 µF. A marcação aparentada MMFD significa picofarads.
Projetos para montar depois desta leitura
Ver todos os projetos
Medição da intensidade da luz com LDR
Quer ver a luminosidade do seu quarto em números? O LDR, um pequeno componente sensível à luz, mede a luz ambiente, e o Arduino exibe o valor na tela do computador a cada meio segundo.

Leitura da intensidade da luz com módulo LDR e ESP32
Acompanhe em tempo real no Monitor Serial o valor bruto do ADC do módulo LDR e a porcentagem relativa de luz calculada a partir de referências de escuridão e claridade. Essa porcentagem não é uma medida em lux. O projeto ensina a lógica de calibração do módulo. É ideal fazê-lo antes do projeto 10, pois ajuda a determinar o valor do limiar.

Medição de distância com HC-SR04 (Monitor Serial)
O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

Voltímetro digital com display LCD
Descubra a tensão de uma pilha ou de um adaptador de alimentação com um medidor feito por você.

Medição de temperatura com NTC e display LCD 2x16
Meça a temperatura ao seu redor com um sensor que parece uma pequena conta. Esse componente, chamado NTC, deixa a eletricidade passar com mais facilidade à medida que aquece; o Arduino lê essa…

Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
Neste projeto, controlamos o brilho de um LED de forma analógica com um potenciômetro. O pino ADC do ESP32 lê a tensão de 0-3,3V do potenciômetro e converte esse valor em um sinal PWM (modulação por largura de pulso), enviado ao LED. Assim, ao girar o potenciômetro, o brilho do LED aumenta e diminui gradualmente. Com Arduino Core 3.0+, você pode usar analogWrite() diretamente; no ESP32-S2/S3, a resolução do ADC é fixada em 12 bits.

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.

Ajuste de frequência com buzzer
Você controla o som de um buzzer com quatro botões: um inicia o som, outro o interrompe e os outros dois o deixam mais agudo ou mais grave.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

