Convertir nF a µF: tabla, código de capacitores y unidades
Convertir nF a µF es fácil: tabla pF-nF-µF, código de capacitor 104 y 2n2, kΩ, mA, mV y mAh a Wh, más los errores de unidades típicos en Arduino y ESP32.
Para convertir nF a µF basta una regla: 1 µF = 1000 nF y 1 nF = 1000 pF. Es decir, de nF a µF divides entre 1000 y de µF a nF multiplicas por 1000: 100 nF = 0,1 µF, 4,7 µF = 4700 nF. El 104 impreso en un capacitor cerámico significa justamente esos 100 nF, o sea 0,1 µF. Casi todas las conversiones de unidades en electrónica se hacen en estos saltos de mil; cuando dominas los prefijos, los cálculos de resistencias, corriente, voltaje y baterías se vuelven mucho más fáciles.
En esta guía reunimos los prefijos p, n, µ, m, k y M en una sola tabla. Aprenderás a leer los códigos de capacitores (104, 2n2, 474J), las notaciones 4K7 y R47 de las resistencias, a pasar de mA a A y de mV a V, a convertir la capacidad de una batería de mAh a Wh y los atajos de unidades que te permiten resolver la ley de Ohm de cabeza. Al final veremos los errores de unidades más comunes en el código de Arduino, ESP32 y Raspberry Pi Pico, y cómo escribirlos bien.

Prefijos del SI: ¿qué significan p, n, µ, m, k y M?
En electrónica los valores abarcan un rango enorme: un microcontrolador dormido consume unos pocos microamperios y un motor varios amperios; el capacitor junto a un cristal puede ser de 22 picofaradios y el de la salida de una fuente de 2200 microfaradios. Por eso, en lugar de escribir largas filas de ceros, usamos un prefijo. Cada prefijo multiplica la unidad base por una potencia de 10, y los que se usan en electrónica están separados entre sí por un factor de 1000. Las reglas son las mismas para voltios, amperios, ohmios, faradios, henrios, vatios y hercios.
| Prefijo | Símbolo | Factor | Ejemplo en electrónica |
|---|---|---|---|
| pico | p | 10⁻¹² (0,000 000 000 001) | Capacitor de 22 pF junto al cristal |
| nano | n | 10⁻⁹ (0,000 000 001) | Capacitor de desacople de 100 nF, periodo de reloj de 62,5 ns |
| micro | µ (u) | 10⁻⁶ (0,000 001) | Capacitor de 10 µF, consumo en reposo de 10 µA |
| mili | m | 10⁻³ (0,001) | LED a 20 mA, paso del ADC de 4,88 mV |
| (unidad base) | - | 1 | 5 V, 1 A, 1 Ω, 1 F |
| kilo | k | 10³ (1000) | Resistencia pull-up de 10 kΩ, portadora IR de 38 kHz |
| mega | M | 10⁶ (1 000 000) | Impedancia de entrada de 1 MΩ, reloj de 16 MHz |
| giga | G | 10⁹ | Wi-Fi y Bluetooth a 2,4 GHz |
Tabla de conversión de pF, nF y µF
Lo que más confunde con los capacitores es que el mismo valor puede aparecer en tres unidades distintas. El diagrama dice 0,1 µF, la tienda en línea dice 100 nF, el componente dice 104, y los tres son la misma pieza. Para convertir nF a µF divides entre 1000; para pasar de pF a nF vuelves a dividir entre 1000. En sentido contrario, multiplicas por 1000. La tabla reúne los valores más usados junto con los códigos que vas a encontrar impresos; vale la pena imprimirla y pegarla junto a tu protoboard.
| 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 |
Cómo leer el código de un capacitor: ¿cuántos nF es 104?
En los capacitores cerámicos y de poliéster pequeños no cabe el valor completo, así que llevan un código de tres cifras cuya unidad siempre es el picofaradio. Las dos primeras cifras son el valor y la tercera es la cantidad de ceros que hay que agregar. En el 104 pones cuatro ceros detrás del 10: 100 000 pF, que equivalen a 100 nF o 0,1 µF. Si no quieres hacerlo de cabeza, la calculadora de código de capacitores lo resuelve en un segundo; cómo funcionan los capacitores lo explicamos en ¿Qué es un condensador?.
- Anota las dos primeras cifras: 47 en el 474.
- Agrega tantos ceros como indique la tercera cifra: 47 más 4 ceros da 470 000 pF.
- Divide entre 1000 para pasar a nF: 470 000 pF = 470 nF.
- Divide otra vez entre 1000 para pasar a µF: 470 nF = 0,47 µF.
- Mira la letra que sigue al código: J significa ±5 %, K ±10 % y M ±20 % de tolerancia. Un 474J es un capacitor de 0,47 µF con ±5 %.
- Si delante del código aparece algo como 2A o 1H, es el voltaje de trabajo: 1H = 50 V, 2A = 100 V, 2J = 630 V.
| Marcado | Significado | Valor |
|---|---|---|
| 2n2 | La n hace de coma decimal | 2,2 nF = 2200 pF |
| 4n7 | La n hace de coma decimal | 4,7 nF = 4700 pF |
| µ1 o u1 | La µ hace de coma decimal | 0,1 µF = 100 nF |
| 4µ7 | La µ hace de coma decimal | 4,7 µF |
| p68 | La p hace de coma decimal | 0,68 pF |
| 109 | Tercera cifra 9 = ×0,1 | 1,0 pF |
| 104Z | Z = tolerancia +80 % / -20 % | 100 nF |
| 35 MFD | Notación antigua: MFD = microfaradio | 35 µF |
Unidades de resistencia: Ω, kΩ, MΩ y la notación 4K7
La unidad base de las resistencias es el ohmio (Ω), pero la mayoría de los valores que verás en circuitos con Arduino están en el rango de los kiloohmios: 220 Ω para un LED, 10 kΩ de pull-up, 1 MΩ para una entrada de alta impedancia. En los diagramas y listas de materiales se usa una letra en lugar de la coma, porque un punto pequeño puede perderse al imprimir y una letra no. R significa ohmios, K kiloohmios y M megaohmios, y la posición de la letra marca la coma. Para descifrar las bandas de color mira nuestra guía del código de colores de resistencias o la calculadora de código de colores; para códigos como 103 y 4701 en componentes SMD, lee códigos de resistencias SMD.
| Notación | Valor | En ohmios |
|---|---|---|
| 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 y 3 ceros | 10 000 Ω = 10 kΩ |
| 4701 (SMD, 4 cifras) | 470 y 1 cero | 4700 Ω = 4,7 kΩ |
El código de tres cifras funciona igual en resistencias y bobinas, pero la unidad base cambia: picofaradios en un capacitor, ohmios en una resistencia SMD y microhenrios en una bobina. Así, 101 en un capacitor son 100 pF, en una resistencia SMD 100 Ω y en una bobina 100 µH. Nunca interpretes un código sin saber en qué componente está.
Corriente y voltaje: convertir mA a A, µA y mV a V
Con la corriente casi siempre vas a pasar entre mA y A: 1 A = 1000 mA y 1 mA = 1000 µA. Un LED que consume 20 mA consume 0,02 A; los 10 µA de un ESP32 en deep sleep son 0,01 mA, o sea 0,00001 A. El voltaje usa los mismos saltos: 1 V = 1000 mV. El ADC de 10 bits del Arduino Uno divide 5 V en 1024 partes, así que cada paso vale 5 / 1024 = 0,00488 V, es decir 4,88 mV. En las hojas de datos de los sensores verás relaciones como mV por grado (10 mV/°C en el LM35) o mV por amperio (185 mV/A en el ACS712-5A); usarlas en la unidad correcta define la precisión de tu medición. La lectura analógica se explica en detalle en ¿Qué es un ADC?.
| Situación | Valor típico | En unidad base |
|---|---|---|
| Corriente por pin del Arduino Uno (recomendada / máximo absoluto) | 20 mA / 40 mA | 0,02 A / 0,04 A |
| Corriente de trabajo de un LED rojo | 10-20 mA | 0,01-0,02 A |
| ESP32 transmitiendo por Wi-Fi | hasta 250 mA | 0,25 A |
| Consumo del chip ESP32 en deep sleep | unos 10 µA | 0,00001 A |
| Paso del ADC del Arduino Uno (5 V, 10 bits) | 4,88 mV | 0,00488 V |
| Paso del ADC del ESP32 y la Pico (3,3 V, 12 bits) | unos 0,8 mV | 0,0008 V |
| Corriente de bloqueo de un servo SG90 | 650-700 mA | unos 0,7 A |
Atajos de unidades en la ley de Ohm: V, mA y kΩ
No hace falta pasar cada valor a la unidad base antes de calcular. Si combinas los prefijos de modo que se cancelen, el resultado sale directamente en la unidad correcta. La combinación más útil es esta: voltios entre kiloohmios da miliamperios. Si aplicas 5 V a una resistencia pull-up de 10 kΩ, circulan 5 / 10 = 0,5 mA, sin pelearte con ceros. Con la misma lógica, miliamperios por kiloohmios da voltios, y voltios por miliamperios da milivatios. También sirve para la carga de un capacitor: kiloohmios por microfaradios da milisegundos. Para repasar lo básico lee La ley de Ohm o usa la calculadora de la ley de Ohm para un resultado rápido.
| Fórmula | Combinación de unidades | Ejemplo |
|---|---|---|
| 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 y Wh: convertir la capacidad de una batería
Los mAh (miliamperios-hora) indican cuánta corriente puede entregar una batería y durante cuántas horas, mientras que los Wh (vatios-hora) indican cuánta energía guarda realmente. Para comparar baterías de distinto voltaje necesitas los Wh, porque una pila AA de 2000 mAh y una batería de litio de 2000 mAh no almacenan la misma energía. La fórmula es simple: Wh = mAh × V / 1000. Una celda 18650 de 2600 mAh y 3,7 V guarda 2600 × 3,7 / 1000 = 9,62 Wh. El límite de 100 Wh que fijan las aerolíneas para las power banks en el equipaje de mano equivale a unos 27 000 mAh a 3,7 V.
Para estimar la autonomía divides la capacidad entre la corriente media: horas = mAh / mA. En la práctica la batería no se aprovecha entera y el regulador pierde energía, así que multiplicar el resultado por 0,7-0,8 es más realista. Un proyecto con ESP32 que consume 80 mA de media dura unas 2600 / 80 × 0,8 = 26 horas con una celda de 2600 mAh. Los 10 000 mAh impresos en una power bank se refieren a sus celdas de 3,7 V; al elevarlos a 5 V con un rendimiento cercano al 85 %, quedan unos 10 000 × 3,7 × 0,85 / 5 ≈ 6300 mAh útiles. Si quieres el cálculo detallado, lee ¿Qué significa mAh? o usa la calculadora de autonomía de baterías.
| Pila / batería | Capacidad | Voltaje | Energía |
|---|---|---|---|
| Pila de botón CR2032 | 220 mAh | 3 V | 0,66 Wh |
| Pila AA alcalina | unos 2500 mAh | 1,5 V | unos 3,75 Wh |
| Batería alcalina de 9 V | unos 500 mAh | 9 V | unos 4,5 Wh |
| LiPo de 1000 mAh | 1000 mAh | 3,7 V | 3,7 Wh |
| Celda 18650 de litio | 2600 mAh | 3,7 V | 9,62 Wh |
| Power bank de 10 000 mAh | 10 000 mAh | 3,7 V (celda) | 37 Wh |
Tiempo y frecuencia: ms, µs, Hz, kHz y MHz
La frecuencia y el periodo son inversos: T = 1 / f. Como el hercio es "uno por segundo", la inversa de kHz da milisegundos y la de MHz, microsegundos. Los servomotores se controlan a 50 Hz, así que llega un pulso cada 1 / 50 = 0,02 s = 20 ms. La mayoría de los pines PWM del Arduino Uno trabajan a unos 490 Hz con un periodo de 2,04 ms; los pines 5 y 6, a 980 Hz con 1,02 ms (más detalles en ¿Qué es PWM?). Con un reloj de 16 MHz, cada ciclo dura 62,5 ns. Tampoco confundas las dos funciones de tiempo de Arduino: millis() devuelve milisegundos, micros() microsegundos, y delayMicroseconds() solo es precisa hasta 16 383 µs; para esperas más largas usa temporización con millis.
Las unidades de velocidad se basan en las mismas conversiones. En el sensor ultrasónico HC-SR04 la velocidad del sonido es de 343 m/s; pasada a cm/µs da 34 300 cm / 1 000 000 µs = 0,0343 cm/µs. Como el sensor entrega el tiempo de ida y vuelta del eco, distancia = tiempo (µs) × 0,0343 / 2, y un eco de 1000 µs equivale a 17,15 cm. Si sabes de dónde sale ese 0,0343, podrás calcular tú mismo el factor correcto cuando quieras el resultado en metros o en pulgadas.
Errores de unidades en el código de Arduino: pasar la lectura del ADC a mV y V
Aunque la conversión esté bien en papel, en el código te esperan dos trampas. La primera es el desbordamiento de int: en el Arduino Uno un int guarda como máximo 32 767, pero 1023 × 5000 son 5 115 000 y el resultado sale cualquier cosa. La segunda es la división entera: 4700 / 1000 da 4 y no 4,7, porque al dividir dos enteros se descarta la parte decimal. La solución es hacer la multiplicación en long y escribir 1000.0 en lugar de 1000 cuando quieras un resultado con decimales. El siguiente sketch convierte correctamente el voltaje de A0 a mV y V, y luego calcula el voltaje real a la entrada de un divisor de voltaje de 10 kΩ y 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}El cast (long)raw hace que la multiplicación se calcule en 32 bits, así que no hay desbordamiento. Dividimos entre 1024 porque es la fórmula de la hoja de datos del ATmega328P; la diferencia con 1023 ronda el 0,1 por ciento. Escribir las resistencias del divisor en kΩ no es problema, porque en el cociente las unidades se cancelan. Con este divisor, A0 recibe como máximo 5 V mientras que en la entrada puedes medir hasta unos 15,6 V.
Decodificador de código de capacitores: escribe 104 en el Monitor Serie
Para que descifrar códigos te salga solo, escribamos una pequeña herramienta. El programa lee el código de tres cifras que escribas en el Monitor Serie y muestra su valor en pF, nF y µF. También contempla los casos especiales en que la tercera cifra es 8 o 9 (×0,01 y ×0,1). Solo configura el ajuste de fin de línea del Monitor Serie en "Nueva línea".
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}Conversión de unidades en el ESP32 y la Raspberry Pi Pico
El ADC del ESP32 es de 12 bits y devuelve valores de 0 a 4095, pero los pines trabajan a 3,3 V y el ADC se desvía un poco distinto en cada placa. Por eso es mejor usar la función analogReadMilliVolts() del core en lugar de convertir tú el valor crudo: aprovecha la calibración grabada de fábrica en el chip y devuelve milivoltios directamente. Con la atenuación por defecto de 11 dB, el rango medible llega a unos 3,1 V y los resultados más precisos se obtienen entre 0,15 y 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}En la Raspberry Pi Pico, la función read_u16() de MicroPython escala el valor a 0-65535 aunque el ADC sea de 12 bits. Por lo tanto el factor de conversión debe ser 3,3 / 65535 y no 3,3 / 4095; con el factor equivocado el resultado sale 16 veces más grande. La resolución real sigue siendo 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)Errores de unidades frecuentes y cómo resolverlos
- Confundir m con M: entre 1 mΩ (miliohmio) y 1 MΩ (megaohmio) hay un factor de mil millones. La m minúscula es mili y la M mayúscula es mega; fíjate en el tamaño de la letra en el diagrama.
- Leer 104 como 104 pF: la tercera cifra es la cantidad de ceros, así que el valor es 100 000 pF. Solo los marcados de dos cifras como 22 y 47 son picofaradios directos; en los códigos de tres cifras hasta el 220 significa 22 pF y no 220 pF.
- Comparar mAh sin mirar el voltaje: al comparar baterías de distinto voltaje pasa a Wh, o una batería de 9 V parecerá más débil y una pila AA más fuerte de lo que son.
- División entera: en Arduino 3 / 2 da 1. Si necesitas decimales, escribe uno de los números como 3.0 o usa float.
- Desbordamiento de int: productos como analogRead() × 5000 superan el límite de 32 767 del Uno. Haz el cast a (long) antes de multiplicar.
- Confundir W con Wh: W es potencia instantánea; Wh es la energía consumida cuando esa potencia se mantiene una hora. Un circuito de 2 W funciona 5 horas con una batería de 10 Wh, sin contar pérdidas.
- Olvidar la potencia de la resistencia: 1/4 W son 250 mW. Una resistencia de 100 Ω conectada a 12 V disipa 1,44 W y quema una resistencia común de un cuarto de vatio, así que haz siempre el cálculo de potencia.
Con los prefijos y los atajos de unidades bien asentados, leer hojas de datos, elegir componentes y escribir el factor correcto en tu código se vuelve mucho más rápido. Si quieres ponerlo en práctica, en la app BlueGrays los proyectos de voltímetro digital con LCD, lectura de luz con LDR, medición de temperatura con NTC y deep sleep del ESP32 muestran paso a paso, con diagrama y código, cómo se calculan las lecturas del ADC, las corrientes y la autonomía de la batería.
Preguntas frecuentes
¿Cuántos nF tiene un capacitor 104?
El código 104 se lee como 10 seguido de cuatro ceros: 100 000 pF. Eso equivale a 100 nF o 0,1 µF. Es el capacitor de desacople que vas a ver en la alimentación de casi cualquier circuito con Arduino.
¿Cómo convertir nF a µF?
Divide el valor en nF entre 1000. Por ejemplo, 470 nF = 0,47 µF y 22 nF = 0,022 µF; al revés, 1 µF son 1000 nF.
¿Qué significa 2n2 en un capacitor?
En 2n2 la letra n indica a la vez la unidad (nanofaradios) y la coma decimal, así que el valor es 2,2 nF, es decir 2200 pF. El mismo capacitor también puede venir marcado con el código 222.
¿Cómo pasar mAh a Wh?
Multiplica los mAh por el voltaje nominal de la batería y divide entre 1000: Wh = mAh × V / 1000. Una celda 18650 de 3,7 V y 2600 mAh almacena unos 9,6 Wh.
¿Qué significa 4K7 en una resistencia?
En 4K7 la K indica a la vez los kiloohmios y la coma decimal, así que el valor es 4,7 kΩ, o sea 4700 Ω. Es uno de los valores de pull-up más usados en las líneas I2C.
¿Qué significa MFD en un capacitor?
MFD es una notación antigua de microfaradio. Un capacitor de arranque o de marcha marcado 35 MFD tiene 35 µF; la marca relacionada MMFD significa picofaradios.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Medir la intensidad de luz con LDR
¿Quieres ver en números cuánta luz hay en tu habitación? El LDR, una pequeña pieza sensible a la luz, mide la luz ambiente y el Arduino escribe el valor en la pantalla del ordenador cada medio…

Lectura de la intensidad luminosa con el módulo LDR del ESP32
Visualización en tiempo real en el monitor serie del valor bruto del ADC del módulo LDR y del porcentaje relativo de luz calculado a partir de referencias de oscuridad y claridad. Este porcentaje no es una medición en lux. Explica el funcionamiento de la calibración del módulo. Es recomendable realizarlo antes del Proyecto 10, ya que se utiliza para determinar el valor umbral.

HC-SR04 Medición de distancia (pantalla en serie)
El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

Voltímetro digital con pantalla LCD
Descubre cuánto voltaje da una pila o un adaptador con un medidor hecho por ti. Un divisor de dos resistencias baja la tensión alta a un nivel que la placa puede leer, y el Arduino calcula el valor…

Medición de temperatura con NTC y pantalla LCD 2x16
Mide la temperatura del ambiente con un sensor que parece una pequeña cuenta. Esta pieza, llamada NTC, deja pasar la electricidad con más facilidad cuanto más se calienta; el Arduino lee ese cambio…

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

Ajuste de frecuencia con zumbador
Controlas el sonido de un zumbador con cuatro botones: uno lo enciende, otro lo calla y los otros dos lo hacen más agudo o más grave.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

