Código de resistencias SMD: cómo leer 103, 4702, 01C y 4R7

El código de resistencias SMD es la marca corta de tres o cuatro caracteres que se imprime sobre las resistencias de montaje superficial (SMD) en lugar de las bandas de colores, e indica su valor en ohmios. Cuando aprendes la regla, es muy fácil de leer: 103 = 10 kΩ, 4702 = 47 kΩ, 4R7 = 4,7 Ω y 01C = 10 kΩ. En el código de tres dígitos, los dos primeros son el valor y el último es el número de ceros que hay que añadir; en el de cuatro dígitos, los tres primeros son el valor. La letra R sustituye a la coma decimal, y los códigos formados por dos cifras y una letra se leen en la tabla EIA-96.

Las placas Arduino Nano, las placas de desarrollo ESP32, los módulos de sensores y las placas reguladoras están llenas de estas piezas diminutas. Si quieres reparar un módulo, averiguar qué resistencia alimenta el LED de tu placa, encontrar el valor de una resistencia pull-up o diseñar tu propia PCB, necesitas saber leer estos códigos. Además de las resistencias, en esta guía aprenderás los códigos de condensadores SMD (104 = 100 nF), los tamaños como 0603, 0805 y 1206, las marcas cortas de transistores y diodos SMD y cómo medir con Arduino una pieza que no lleva ninguna marca.

¿Qué es una resistencia SMD y por qué no tiene código de colores?

SMD (Surface Mount Device) es un componente cuyas patillas no atraviesan agujeros, sino que se sueldan directamente sobre los pads de la superficie de la placa. Una resistencia SMD es un pequeño bloque cerámico con los extremos metalizados; la capa negra de arriba protege la película resistiva y lleva el código. Una resistencia de tamaño 0805 mide solo 2 × 1,25 mm, así que pintar cuatro bandas de colores no es práctico; por eso el valor se imprime como un código con cifras blancas. En las de 0402 y menores ni siquiera cabe ese código, así que no llevan ninguna marca. Recuerda que el código solo indica la resistencia: los límites de potencia y tensión dependen del tamaño, y la tolerancia suele deducirse del tipo de código.

Cómo leer el código SMD de 3 dígitos

El formato más habitual es el código de tres dígitos. Las dos primeras cifras son la parte significativa del valor y la tercera indica cuántos ceros se añaden detrás, es decir, la potencia de diez. En 103 se añaden tres ceros al 10: 10 000 Ω = 10 kΩ. Del mismo modo, 472 = 47 y dos ceros = 4700 Ω = 4,7 kΩ; 221 = 220 Ω; 334 = 330 kΩ y 105 = 1 000 000 Ω = 1 MΩ. Estos códigos se usan normalmente en resistencias del ±5 % y los valores pertenecen a la serie E24: 10, 11, 12, 13, 15, 16, 18, 20, 22, 24, 27, 30, 33, 36, 39, 43, 47, 51, 56, 62, 68, 75, 82 y 91, y sus múltiplos de diez. Si el valor que lees no está en esta lista, o estás leyendo el código al revés o la pieza no es una resistencia.

Código de 4 dígitos y la letra R: 4702, 1002, 4R7

El código de cuatro dígitos se usa en resistencias de precisión del ±1 %. La lógica es la misma, pero la parte significativa tiene tres cifras: las tres primeras son el valor y la cuarta es el número de ceros. 1002 = 100 y dos ceros = 10 000 Ω = 10 kΩ; 4702 = 47 kΩ; 1001 = 1 kΩ; 1000 = 100 Ω; 2201 = 2,2 kΩ; 1004 = 1 MΩ. Con tres cifras significativas también se pueden escribir valores intermedios de la serie E96, como 49,9 kΩ (4992) o 4,99 kΩ (4991). En resumen, la misma resistencia de 10 kΩ puede aparecer como 103, 1002 o 01C según el fabricante y la precisión; las tres tienen el mismo valor.

Los valores por debajo de 10 Ω no se pueden escribir con un número de ceros, así que la letra R ocupa el lugar de la coma decimal. 4R7 = 4,7 Ω, 2R2 = 2,2 Ω, 1R0 = 1 Ω y R47 = 0,47 Ω. La versión de cuatro caracteres sigue la misma regla: 10R0 = 10 Ω, 4R70 = 4,7 Ω. Los valores muy pequeños suelen ser resistencias shunt para medir corriente: R100 = 0,1 Ω (la verás en módulos de medida de corriente como el INA219) y R010 = 0,01 Ω, es decir, 10 mΩ. En los esquemas y listas de materiales se usa la misma idea con las letras k y M: 4k7 = 4,7 kΩ, 2M2 = 2,2 MΩ. Esta notación se prefiere porque, si la coma se pierde al imprimir, 4,7 kΩ podría convertirse en 47 kΩ.

Cómo leer el código EIA-96 (01C, 68X, 85B)

En una resistencia del 1 % de tamaño 0603 no caben cuatro cifras. Para ellas se usa un sistema de tres caracteres llamado EIA-96: las dos primeras cifras (01–96) son el número de posición del valor en la serie E96 y la letra final es el multiplicador. El valor número 01 es 100, el 68 es 499 y el 85 es 750. Así, 01C = 100 × 100 = 10 kΩ, 68X = 499 × 0,1 = 49,9 Ω y 85B = 750 × 10 = 7,5 kΩ. Aquí no puedes calcular nada con las cifras: tienes que buscar el valor en la tabla. Lo más rápido es escribir el código en la herramienta Código SMD, que entiende códigos de 3 y 4 dígitos, la notación con R y EIA-96.

Subrayado, cero ohmios y otros casos especiales

• Subrayado: Algunos fabricantes ponen una línea bajo el código de tres dígitos en resistencias del 1 % cuyo valor pertenece a la serie E24. La línea no cambia el valor; indica que es una resistencia de precisión y en qué sentido se lee.
• 0, 00 o 000: Es una resistencia puente de cero ohmios (jumper). Se usa para unir dos pistas de la PCB o para activar o desactivar una opción; en tamaños 0603 y 0805 suele soportar entre 1 y 2 A.
• Resistencias sin marcar: Las piezas de 0402, 0201 y menores no llevan código. Su valor solo se conoce midiendo o por la etiqueta del carrete.
• Redes de resistencias: Los arrays con cuatro resistencias juntas en un mismo cuerpo llevan un único código; un array marcado 103 contiene cuatro resistencias de 10 kΩ. Son frecuentes en placas como Arduino Uno.
• Resistencias cilíndricas (MELF): Estas resistencias SMD tienen forma de pequeño cilindro y llevan bandas de colores como las de patillas. Puedes descifrarlas con la herramienta Código de colores.
• Bobinas SMD: Las bobinas usan códigos parecidos, pero en microhenrios: 101 = 100 µH, 4R7 = 4,7 µH. Puedes leerlas con la herramienta Código de bobina.

Tamaños SMD: ¿qué significan 0603, 0805 y 1206?

El código de tamaño indica las dimensiones físicas de la pieza, no su valor. En el sistema en pulgadas, el más usado, las dos primeras cifras dan la longitud y las dos últimas la anchura en centésimas de pulgada: 0805 es 0,08 × 0,05 pulgadas, unos 2,0 × 1,25 mm. En el sistema métrico la misma pieza se escribe 2012, en décimas de milímetro. Cuanto mayor es el cuerpo, más potencia y tensión aguanta la resistencia. Los tamaños más cómodos para soldar a mano son 1206 y 0805; 0603 se suelda bien con pinzas y una punta fina, mientras que 0402 y menores requieren lupa y paciencia. Los valores de abajo son típicos; los límites exactos varían algo según el fabricante.

Las potencias suelen darse para 70 °C de temperatura ambiente y bajan cuando hace más calor, así que trabajar a la mitad del límite es una buena costumbre. Calcula la potencia que disipa una resistencia con P = V × I o P = I² × R. Ejemplo: para alimentar un LED rojo a 20 mA desde 5 V necesitas (5 − 2) / 0,02 = 150 Ω, y la potencia en la resistencia es 3 V × 0,02 A = 0,06 W. Una 0603 (0,1 W) lo soporta, pero una 0805 va más holgada. Si alimentas el mismo LED desde 12 V necesitas 510 Ω y la potencia sube a 10 V × 0,02 A = 0,2 W; una 1206 quedaría al límite, así que elige una 1210 o un cuerpo mayor. Para repasar estos cálculos, mira Ley de Ohm.

Código de condensadores SMD: 104 = 100 nF

Los códigos de condensadores siguen la misma lógica que los de resistencias, pero la unidad es el picofaradio (pF): las dos primeras cifras son el valor y la tercera el número de ceros. 104 = 10 y cuatro ceros = 100 000 pF = 100 nF = 0,1 µF. 103 = 10 nF, 102 = 1 nF, 105 = 1 µF, 106 = 10 µF. Al convertir unidades, recuerda que 1 µF = 1000 nF = 1 000 000 pF. Si ves un 8 o un 9 en la tercera posición, no es un número de ceros sino un multiplicador: 9 = × 0,1 y 8 = × 0,01; es decir, 229 = 2,2 pF y 479 = 4,7 pF. Una letra detrás del valor indica la tolerancia: J = ±5 %, K = ±10 %, M = ±20 %. Cuando la letra va en medio, marca a la vez la unidad y la coma: 4n7 = 4,7 nF, p47 = 0,47 pF, 2u2 = 2,2 µF. Para convertir códigos rápidamente, usa la herramienta Código de condensador.

Hay un dato importante: la mayoría de los condensadores cerámicos SMD (MLCC) no llevan ninguna marca. El valor de estos pequeños bloques marrones, beige o grises solo se conoce por la etiqueta del carrete o con un multímetro que mida capacidad. Los números 106 y 104 que viste en la placa AMS1117 están impresos en la placa, no en los condensadores. En piezas antiguas o de algunos fabricantes puede aparecer un código de dos caracteres formado por una letra y una cifra: la letra indica el valor de la serie E24 (A = 1,0; E = 1,5; J = 2,2; N = 3,3; S = 4,7; W = 6,8) y la cifra el número de ceros en pF; S3 = 4,7 × 1000 pF = 4,7 nF. Las siglas X7R, X5R y C0G (NP0) de la etiqueta del carrete indican el tipo de dieléctrico: C0G apenas cambia con la temperatura, mientras que X7R y X5R pueden perder buena parte de su capacidad al aumentar la tensión continua aplicada.

Los condensadores de tántalo suelen tener un cuerpo rectangular amarillo, naranja o negro. Llevan un código en pF (106 = 10 µF, 476 = 47 µF, 107 = 100 µF) y a menudo una letra de tensión: J = 6,3 V, A = 10 V, C = 16 V, D = 20 V, E = 25 V, V = 35 V. Algunos fabricantes imprimen la tensión directamente. Los electrolíticos de aluminio SMD son pequeñas latas metálicas; el valor va impreso directamente en µF y la media luna negra de arriba marca el terminal negativo (−). Marcas como 2A104J en condensadores de film y cerámicos grandes se dividen en tres partes: 2A = 100 V, 104 = 100 nF, J = ±5 %. Otros códigos de tensión frecuentes son 1C = 16 V, 1E = 25 V, 1H = 50 V y 2J = 630 V. Encontrarás más sobre los tipos de condensadores en ¿Qué es un condensador?.

Códigos de transistores y diodos SMD (1AM, J3Y, A7, M7)

En encapsulados pequeños como el SOT-23 no cabe el nombre completo, así que los transistores y diodos llevan un código de marcado (marking code) de 2 o 3 caracteres. Estos códigos no siguen un estándar único: el mismo código puede significar piezas totalmente distintas en dos fabricantes, y una letra minúscula al final suele ser un código de fábrica o de fecha. Para identificar una pieza, combina tres pistas: el tipo de encapsulado, el código de marcado y la función de la pieza en el circuito. En los transistores bipolares en SOT-23 el orden de patillas suele ser 1 = base, 2 = emisor, 3 = colector; en MOSFET como el 2N7002 es 1 = gate (puerta), 2 = source (fuente), 3 = drain (drenador). Para patillajes y equivalentes consulta la herramienta Transistores, y para entender cómo funcionan lee ¿Qué es un transistor?.

Medir una resistencia sin marcar o ilegible: óhmetro con Arduino

Si el código está borrado, la pieza es de tamaño 0402 o no estás seguro del resultado, lo más fiable es medir. Al medir con el multímetro, desuelda la resistencia si puedes o al menos levanta un extremo; los caminos en paralelo del circuito hacen que la lectura sea más baja que el valor real. Si no tienes multímetro, puedes construir un óhmetro sencillo con Arduino. El circuito es un divisor de tensión: conectas en serie una resistencia de referencia de valor conocido (Rref) y la resistencia a medir (Rx), y lees la tensión del punto medio con un pin analógico. Como la lectura analógica de Arduino es proporcional a la tensión de alimentación, la fórmula es muy sencilla: Rx = Rref × lectura / (1024 − lectura). El resultado más preciso se obtiene cuando Rx está cerca de Rref: con una referencia de 10 kΩ puedes medir resistencias de 1 kΩ a 100 kΩ con un error de aproximadamente ±2 %. Para valores de unos 100 Ω usa una referencia de 1 kΩ, y para megaohmios una de 1 MΩ, y actualiza la constante RREF; medir una vez con el multímetro el valor real de la referencia y escribirlo en el código mejora mucho la precisión.

1// Basit ohmmetre: 5V - Rref - A0 - Rx - GND / Simple ohmmeter: 5V - Rref - A0 - Rx - GND
2const float RREF = 10000.0;   // bilinen direnç, multimetreyle ölçtüğün değeri yaz / known resistor, enter its measured value
3const int OLCUM_PIN = A0;
4
5void setup() {
6  Serial.begin(9600);
7}
8
9void loop() {
10  long toplam = 0;
11  for (int i = 0; i < 16; i++) {          // 16 okumanın ortalaması / average of 16 readings
12    toplam += analogRead(OLCUM_PIN);
13    delay(2);
14  }
15  float ham = toplam / 16.0;
16
17  if (ham > 1018) {
18    Serial.println(F("Acik devre / Open circuit"));
19  } else if (ham < 2) {
20    Serial.println(F("Kisa devre / Short circuit"));
21  } else {
22    float rx = RREF * ham / (1024.0 - ham); // Rx = Rref * ham / (1024 - ham)
23    Serial.print(F("Rx = "));
24    if (rx >= 1000) {
25      Serial.print(rx / 1000.0, 2);
26      Serial.println(F(" kOhm"));
27    } else {
28      Serial.print(rx, 1);
29      Serial.println(F(" Ohm"));
30    }
31  }
32  delay(1000);
33}

Que lo descifre Arduino: decodificador de códigos SMD en el Monitor Serie

El programa siguiente aplica todas las reglas de resistencias de este artículo: entiende códigos de 3 y 4 dígitos, la notación con R, EIA-96 y los puentes de 0 ohmios. Abre el Monitor Serie a 9600 baudios con el ajuste de fin de línea "Nueva línea", escribe un código como 4702 o 68X y pulsa Enter. Como la letra R puede ser tanto coma decimal como multiplicador EIA-96, el programa interpreta primero los códigos con R como notación decimal (47R = 47 Ω); la herramienta Código SMD sigue la misma regla. La tabla E96 se guarda en la memoria flash con PROGMEM, así que no gasta los 2 KB de RAM del Uno. El código también compila y funciona en el ESP32 sin ningún cambio. Si usas el Monitor Serie por primera vez, echa un vistazo a Monitor Serie Arduino.

1// SMD direnç kodu çözücü: Seri Monitör'e kodu yaz, değeri gör / SMD resistor code decoder: type a code in the Serial Monitor, see the value
2const uint16_t E96[96] PROGMEM = {
3  100, 102, 105, 107, 110, 113, 115, 118, 121, 124, 127, 130, 133, 137, 140, 143,
4  147, 150, 154, 158, 162, 165, 169, 174, 178, 182, 187, 191, 196, 200, 205, 210,
5  215, 221, 226, 232, 237, 243, 249, 255, 261, 267, 274, 280, 287, 294, 301, 309,
6  316, 324, 332, 340, 348, 357, 365, 374, 383, 392, 402, 412, 422, 432, 442, 453,
7  464, 475, 487, 499, 511, 523, 536, 549, 562, 576, 590, 604, 619, 634, 649, 665,
8  681, 698, 715, 732, 750, 768, 787, 806, 825, 845, 866, 887, 909, 931, 953, 976
9};
10
11// EIA-96 harf çarpanı; bilinmeyen harfte -1 / EIA-96 letter multiplier; -1 for an unknown letter
12float eiaCarpan(char c) {
13  switch (c) {
14    case 'Z': return 0.001;
15    case 'Y': case 'R': return 0.01;
16    case 'X': case 'S': return 0.1;
17    case 'A': return 1;
18    case 'B': case 'H': return 10;
19    case 'C': return 100;
20    case 'D': return 1000;
21    case 'E': return 10000;
22    case 'F': return 100000;
23    default: return -1;
24  }
25}
26
27// Kodu ohma çevirir, geçersizse -1 döner / Converts the code to ohms, returns -1 if invalid
28float smdCoz(String kod) {
29  kod.trim();
30  kod.toUpperCase();
31  int n = kod.length();
32  if (n == 0 || n > 5) return -1;
33
34  int r = kod.indexOf('R');
35  if (r >= 0) {                                  // R ondalık virgüldür: 4R7, R47, 47R / R is the decimal point
36    if (kod.lastIndexOf('R') != r || n < 2) return -1;
37    for (int i = 0; i < n; i++) {
38      if (i != r && !isDigit(kod[i])) return -1;
39    }
40    kod.replace('R', '.');
41    return kod.toFloat();                        // "4.7" -> 4.7, ".47" -> 0.47
42  }
43
44  if (n == 3 && isDigit(kod[0]) && isDigit(kod[1]) && isAlpha(kod[2])) {   // EIA-96: 01C
45    int sira = kod.substring(0, 2).toInt();
46    float carpan = eiaCarpan(kod[2]);
47    if (sira < 1 || sira > 96 || carpan < 0) return -1;
48    return pgm_read_word(&E96[sira - 1]) * carpan;
49  }
50
51  for (int i = 0; i < n; i++) {
52    if (!isDigit(kod[i])) return -1;
53  }
54  if (n <= 2) return kod.toInt() == 0 ? 0 : -1;  // 0 ya da 00: köprü direnci / 0 or 00: jumper
55  long taban = kod.substring(0, n - 1).toInt();  // 3 hane: 2 rakam, 4 hane: 3 rakam / significant digits
56  int sifir = kod[n - 1] - '0';                  // son hane: sıfır sayısı / last digit: number of zeros
57  float deger = taban;
58  for (int i = 0; i < sifir; i++) deger *= 10;
59  return deger;
60}
61
62void ohmYaz(float r) {
63  if (r >= 1e6) { Serial.print(r / 1e6, 3); Serial.println(F(" MOhm")); }
64  else if (r >= 1e3) { Serial.print(r / 1e3, 3); Serial.println(F(" kOhm")); }
65  else { Serial.print(r, 3); Serial.println(F(" Ohm")); }
66}
67
68void setup() {
69  Serial.begin(9600);
70  Serial.println(F("SMD kodunu yaz (or. 103, 4702, 4R7, 01C) / Type an SMD code"));
71}
72
73void loop() {
74  if (Serial.available()) {
75    String kod = Serial.readStringUntil('\n');
76    kod.trim();
77    if (kod.length() == 0) return;
78    float r = smdCoz(kod);
79    Serial.print(kod);
80    Serial.print(F(" = "));
81    if (r < 0) Serial.println(F("gecersiz kod / invalid code"));
82    else ohmYaz(r);
83  }
84}

Medir con ESP32 y Raspberry Pi Pico

Para usar el óhmetro en un ESP32, cambia el pin de medida al 34 y conecta el extremo superior de Rref al pin 3V3. El GPIO 34 pertenece al grupo ADC1, que sigue funcionando con el Wi-Fi activo. A diferencia del Uno, el ADC del ESP32 no mide en proporción a la tensión de alimentación y no es lineal cerca de los extremos, así que cambiar solo 1024 por 4096 en la fórmula puede dar errores de más del 10 por ciento. Usa en su lugar analogReadMilliVolts(), que devuelve milivoltios calibrados, y escribe la fórmula como Rx = Rref × V / (3300 − V), con V en milivoltios; si en lugar de 3300 pones la tensión que mides con el multímetro en el pin 3V3, el resultado mejora aún más. Como el ADC se satura hacia 3,1 V, baja el umbral de circuito abierto a unos 3000 mV y mantén la resistencia medida cerca de la de referencia. En la Raspberry Pi Pico, el código MicroPython de abajo descifra códigos SMD y además mide resistencias en GP26. La función read_u16() de la Pico devuelve un valor de 0 a 65535, así que el 1024 de la fórmula pasa a ser 65535. Si eres nuevo con la Pico, empieza por ¿Qué es la Raspberry Pi Pico?.

1from machine import ADC
2import time
3
4E96 = [100, 102, 105, 107, 110, 113, 115, 118, 121, 124, 127, 130, 133, 137, 140, 143,
5       147, 150, 154, 158, 162, 165, 169, 174, 178, 182, 187, 191, 196, 200, 205, 210,
6       215, 221, 226, 232, 237, 243, 249, 255, 261, 267, 274, 280, 287, 294, 301, 309,
7       316, 324, 332, 340, 348, 357, 365, 374, 383, 392, 402, 412, 422, 432, 442, 453,
8       464, 475, 487, 499, 511, 523, 536, 549, 562, 576, 590, 604, 619, 634, 649, 665,
9       681, 698, 715, 732, 750, 768, 787, 806, 825, 845, 866, 887, 909, 931, 953, 976]
10EIA = {"Z": 0.001, "Y": 0.01, "R": 0.01, "X": 0.1, "S": 0.1, "A": 1,
11       "B": 10, "H": 10, "C": 100, "D": 1000, "E": 10000, "F": 100000}
12
13def smd_coz(kod):
14    kod = kod.strip().upper()
15    if "R" in kod:                                    # R ondalık virgüldür: 4R7, R47 / R is the decimal point
16        if kod.count("R") != 1 or not kod.replace("R", "").isdigit():
17            return None
18        return float(kod.replace("R", "."))
19    if len(kod) == 3 and kod[:2].isdigit() and kod[2] in EIA:   # EIA-96: 01C
20        sira = int(kod[:2])
21        return E96[sira - 1] * EIA[kod[2]] if 1 <= sira <= 96 else None
22    if kod.isdigit():
23        if len(kod) <= 2:
24            return 0.0 if int(kod) == 0 else None     # 0 ya da 00: köprü / 0 or 00: jumper
25        return int(kod[:-1]) * 10 ** int(kod[-1])     # son hane sıfır sayısı / last digit = number of zeros
26    return None
27
28def ohm_yaz(r):
29    if r >= 1e6:
30        return "{:.3g} MOhm".format(r / 1e6)
31    if r >= 1e3:
32        return "{:.3g} kOhm".format(r / 1e3)
33    return "{:.3g} Ohm".format(r)
34
35adc = ADC(26)                  # GP26 = ADC0
36RREF = 10000                   # 3V3 ile GP26 arasındaki bilinen direnç / known resistor between 3V3 and GP26
37
38def olc():
39    toplam = 0
40    for _ in range(32):        # 32 okumanın ortalaması / average of 32 readings
41        toplam += adc.read_u16()
42        time.sleep_ms(2)
43    ham = toplam / 32
44    if ham > 65000:
45        return None            # açık devre / open circuit
46    return RREF * ham / (65535 - ham)
47
48for kod in ("103", "4702", "4R7", "01C", "68X"):
49    print(kod, "=", ohm_yaz(smd_coz(kod)))
50
51while True:
52    rx = olc()
53    print("Rx =", ohm_yaz(rx) if rx is not None else "acik devre / open circuit")
54    time.sleep(1)

Errores frecuentes y cómo solucionarlos

Ideas para practicar con los códigos SMD

• Examina tu placa: Lee los códigos de las resistencias de tu Arduino Nano o tu placa ESP32; busca los códigos 102 o 103 junto a los LED y averigua qué resistencia alimenta cada LED.
• Óhmetro con pantalla: Combina el óhmetro anterior con una pantalla LCD I2C para crear un medidor de resistencias portátil.
• Capacímetro: Averigua el valor de condensadores cerámicos sin marcar cargándolos a través de una resistencia y midiendo la constante de tiempo RC; el método está en ¿Qué es un condensador?.
• Tu propia PCB: Diseña tu primera PCB con resistencias y condensadores 0805; los pasos están en Diseño de PCB con EasyEDA.
• Medidor de tensión de pila: Monta un divisor con dos resistencias SMD y mide una pila de 9 V con Arduino; elige las resistencias con la herramienta Divisor de tensión.
• Caja de componentes ordenada: Guarda las piezas SMD que desueldes en cajas etiquetadas con sus códigos; mide las que no llevan marca y apunta su valor en la etiqueta.

Leer códigos SMD puede parecer al principio como descifrar un mensaje secreto, pero en cuanto aprendes unas pocas reglas, cada resistencia y condensador de una placa empieza a contarte para qué sirve. Si quieres repasar cómo funcionan las resistencias con bandas de colores, echa un vistazo a ¿Qué es una resistencia?. En la app BlueGrays encontrarás proyectos en los que las resistencias son clave, desde encender un LED y medir la luz con un LDR hasta medir temperatura con un NTC o construir un voltímetro digital, todos con esquemas de circuito y código paso a paso.