Códigos de resistor SMD: como ler 103, 4702, 01C e 4R7

Os códigos de resistor SMD são as marcações curtas, de três ou quatro caracteres, impressas nos resistores de montagem em superfície (SMD) no lugar das faixas de cores, e indicam a resistência em ohms. Depois que você conhece a regra, eles são muito fáceis de ler: 103 = 10 kΩ, 4702 = 47 kΩ, 4R7 = 4,7 Ω e 01C = 10 kΩ. Em um código de três dígitos, os dois primeiros dígitos são o valor e o último é o número de zeros a acrescentar; em um código de quatro dígitos, os três primeiros dígitos são o valor. A letra R faz o papel da vírgula decimal, e os códigos formados por dois dígitos e uma letra são lidos na tabela EIA-96.

Placas Arduino Nano, placas de desenvolvimento ESP32, módulos de sensores e placas reguladoras são feitos quase inteiramente dessas pecinhas. Se você quer consertar um módulo, descobrir qual resistor alimenta o LED da sua placa, encontrar o valor de um resistor de pull-up ou projetar sua própria PCB, precisa saber ler esses códigos. Além dos resistores, este guia aborda os códigos de capacitores SMD (104 = 100 nF), os códigos de tamanho como 0603, 0805 e 1206, as marcações curtas de transistores e diodos SMD e como medir uma peça sem nenhuma marcação usando um Arduino.

O que é um resistor SMD e por que ele não tem código de cores?

SMD (Surface Mount Device, dispositivo de montagem em superfície) é uma peça cujos terminais não atravessam furos, e sim são soldados diretamente em ilhas na superfície da placa de circuito. Um resistor SMD é um pequeno bloco cerâmico com as pontas metalizadas; a camada protetora preta na parte de cima protege o filme resistivo e leva o código. Um resistor 0805 mede apenas 2 × 1,25 mm, então pintar quatro faixas de cores nele não é prático; em vez disso, o valor é impresso como um código em dígitos brancos. Resistores de tamanho 0402 ou menores não têm espaço nem para isso, por isso não têm nenhuma marcação. Lembre-se de que o código só informa a resistência: os limites de potência e tensão vêm do tamanho do corpo, e a tolerância geralmente pode ser deduzida pelo tipo de código.

Como ler um código de resistor SMD de 3 dígitos

O formato mais comum é o código de três dígitos. Os dois primeiros dígitos são a parte significativa do valor, e o terceiro diz quantos zeros acrescentar depois dela, ou seja, a potência de dez. Em 103 você acrescenta três zeros depois de 10: 10.000 Ω = 10 kΩ. Da mesma forma, 472 = 47 mais dois zeros = 4.700 Ω = 4,7 kΩ; 221 = 220 Ω; 334 = 330 kΩ; e 105 = 1.000.000 Ω = 1 MΩ. Esses códigos normalmente são usados em resistores de ±5%, e os valores vêm da série E24: 10, 11, 12, 13, 15, 16, 18, 20, 22, 24, 27, 30, 33, 36, 39, 43, 47, 51, 56, 62, 68, 75, 82 e 91, além dos seus múltiplos de dez. Se o valor que você leu não está nessa lista, ou você está lendo o código de cabeça para baixo, ou a peça não é um resistor.

Códigos de 4 dígitos e a letra R: 4702, 1002, 4R7

O código de quatro dígitos é usado em resistores de precisão de ±1%. A lógica é a mesma, mas a parte significativa tem três dígitos: os três primeiros dígitos são o valor e o quarto é o número de zeros. 1002 = 100 mais dois zeros = 10.000 Ω = 10 kΩ; 4702 = 47 kΩ; 1001 = 1 kΩ; 1000 = 100 Ω; 2201 = 2,2 kΩ; 1004 = 1 MΩ. Três dígitos significativos também permitem valores intermediários da série E96, como 49,9 kΩ (4992) ou 4,99 kΩ (4991). Resumindo, o mesmo resistor de 10 kΩ pode aparecer como 103, 1002 ou 01C, dependendo do fabricante e da precisão; os três são o mesmo valor.

Valores abaixo de 10 Ω não podem ser escritos com um número de zeros, então a letra R ocupa o lugar da vírgula decimal. 4R7 = 4,7 Ω, 2R2 = 2,2 Ω, 1R0 = 1 Ω e R47 = 0,47 Ω. A versão de quatro caracteres segue a mesma regra: 10R0 = 10 Ω, 4R70 = 4,7 Ω. Valores muito pequenos geralmente são resistores shunt usados para medir corrente: R100 = 0,1 Ω (você vai vê-lo em módulos de medição de corrente como o INA219) e R010 = 0,01 Ω, ou 10 mΩ. Esquemas e listas de peças usam a mesma ideia com as letras k e M: 4k7 = 4,7 kΩ, 2M2 = 2,2 MΩ. Essa notação é preferida porque uma vírgula decimal que se perde na impressão poderia transformar 4,7 kΩ em 47 kΩ.

Como ler códigos EIA-96 (01C, 68X, 85B)

Quatro dígitos não cabem em um resistor de 1% no tamanho 0603. Para esses, usa-se um sistema de três caracteres chamado EIA-96: os dois primeiros dígitos (01–96) são o número da posição do valor na série E96, e a letra final é o multiplicador. O valor número 01 é 100, o número 68 é 499 e o número 85 é 750. Assim, 01C = 100 × 100 = 10 kΩ, 68X = 499 × 0,1 = 49,9 Ω e 85B = 750 × 10 = 7,5 kΩ. Aqui não dá para calcular nada a partir dos dígitos; é preciso procurar o valor na tabela. O jeito mais rápido é digitar o código na ferramenta Código SMD, que entende códigos de 3 e 4 dígitos, a notação com R e o EIA-96.

Sublinhados, zero ohm e outros casos especiais

• Sublinhado: alguns fabricantes desenham uma linha sob o código de três dígitos em resistores que têm tolerância de 1%, mas valor da série E24. A linha não muda o valor; ela indica que a peça é um resistor de precisão e mostra em que posição ler.
• 0, 00 ou 000: é um resistor jumper de zero ohm. Ele é usado para ligar duas trilhas em uma PCB ou para ativar e desativar uma opção; nos tamanhos 0603 e 0805, normalmente suporta 1–2 A.
• Resistores sem marcação: peças de tamanho 0402, 0201 e menores não têm código nenhum. Só dá para descobrir o valor medindo ou pela etiqueta do rolo.
• Redes de resistores: as redes (arrays) com quatro resistores lado a lado em um só corpo levam um único código; uma rede marcada 103 contém quatro resistores de 10 kΩ. Elas são comuns em placas como o Arduino Uno.
• Resistores cilíndricos (MELF): esses resistores SMD têm a forma de um pequeno cilindro e levam faixas de cores, igual aos resistores PTH (de furo passante). Você pode decifrar as cores com a ferramenta Código de cores.
• Indutores SMD: os indutores usam códigos parecidos, mas a unidade é o micro-henry: 101 = 100 µH, 4R7 = 4,7 µH. Você pode lê-los com a ferramenta Código do indutor.

Tamanhos SMD: o que significam 0603, 0805 e 1206?

O código de tamanho informa as dimensões físicas da peça, não o seu valor. No sistema imperial, o mais usado, os dois primeiros dígitos dão o comprimento e os dois últimos a largura, em centésimos de polegada: 0805 é 0,08 × 0,05 polegada, ou cerca de 2,0 × 1,25 mm. No sistema métrico, a mesma peça é escrita como 2012, em décimos de milímetro. Quanto maior o corpo, mais potência e tensão o resistor aguenta. Os tamanhos mais fáceis para soldar à mão são 1206 e 0805; o 0603 é tranquilo com pinça e uma ponta de ferro fina, enquanto 0402 ou menores exigem lupa e paciência. Os valores abaixo são típicos; os limites exatos variam um pouco entre fabricantes.

As potências nominais geralmente são dadas para uma temperatura ambiente de 70 °C e caem conforme esquenta, então trabalhar em torno da metade do limite é um bom hábito. Calcule a potência que um resistor dissipa com P = V × I ou P = I² × R. Exemplo: para acionar um LED vermelho com 20 mA a partir de 5 V, você precisa de (5 − 2) / 0,02 = 150 Ω, e a potência no resistor é 3 V × 0,02 A = 0,06 W. Um 0603 (0,1 W) dá conta, mas um 0805 fica mais folgado. Se você alimentar o mesmo LED com 12 V, precisa de 510 Ω e a potência sobe para 10 V × 0,02 A = 0,2 W; um 1206 ficaria no limite, então escolha um 1210 ou um corpo maior. Para entender o raciocínio por trás dessas contas, dê uma olhada em Lei de Ohm explicada.

Códigos de capacitores SMD: 104 = 100 nF

Os códigos de capacitores seguem a mesma lógica dos códigos de resistores, mas a unidade é o picofarad (pF): os dois primeiros dígitos são o valor e o terceiro é o número de zeros. 104 = 10 mais quatro zeros = 100.000 pF = 100 nF = 0,1 µF. 103 = 10 nF, 102 = 1 nF, 105 = 1 µF, 106 = 10 µF. Ao converter unidades, lembre-se de que 1 µF = 1.000 nF = 1.000.000 pF. Se você vir um 8 ou um 9 na terceira posição, ele não é um número de zeros, e sim um multiplicador: 9 = × 0,1 e 8 = × 0,01, então 229 = 2,2 pF e 479 = 4,7 pF. Uma letra depois do valor indica a tolerância: J = ±5%, K = ±10%, M = ±20%. Quando a letra fica no meio, ela marca ao mesmo tempo a unidade e a vírgula decimal: 4n7 = 4,7 nF, p47 = 0,47 pF, 2u2 = 2,2 µF. Para converter códigos rapidamente, use a ferramenta Código do capacitor.

Um fato importante: a maioria dos capacitores cerâmicos SMD (MLCCs) não tem nenhuma marcação. O valor desses pequenos blocos marrons, beges ou cinzas só pode ser descoberto pela etiqueta do rolo ou com um multímetro que mede capacitância. Os 106 e 104 que você viu na placa do AMS1117 acima estão impressos na placa, não nos capacitores. Em peças mais antigas ou de alguns fabricantes, você pode encontrar um código de dois caracteres formado por uma letra e um dígito: a letra dá o valor da série E24 (A = 1,0, E = 1,5, J = 2,2, N = 3,3, S = 4,7, W = 6,8) e o dígito, o número de zeros em pF, então S3 = 4,7 × 1.000 pF = 4,7 nF. Os X7R, X5R e C0G (NP0) da etiqueta do rolo são tipos de dielétrico: o C0G quase não muda com a temperatura, enquanto o X7R e o X5R podem perder grande parte da capacitância conforme a tensão CC aplicada aumenta.

Os capacitores de tântalo geralmente têm um corpo retangular amarelo, laranja ou preto. Eles levam um código em pF (106 = 10 µF, 476 = 47 µF, 107 = 100 µF) e, muitas vezes, uma letra de tensão: J = 6,3 V, A = 10 V, C = 16 V, D = 20 V, E = 25 V, V = 35 V. Alguns fabricantes imprimem a tensão diretamente, em vez de uma letra. Os eletrolíticos de alumínio SMD são pequenas latinhas metálicas; o valor é impresso diretamente em µF, e a meia-lua preta na parte de cima marca o terminal negativo (−). Marcações como 2A104J em capacitores de filme e cerâmicos maiores se dividem em três partes: 2A = 100 V, 104 = 100 nF, J = ±5%. Outros códigos de tensão comuns são 1C = 16 V, 1E = 25 V, 1H = 50 V e 2J = 630 V. Você encontra mais sobre os tipos de capacitores em O que é capacitor?.

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

O código completo da peça não cabe em encapsulamentos pequenos como o SOT-23, por isso transistores e diodos levam um código de marcação de 2–3 caracteres. Esses códigos não seguem um padrão único: o mesmo código pode significar peças completamente diferentes em dois fabricantes, e uma letra pequena no final geralmente é um código de fábrica ou de data. Ao identificar uma peça, use três pistas juntas: o tipo de encapsulamento, o código de marcação e a função da peça no circuito. Nos transistores bipolares, a ordem dos pinos do SOT-23 costuma ser 1 = base, 2 = emissor, 3 = coletor; nos MOSFETs como o 2N7002, é 1 = gate, 2 = fonte, 3 = dreno. Para pinagens e equivalentes, veja a ferramenta Transistores e, para saber como funcionam, leia O que é transistor?.

Medindo um resistor sem marcação ou ilegível: um ohmímetro com Arduino

Se o código se apagou, a peça é um 0402 ou você não tem certeza do resultado, o jeito mais confiável é medir. Ao medir com um multímetro, retire o resistor do circuito se puder ou, pelo menos, levante uma das pontas; caminhos em paralelo no circuito fazem a leitura ficar abaixo do valor real. Se você não tem multímetro, pode montar um ohmímetro simples com um Arduino. O circuito é um divisor de tensão: você liga um resistor de referência de valor conhecido (Rref) em série com o resistor a ser medido (Rx) e lê a tensão no ponto central com um pino analógico. Como a leitura analógica do Arduino é raciométrica em relação à tensão de alimentação, a fórmula é bem simples: Rx = Rref × leitura / (1024 − leitura). O resultado é mais preciso quando Rx está próximo de Rref: com uma referência de 10 kΩ, você consegue medir resistores entre 1 kΩ e 100 kΩ com cerca de ±2%. Use uma referência de 1 kΩ para valores em torno de 100 Ω e uma de 1 MΩ para megaohms, e atualize a constante RREF; medir uma vez o valor real da referência com um multímetro e colocá-lo no código melhora bastante a precisão.

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}

Deixe o Arduino fazer isso: um decodificador de códigos SMD no Monitor Serial

O programa abaixo aplica todas as regras de resistores deste artigo: ele entende códigos de 3 e 4 dígitos, a notação com R, o EIA-96 e os jumpers de 0 ohm. Abra o Monitor Serial a 9600 baud com o final de linha “Nova linha”, digite um código como 4702 ou 68X e aperte Enter. Como a letra R pode ser tanto vírgula decimal quanto multiplicador do EIA-96, o programa trata primeiro os códigos que contêm R como notação decimal (47R = 47 Ω); a ferramenta Código SMD segue a mesma regra. A tabela E96 fica guardada na memória flash com PROGMEM, então não ocupa os 2 KB de RAM do Uno. O código também compila e roda no ESP32 sem nenhuma alteração. Se você vai usar o Monitor Serial pela primeira vez, dê uma olhada em Monitor Serial do 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}

Medindo com o ESP32 e o Raspberry Pi Pico

Para usar o código do ohmímetro em um ESP32, mude o pino de medição para 34 e ligue a ponta de cima do Rref ao pino 3V3. O GPIO 34 pertence ao grupo ADC1, que continua funcionando com o Wi-Fi ligado. Ao contrário do Uno, o ADC do ESP32 não é raciométrico em relação à tensão de alimentação e não é linear perto das extremidades da faixa, então simplesmente trocar 1024 por 4096 na fórmula pode dar erros de mais de 10 por cento. Use em vez disso analogReadMilliVolts(), que retorna milivolts calibrados, e escreva a fórmula como Rx = Rref × V / (3300 − V), com V em milivolts; digitar no lugar de 3300 a tensão que você mediu no pino 3V3 com um multímetro melhora ainda mais o resultado. Como o ADC satura por volta de 3,1 V, baixe o limite de circuito aberto para cerca de 3000 mV e mantenha o resistor medido próximo da referência. No Raspberry Pi Pico, o código MicroPython abaixo tanto decifra códigos SMD quanto mede resistência no GP26. O read_u16() do Pico retorna um valor de 0 a 65535, então o 1024 da fórmula vira 65535 aqui. Se você está começando com o Pico, comece por O que é o 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)

Erros comuns e como corrigir

Ideias para praticar com códigos SMD

• Examine sua placa: leia os códigos dos resistores do seu Arduino Nano ou da sua placa ESP32; encontre os códigos 102 ou 103 ao lado dos LEDs e descubra qual resistor alimenta qual LED.
• Ohmímetro com display: combine o ohmímetro acima com um display LCD I2C para fazer um medidor de resistência portátil.
• Capacímetro: descubra o valor de capacitores cerâmicos sem marcação carregando-os por meio de um resistor e medindo a constante de tempo RC; o método está em O que é capacitor?.
• Sua própria PCB: projete sua primeira PCB com resistores e capacitores 0805; os passos estão em Projeto de PCB com EasyEDA.
• Medidor de tensão de bateria: monte um divisor com dois resistores SMD e meça uma bateria de 9 V com um Arduino; escolha os resistores com a ferramenta Divisor de tensão.
• Caixa de peças organizada: guarde as peças SMD que você dessoldar em caixinhas etiquetadas com os códigos; meça as peças sem marcação e escreva o valor na etiqueta.

Ler códigos SMD pode parecer decifrar uma mensagem secreta no começo, mas, depois que você aprende algumas regras, cada resistor e capacitor de uma placa começa a contar para que serve. Se quiser rever como funcionam os resistores com faixas de cores, dê uma olhada em O que é resistor?. No app BlueGrays você encontra projetos em que os resistores têm papel central, de acender um LED e medir a luz com um LDR até a medição de temperatura com NTC e um voltímetro digital, cada um com esquemas do circuito e código passo a passo.