Fundamentos · 13 min de lectura

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.

Capacitores electrolíticos marcados 470 µF 16 V y 220 µF 16 V
En los capacitores electrolíticos el valor viene impreso tal cual (470 µF, 16 V); los cerámicos pequeños usan códigos como 104.

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.

PrefijoSímboloFactorEjemplo en electrónica
picop10⁻¹² (0,000 000 000 001)Capacitor de 22 pF junto al cristal
nanon10⁻⁹ (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
milim10⁻³ (0,001)LED a 20 mA, paso del ADC de 4,88 mV
(unidad base)-15 V, 1 A, 1 Ω, 1 F
kilok10³ (1000)Resistencia pull-up de 10 kΩ, portadora IR de 38 kHz
megaM10⁶ (1 000 000)Impedancia de entrada de 1 MΩ, reloj de 16 MHz
gigaG10⁹Wi-Fi y Bluetooth a 2,4 GHz
Subir o bajar un prefijo significa mover la coma tres lugares. Al pasar de una unidad pequeña a una más grande el número se achica (2200 pF = 2,2 nF); al pasar de una grande a una más pequeña, el número crece (0,1 µF = 100 nF). Si tu teclado no tiene µ, se escribe u: 10uF es lo mismo que 10 µF.

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.

pFnFµFCódigo
10 pF0,01 nF0,00001 µF100
22 pF0,022 nF0,000022 µF220
100 pF0,1 nF0,0001 µF101
1000 pF1 nF0,001 µF102
2200 pF2,2 nF (2n2)0,0022 µF222
4700 pF4,7 nF (4n7)0,0047 µF472
10 000 pF10 nF0,01 µF103
47 000 pF47 nF0,047 µF473
100 000 pF100 nF0,1 µF104
220 000 pF220 nF0,22 µF224
470 000 pF470 nF0,47 µF474
1 000 000 pF1000 nF1 µF105
10 000 000 pF10 000 nF10 µF106

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?.

  1. Anota las dos primeras cifras: 47 en el 474.
  2. Agrega tantos ceros como indique la tercera cifra: 47 más 4 ceros da 470 000 pF.
  3. Divide entre 1000 para pasar a nF: 470 000 pF = 470 nF.
  4. Divide otra vez entre 1000 para pasar a µF: 470 nF = 0,47 µF.
  5. 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 %.
  6. 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.
MarcadoSignificadoValor
2n2La n hace de coma decimal2,2 nF = 2200 pF
4n7La n hace de coma decimal4,7 nF = 4700 pF
µ1 o u1La µ hace de coma decimal0,1 µF = 100 nF
4µ7La µ hace de coma decimal4,7 µF
p68La p hace de coma decimal0,68 pF
109Tercera cifra 9 = ×0,11,0 pF
104ZZ = tolerancia +80 % / -20 %100 nF
35 MFDNotación antigua: MFD = microfaradio35 µF
En capacitores antiguos o de fabricación estadounidense, MFD e incluso mF se usan para indicar microfaradios: los "35 MFD" del capacitor de un ventilador de techo o de un aire acondicionado son 35 µF, no 35 milifaradios. Del mismo modo, MMFD en diagramas viejos significa picofaradios. Cuando compres un repuesto, interpreta la unidad según el contexto; un capacitor de ese tamaño no puede tener milifaradios.

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ónValorEn ohmios
R470,47 Ω0,47 Ω
2R22,2 Ω2,2 Ω
220R220 Ω220 Ω
1K1 kΩ1000 Ω
4K74,7 kΩ4700 Ω
47K47 kΩ47 000 Ω
1M01 MΩ1 000 000 Ω
103 (SMD)10 y 3 ceros10 000 Ω = 10 kΩ
4701 (SMD, 4 cifras)470 y 1 cero4700 Ω = 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ónValor típicoEn unidad base
Corriente por pin del Arduino Uno (recomendada / máximo absoluto)20 mA / 40 mA0,02 A / 0,04 A
Corriente de trabajo de un LED rojo10-20 mA0,01-0,02 A
ESP32 transmitiendo por Wi-Fihasta 250 mA0,25 A
Consumo del chip ESP32 en deep sleepunos 10 µA0,00001 A
Paso del ADC del Arduino Uno (5 V, 10 bits)4,88 mV0,00488 V
Paso del ADC del ESP32 y la Pico (3,3 V, 12 bits)unos 0,8 mV0,0008 V
Corriente de bloqueo de un servo SG90650-700 mAunos 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órmulaCombinación de unidadesEjemplo
I = V / RV / kΩ = mA5 V / 10 kΩ = 0,5 mA
R = V / IV / mA = kΩ(5 V - 2 V) / 20 mA = 0,15 kΩ = 150 Ω
V = I × RmA × kΩ = V2 mA × 4,7 kΩ = 9,4 V
P = V × IV × mA = mW5 V × 20 mA = 100 mW
τ = R × CkΩ × µF = ms10 kΩ × 100 µF = 1000 ms = 1 s
τ = R × CkΩ × nF = µs10 kΩ × 100 nF = 1000 µs = 1 ms
τ = R × CMΩ × µF = s1 MΩ × 10 µF = 10 s
La segunda fila de la tabla es en realidad un cálculo de resistencia para LED: a 5 V le restas los 2 V que cae el LED, divides los 3 V restantes entre 20 mA y obtienes 0,15 kΩ. Si ese valor no existe en la serie comercial, elige el siguiente hacia arriba (150 Ω o 220 Ω). Para experimentar con la constante de tiempo de un circuito RC, prueba la calculadora de constante de tiempo RC.

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íaCapacidadVoltajeEnergía
Pila de botón CR2032220 mAh3 V0,66 Wh
Pila AA alcalinaunos 2500 mAh1,5 Vunos 3,75 Wh
Batería alcalina de 9 Vunos 500 mAh9 Vunos 4,5 Wh
LiPo de 1000 mAh1000 mAh3,7 V3,7 Wh
Celda 18650 de litio2600 mAh3,7 V9,62 Wh
Power bank de 10 000 mAh10 000 mAh3,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Ω.

C++ (Arduino IDE)
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".

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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.
Cuando un resultado te parezca raro, escribe las unidades junto a los números y simplifícalas. Si no llegas a la unidad que esperabas (mA, ms, Wh), en algún punto de la fórmula se perdió un prefijo. Este hábito atrapa la mayoría de los errores cuando todavía están en papel, tanto en un examen como en el banco de trabajo.

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.

Ver todos los proyectos
Medir la intensidad de luz con LDR
AR-11Principiante

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…

4.6(83)
143
Lectura de la intensidad luminosa con el módulo LDR del ESP32
ES-11Principiante

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.

4.6(36)
55
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

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.

4.6(50)
82
Voltímetro digital con pantalla LCD
AR-56Intermedio
Premium

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…

4.5(27)
36
Medición de temperatura con NTC y pantalla LCD 2x16
AR-44Principiante
Premium

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…

4.5(33)
44
Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
ES-13Intermedio
Premium

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.

4.5(19)
32
Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
ES-33Avanzado
Premium

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.

4.3(10)
16
Ajuste de frecuencia con zumbador
AR-14Intermedio

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.

4.6(69)
120