Codice resistenze SMD: come leggere 103, 4702, 01C e 4R7

Il codice delle resistenze SMD è la breve sigla di tre o quattro caratteri stampata sulle resistenze a montaggio superficiale (SMD) al posto delle fasce colorate, e indica il valore in ohm. Una volta imparata la regola è facilissimo da leggere: 103 = 10 kΩ, 4702 = 47 kΩ, 4R7 = 4,7 Ω e 01C = 10 kΩ. Nel codice a tre cifre le prime due sono il valore e l'ultima è il numero di zeri da aggiungere; nel codice a quattro cifre sono le prime tre a formare il valore. La lettera R prende il posto della virgola, mentre i codici formati da due cifre e una lettera si leggono nella tabella EIA-96.

Arduino Nano, schede di sviluppo ESP32, moduli sensore e schede regolatrici sono quasi interamente fatti di questi minuscoli componenti. Se vuoi riparare un modulo, capire quale resistenza alimenta il LED della tua scheda, trovare il valore di una resistenza di pull-up o progettare il tuo circuito stampato, devi saper leggere questi codici. Oltre alle resistenze, in questa guida imparerai i codici dei condensatori SMD (104 = 100 nF), i formati come 0603, 0805 e 1206, le brevi sigle di transistor e diodi SMD e come misurare con Arduino un componente che non ha alcuna scritta.

Cos'è una resistenza SMD e perché non ha il codice colori?

SMD (Surface Mount Device) indica un componente i cui terminali non passano attraverso i fori, ma vengono saldati direttamente sulle piazzole sulla superficie del circuito stampato. Una resistenza SMD è un piccolo blocchetto di ceramica con le estremità metallizzate; lo strato nero superiore protegge il film resistivo e porta il codice. Una resistenza in formato 0805 misura solo 2 × 1,25 mm, quindi dipingerci sopra quattro fasce colorate non è pratico: il valore viene stampato come codice in cifre bianche. Sui formati 0402 e più piccoli non c'è spazio nemmeno per quello, perciò questi componenti non hanno alcuna sigla. Ricorda che il codice indica solo la resistenza: i limiti di potenza e tensione dipendono dalle dimensioni del corpo, mentre la tolleranza si capisce di solito dal tipo di codice.

Come leggere il codice SMD a 3 cifre

Il formato più comune è il codice a tre cifre. Le prime due cifre sono la parte significativa del valore, la terza indica quanti zeri aggiungere dopo, cioè la potenza di dieci. Con 103 si aggiungono tre zeri al 10: 10.000 Ω = 10 kΩ. Allo stesso modo 472 = 47 e due zeri = 4.700 Ω = 4,7 kΩ; 221 = 220 Ω; 334 = 330 kΩ e 105 = 1.000.000 Ω = 1 MΩ. Questi codici si usano di solito sulle resistenze al ±5% e i valori provengono dalla 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 e 91, più i loro multipli di dieci. Se il valore che leggi non è in questo elenco, o stai leggendo il codice capovolto o il componente non è una resistenza.

Codice a 4 cifre e lettera R: 4702, 1002, 4R7

Il codice a quattro cifre si usa sulle resistenze di precisione con tolleranza ±1%. La logica è la stessa, ma la parte significativa ha tre cifre: le prime tre sono il valore e la quarta il numero di zeri. 1002 = 100 e due zeri = 10.000 Ω = 10 kΩ; 4702 = 47 kΩ; 1001 = 1 kΩ; 1000 = 100 Ω; 2201 = 2,2 kΩ; 1004 = 1 MΩ. Tre cifre significative permettono di scrivere anche valori intermedi della serie E96, come 49,9 kΩ (4992) o 4,99 kΩ (4991). In breve, la stessa resistenza da 10 kΩ può presentarsi come 103, 1002 o 01C a seconda del produttore e della precisione: tutti e tre indicano lo stesso valore.

I valori sotto i 10 Ω non si possono scrivere con un numero di zeri, quindi la lettera R prende il posto della virgola. 4R7 = 4,7 Ω, 2R2 = 2,2 Ω, 1R0 = 1 Ω e R47 = 0,47 Ω. La versione a quattro caratteri segue la stessa regola: 10R0 = 10 Ω, 4R70 = 4,7 Ω. I valori molto piccoli sono di solito resistenze di shunt usate per misurare la corrente: R100 = 0,1 Ω (la trovi sui moduli di misura della corrente come l'INA219) e R010 = 0,01 Ω, cioè 10 mΩ. Negli schemi e nelle distinte componenti si usa la stessa idea con le lettere k e M: 4k7 = 4,7 kΩ, 2M2 = 2,2 MΩ. Si preferisce questa notazione perché una virgola persa in stampa potrebbe trasformare 4,7 kΩ in 47 kΩ.

Come leggere il codice EIA-96 (01C, 68X, 85B)

Su una resistenza all'1% in formato 0603 quattro cifre non ci stanno. Per queste si usa un sistema a tre caratteri chiamato EIA-96: le prime due cifre (01–96) sono il numero d'ordine del valore nella serie E96 e la lettera finale è il moltiplicatore. Il valore numero 01 è 100, il 68 è 499 e l'85 è 750. Quindi 01C = 100 × 100 = 10 kΩ, 68X = 499 × 0,1 = 49,9 Ω e 85B = 750 × 10 = 7,5 kΩ. Qui non puoi calcolare nulla dalle cifre: devi cercare il valore nella tabella. Il modo più rapido è scrivere il codice nello strumento Codice SMD, che riconosce i codici a 3 e 4 cifre, la notazione con R e l'EIA-96.

Sottolineatura, zero ohm e altri casi particolari

• Sottolineatura: Alcuni produttori tracciano una linea sotto il codice a tre cifre delle resistenze all'1% con un valore della serie E24. La linea non cambia il valore; indica che si tratta di una resistenza di precisione e in quale verso leggerla.
• 0, 00 o 000: È una resistenza da zero ohm usata come ponticello (jumper). Serve a collegare due piste del circuito stampato o ad attivare e disattivare un'opzione; nei formati 0603 e 0805 regge di solito 1–2 A.
• Resistenze senza sigla: I componenti 0402, 0201 e più piccoli non hanno alcun codice. Il valore si conosce solo misurandolo o dall'etichetta della bobina di confezionamento (reel).
• Reti di resistenze: Gli array con quattro resistenze affiancate in un unico corpo riportano un solo codice; un array siglato 103 contiene quattro resistenze da 10 kΩ. Si trovano spesso su schede come Arduino Uno.
• Resistenze cilindriche (MELF): Queste resistenze SMD hanno la forma di un piccolo cilindro e riportano fasce colorate come le resistenze a foro passante. Puoi decifrare i colori con lo strumento Codice colori.
• Induttori SMD: Gli induttori usano codici simili, ma in microhenry: 101 = 100 µH, 4R7 = 4,7 µH. Puoi leggerli con lo strumento Codice induttore.

Formati SMD: cosa significano 0603, 0805 e 1206?

Il codice del formato indica le dimensioni fisiche del componente, non il suo valore. Nel sistema in pollici, il più diffuso, le prime due cifre danno la lunghezza e le ultime due la larghezza in centesimi di pollice: 0805 corrisponde a 0,08 × 0,05 pollici, circa 2,0 × 1,25 mm. Nel sistema metrico lo stesso componente si scrive 2012, in decimi di millimetro. Più il corpo è grande, più potenza e tensione la resistenza sopporta. I formati più comodi da saldare a mano sono 1206 e 0805; lo 0603 si salda bene con le pinzette e una punta sottile, mentre lo 0402 e i più piccoli richiedono lente d'ingrandimento e pazienza. I valori qui sotto sono tipici; i limiti esatti variano un po' da produttore a produttore.

Le potenze sono di solito indicate per una temperatura ambiente di 70 °C e diminuiscono quando fa più caldo, quindi lavorare intorno a metà del limite è una buona abitudine. Calcola la potenza dissipata da una resistenza con P = V × I oppure P = I² × R. Esempio: per alimentare un LED rosso a 20 mA da 5 V servono (5 − 2) / 0,02 = 150 Ω, e la potenza sulla resistenza è 3 V × 0,02 A = 0,06 W. Una 0603 (0,1 W) la regge, ma una 0805 ha più margine. Se alimenti lo stesso LED a 12 V servono 510 Ω e la potenza sale a 10 V × 0,02 A = 0,2 W; una 1206 sarebbe al limite, quindi scegli una 1210 o un corpo più grande. Per ripassare questi calcoli leggi Legge di Ohm spiegata.

Codice dei condensatori SMD: 104 = 100 nF

I codici dei condensatori seguono la stessa logica di quelli delle resistenze, ma l'unità è il picofarad (pF): le prime due cifre sono il valore e la terza il numero di zeri. 104 = 10 e quattro zeri = 100.000 pF = 100 nF = 0,1 µF. 103 = 10 nF, 102 = 1 nF, 105 = 1 µF, 106 = 10 µF. Per convertire le unità ricorda che 1 µF = 1.000 nF = 1.000.000 pF. Se in terza posizione vedi un 8 o un 9, non è un numero di zeri ma un moltiplicatore: 9 = × 0,1 e 8 = × 0,01; quindi 229 = 2,2 pF e 479 = 4,7 pF. Una lettera dopo il valore indica la tolleranza: J = ±5%, K = ±10%, M = ±20%. Quando la lettera sta in mezzo, indica sia l'unità sia la virgola: 4n7 = 4,7 nF, p47 = 0,47 pF, 2u2 = 2,2 µF. Per convertire velocemente i codici usa lo strumento Codice condensatore.

C'è un fatto importante: la maggior parte dei condensatori ceramici SMD (MLCC) non ha alcuna sigla. Il valore di questi piccoli blocchetti marroni, beige o grigi si conosce solo dall'etichetta della bobina di confezionamento o con un multimetro che misura la capacità. Anche il 106 e il 104 visti sulla scheda AMS1117 sono stampati sulla scheda, non sui condensatori. Su componenti vecchi o di alcuni produttori puoi trovare un codice di due caratteri formato da una lettera e una cifra: la lettera indica il valore della serie E24 (A = 1,0; E = 1,5; J = 2,2; N = 3,3; S = 4,7; W = 6,8) e la cifra il numero di zeri in pF; S3 = 4,7 × 1.000 pF = 4,7 nF. Le sigle X7R, X5R e C0G (NP0) sull'etichetta indicano il tipo di dielettrico: il C0G non cambia quasi con la temperatura, mentre X7R e X5R possono perdere buona parte della capacità all'aumentare della tensione continua applicata.

I condensatori al tantalio hanno di solito un corpo rettangolare giallo, arancione o nero. Riportano un codice in pF (106 = 10 µF, 476 = 47 µF, 107 = 100 µF) e spesso una lettera per la tensione: J = 6,3 V, A = 10 V, C = 16 V, D = 20 V, E = 25 V, V = 35 V. Alcuni produttori stampano direttamente la tensione. Gli elettrolitici in alluminio SMD sono piccoli barattolini metallici; il valore è stampato direttamente in µF e la mezzaluna nera sulla parte superiore indica il terminale negativo (−). Sigle come 2A104J sui condensatori a film e sui ceramici più grandi si dividono in tre parti: 2A = 100 V, 104 = 100 nF, J = ±5%. Altri codici di tensione comuni sono 1C = 16 V, 1E = 25 V, 1H = 50 V e 2J = 630 V. Trovi altri dettagli sui tipi di condensatori in Cos'è un condensatore?.

Codici di transistor e diodi SMD (1AM, J3Y, A7, M7)

Sui contenitori piccoli come il SOT-23 il nome completo non ci sta, quindi transistor e diodi riportano un codice di marcatura (marking code) di 2–3 caratteri. Questi codici non seguono uno standard unico: lo stesso codice può indicare componenti completamente diversi di due produttori, e una lettera minuscola finale è spesso un codice di stabilimento o di data. Per identificare un componente combina tre indizi: il tipo di contenitore, il codice di marcatura e la funzione del componente nel circuito. Nei transistor bipolari in SOT-23 l'ordine dei piedini è di solito 1 = base, 2 = emettitore, 3 = collettore; nei MOSFET come il 2N7002 è 1 = gate, 2 = source, 3 = drain. Per piedinature ed equivalenti consulta lo strumento Transistor, e per capire come funzionano leggi Cos'è un transistor?.

Misurare una resistenza senza sigla o illeggibile: ohmmetro con Arduino

Se il codice è cancellato, il componente è uno 0402 o non sei sicuro del risultato, la cosa più affidabile è misurare. Con il multimetro, dissalda la resistenza se puoi, o almeno solleva un'estremità; i percorsi in parallelo del circuito fanno leggere un valore più basso di quello reale. Se non hai un multimetro, puoi costruire un semplice ohmmetro con Arduino. Il circuito è un partitore di tensione: colleghi in serie una resistenza di riferimento di valore noto (Rref) e la resistenza da misurare (Rx), e leggi la tensione nel punto centrale con un pin analogico. Poiché la lettura analogica di Arduino è proporzionale alla tensione di alimentazione, la formula è semplicissima: Rx = Rref × lettura / (1024 − lettura). Il risultato più preciso si ottiene quando Rx è vicina a Rref: con un riferimento da 10 kΩ misuri resistenze da 1 kΩ a 100 kΩ con una precisione di circa ±2%. Per valori intorno ai 100 Ω usa un riferimento da 1 kΩ, per i megaohm uno da 1 MΩ, e aggiorna la costante RREF; misurare una volta con il multimetro il valore reale del riferimento e scriverlo nel codice migliora molto la precisione.

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}

Lascia fare ad Arduino: decodificatore di codici SMD nel Monitor seriale

Il programma qui sotto applica tutte le regole sulle resistenze di questo articolo: riconosce i codici a 3 e 4 cifre, la notazione con R, l'EIA-96 e i ponticelli da 0 ohm. Apri il Monitor seriale a 9600 baud con il fine riga "A capo (NL)", scrivi un codice come 4702 o 68X e premi Invio. Poiché la lettera R può essere sia la virgola sia un moltiplicatore EIA-96, il programma interpreta prima i codici con R come notazione decimale (47R = 47 Ω); lo strumento Codice SMD segue la stessa regola. La tabella E96 è conservata nella memoria flash con PROGMEM, quindi non consuma i 2 KB di RAM dell'Uno. Il codice si compila e funziona anche sull'ESP32 senza alcuna modifica. Se usi il Monitor seriale per la prima volta, dai un'occhiata a Monitor seriale 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}

Misurare con ESP32 e Raspberry Pi Pico

Per usare l'ohmmetro su un ESP32, imposta il pin di misura su 34 e collega l'estremità superiore di Rref al pin 3V3. Il GPIO 34 appartiene al gruppo ADC1, che funziona anche con il Wi-Fi attivo. A differenza di quello dell'Uno, l'ADC dell'ESP32 non misura in proporzione alla tensione di alimentazione e non è lineare vicino agli estremi della scala, quindi sostituire soltanto 1024 con 4096 nella formula può dare errori superiori al 10 per cento. Usa invece analogReadMilliVolts(), che restituisce millivolt calibrati, e scrivi la formula come Rx = Rref × V / (3300 − V), con V in millivolt; se al posto di 3300 inserisci la tensione misurata con il multimetro sul pin 3V3, il risultato migliora ancora. Poiché l'ADC va in saturazione verso 3,1 V, abbassa la soglia di circuito aperto a circa 3000 mV e tieni la resistenza misurata vicina a quella di riferimento. Sul Raspberry Pi Pico il codice MicroPython qui sotto decifra i codici SMD e misura anche le resistenze su GP26. La funzione read_u16() del Pico restituisce un valore da 0 a 65535, quindi il 1024 della formula qui diventa 65535. Se sei alle prime armi con il Pico, inizia da Cos'è il 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)

Errori comuni e soluzioni

Idee per esercitarti con i codici SMD

• Esamina la tua scheda: Leggi i codici delle resistenze del tuo Arduino Nano o della tua scheda ESP32; trova i codici 102 o 103 accanto ai LED e scopri quale resistenza alimenta quale LED.
• Ohmmetro con display: Unisci l'ohmmetro qui sopra a un display LCD I2C per creare un misuratore di resistenze portatile.
• Capacimetro: Trova il valore dei condensatori ceramici senza sigla caricandoli attraverso una resistenza e misurando la costante di tempo RC; il metodo è in Cos'è un condensatore?.
• Il tuo circuito stampato: Progetta il tuo primo PCB con resistenze e condensatori 0805; i passaggi sono in Progettare un PCB con EasyEDA.
• Misuratore di tensione della pila: Costruisci un partitore con due resistenze SMD e misura una pila da 9 V con Arduino; scegli le resistenze con lo strumento Partitore di tensione.
• Scatola dei componenti in ordine: Conserva i componenti SMD dissaldati in scatole etichettate con i loro codici; misura quelli senza sigla e scrivi il valore sull'etichetta.

Leggere i codici SMD all'inizio sembra come decifrare un messaggio segreto, ma appena impari poche regole ogni resistenza e ogni condensatore su una scheda comincia a raccontarti a cosa serve. Se vuoi ripassare come funzionano le resistenze con le fasce colorate, dai un'occhiata a Cos'è una resistenza?. Nell'app BlueGrays trovi progetti in cui le resistenze hanno un ruolo chiave, dall'accensione di un LED e la misura della luce con un LDR fino alla misura della temperatura con un NTC e al voltmetro digitale, ognuno con schemi elettrici e codice passo dopo passo.