SMD-Widerstand Code lesen: 103, 4702, 01C und 4R7 erklärt

SMD-Widerstandscodes sind die kurzen drei- oder vierstelligen Aufdrucke, die auf oberflächenmontierten (SMD) Widerständen statt Farbringen stehen und den Widerstandswert in Ohm angeben. Wenn du die Regel einmal kennst, sind sie sehr leicht zu lesen: 103 = 10 kΩ, 4702 = 47 kΩ, 4R7 = 4,7 Ω und 01C = 10 kΩ. Beim dreistelligen Code sind die ersten zwei Ziffern der Wert und die letzte Ziffer die Anzahl der angehängten Nullen; beim vierstelligen Code bilden die ersten drei Ziffern den Wert. Der Buchstabe R ersetzt das Komma, und Codes aus zwei Ziffern und einem Buchstaben werden in der EIA-96-Tabelle nachgeschlagen.

Arduino Nano, ESP32-Entwicklungsboards, Sensormodule und Spannungsregler-Platinen bestehen fast vollständig aus diesen winzigen Bauteilen. Wenn du ein Modul reparieren, herausfinden willst, über welchen Widerstand die LED auf deinem Board läuft, den Wert eines Pull-up-Widerstands suchst oder deine eigene Platine entwirfst, musst du diese Codes lesen können. Neben Widerständen lernst du in diesem Ratgeber auch SMD-Kondensatorcodes (104 = 100 nF), Bauformen wie 0603, 0805 und 1206, die kurzen Markierungen auf SMD-Transistoren und Dioden und wie du ein völlig unbeschriftetes Bauteil mit dem Arduino misst.

Was ist ein SMD-Widerstand und warum gibt es keinen Farbcode?

SMD (Surface Mount Device) bezeichnet ein Bauteil, dessen Anschlüsse nicht durch Bohrungen gesteckt, sondern direkt auf Lötpads an der Oberfläche der Platine gelötet werden. Ein SMD-Widerstand ist ein kleiner Keramikquader mit metallisierten Enden; die schwarze Schutzschicht oben schützt die Widerstandsschicht und trägt den Code. Ein Widerstand der Bauform 0805 misst nur 2 × 1,25 mm, vier Farbringe wären darauf kaum unterzubringen; deshalb wird der Wert als Code in weißen Ziffern aufgedruckt. Bei 0402 und kleiner ist nicht einmal dafür Platz, diese Bauteile sind komplett unbeschriftet. Denk daran, dass der Code nur den Widerstandswert verrät: Leistungs- und Spannungsgrenze ergeben sich aus der Bauform, die Toleranz meist aus der Art des Codes.

Dreistelligen SMD-Widerstandscode lesen

Am häufigsten ist der dreistellige Code. Die ersten zwei Ziffern sind die signifikanten Stellen des Werts, die dritte Ziffer gibt an, wie viele Nullen angehängt werden, also die Zehnerpotenz. Bei 103 hängst du an die 10 drei Nullen an: 10.000 Ω = 10 kΩ. Genauso ist 472 = 47 und zwei Nullen = 4.700 Ω = 4,7 kΩ; 221 = 220 Ω; 334 = 330 kΩ und 105 = 1.000.000 Ω = 1 MΩ. Diese Codes findest du meist auf Widerständen mit ±5 % Toleranz, die Werte stammen aus der E24-Reihe: 10, 11, 12, 13, 15, 16, 18, 20, 22, 24, 27, 30, 33, 36, 39, 43, 47, 51, 56, 62, 68, 75, 82 und 91 sowie deren Zehnerpotenzen. Passt der gelesene Wert nicht in diese Liste, liest du den Code entweder verkehrt herum oder das Bauteil ist kein Widerstand.

Vierstellige Codes und der Buchstabe R: 4702, 1002, 4R7

Der vierstellige Code wird bei Präzisionswiderständen mit ±1 % verwendet. Die Logik ist gleich, nur besteht der signifikante Teil aus drei Ziffern: Die ersten drei Ziffern sind der Wert, die vierte die Anzahl der Nullen. 1002 = 100 und zwei Nullen = 10.000 Ω = 10 kΩ; 4702 = 47 kΩ; 1001 = 1 kΩ; 1000 = 100 Ω; 2201 = 2,2 kΩ; 1004 = 1 MΩ. Mit drei signifikanten Stellen lassen sich auch Zwischenwerte der E96-Reihe wie 49,9 kΩ (4992) oder 4,99 kΩ (4991) darstellen. Kurz gesagt: Derselbe 10-kΩ-Widerstand kann dir je nach Hersteller und Genauigkeit als 103, 1002 oder 01C begegnen, alle drei bedeuten denselben Wert.

Werte unter 10 Ω lassen sich nicht über Nullen darstellen, deshalb steht der Buchstabe R an der Stelle des Kommas. 4R7 = 4,7 Ω, 2R2 = 2,2 Ω, 1R0 = 1 Ω und R47 = 0,47 Ω. Die vierstellige Variante folgt derselben Regel: 10R0 = 10 Ω, 4R70 = 4,7 Ω. Sehr kleine Werte sind meist Shunt-Widerstände zur Strommessung: R100 = 0,1 Ω (findest du auf Strommessmodulen wie dem INA219) und R010 = 0,01 Ω, also 10 mΩ. In Schaltplänen und Stücklisten wird dasselbe Prinzip mit k und M genutzt: 4k7 = 4,7 kΩ, 2M2 = 2,2 MΩ. Diese Schreibweise verhindert, dass aus 4,7 kΩ durch ein im Druck verlorenes Komma 47 kΩ werden.

EIA-96-Code lesen (01C, 68X, 85B)

Auf einen 1-%-Widerstand der Bauform 0603 passen keine vier Ziffern. Dafür gibt es das dreistellige EIA-96-System: Die ersten zwei Ziffern (01–96) sind die Positionsnummer des Werts in der E96-Reihe, der Buchstabe am Ende ist der Multiplikator. Wert Nummer 01 ist 100, Nummer 68 ist 499 und Nummer 85 ist 750. Damit ist 01C = 100 × 100 = 10 kΩ, 68X = 499 × 0,1 = 49,9 Ω und 85B = 750 × 10 = 7,5 kΩ. Aus den Ziffern kannst du hier nichts ausrechnen, du musst den Wert in der Tabelle nachschlagen. Am schnellsten gibst du den Code in den SMD-Code-Rechner ein; er versteht 3- und 4-stellige Codes, die R-Schreibweise und EIA-96.

Unterstrich, Null-Ohm und andere Sonderfälle

• Unterstrich: Manche Hersteller setzen bei Widerständen mit 1 % Toleranz, aber einem E24-Wert einen Strich unter den dreistelligen Code. Der Strich ändert den Wert nicht; er kennzeichnet das Bauteil als Präzisionswiderstand und zeigt die Leserichtung.
• 0, 00 oder 000: Das ist ein Null-Ohm-Widerstand als Brücke (Jumper). Er verbindet zwei Leiterbahnen auf der Platine oder schaltet eine Option ein oder aus; in 0603 und 0805 verträgt er typischerweise 1–2 A.
• Unbeschriftete Widerstände: Bauteile in 0402, 0201 und kleiner haben gar keinen Code. Den Wert erfährst du nur durch Messen oder vom Etikett der Gurtrolle.
• Widerstandsnetzwerke: Auf Arrays mit vier Widerständen nebeneinander in einem Gehäuse steht ein einziger Code; ein Array mit 103 enthält vier 10-kΩ-Widerstände. Du findest sie oft auf Boards wie dem Arduino Uno.
• Zylindrische (MELF-)Widerstände: Diese SMD-Widerstände haben die Form eines kleinen Zylinders und tragen Farbringe wie bedrahtete Widerstände. Die Farben entschlüsselst du mit dem Farbcode-Rechner.
• SMD-Spulen: Spulen nutzen ähnliche Codes, aber in Mikrohenry: 101 = 100 µH, 4R7 = 4,7 µH. Lesen kannst du sie mit dem Spulencode-Rechner.

SMD-Bauformen: Was bedeuten 0603, 0805 und 1206?

Der Bauformcode gibt die Abmessungen des Bauteils an, nicht seinen Wert. Im verbreiteten Zollsystem stehen die ersten zwei Ziffern für die Länge und die letzten zwei für die Breite in Hundertstel Zoll: 0805 ist 0,08 × 0,05 Zoll, also etwa 2,0 × 1,25 mm. Im metrischen System heißt dasselbe Bauteil 2012, angegeben in Zehntelmillimetern. Je größer das Gehäuse, desto mehr Leistung und Spannung verträgt der Widerstand. Am einfachsten von Hand zu löten sind 1206 und 0805; 0603 geht mit Pinzette und feiner Lötspitze gut, 0402 und kleiner brauchen Lupe und Geduld. Die Werte unten sind typisch; die genauen Grenzen unterscheiden sich je nach Hersteller etwas.

Die Leistungsangaben gelten meist für 70 °C Umgebungstemperatur und sinken, wenn es wärmer wird; mit etwa der halben Grenzleistung zu arbeiten ist daher eine gute Gewohnheit. Die Verlustleistung berechnest du mit P = U × I oder P = I² × R. Beispiel: Um eine rote LED an 5 V mit 20 mA zu betreiben, brauchst du (5 − 2) / 0,02 = 150 Ω; im Widerstand fallen 3 V × 0,02 A = 0,06 W an. Ein 0603 (0,1 W) schafft das, ein 0805 hat aber mehr Reserve. Betreibst du dieselbe LED an 12 V, brauchst du 510 Ω und die Leistung steigt auf 10 V × 0,02 A = 0,2 W; ein 1206 wäre dann am Limit, nimm also 1210 oder größer. Die Grundlagen dazu findest du in Ohmsches Gesetz einfach erklärt.

SMD-Kondensator-Code: 104 = 100 nF

Kondensatorcodes werden genauso gelesen wie Widerstandscodes, nur ist die Einheit Pikofarad (pF): Die ersten zwei Ziffern sind der Wert, die dritte die Anzahl der Nullen. 104 = 10 und vier Nullen = 100.000 pF = 100 nF = 0,1 µF. 103 = 10 nF, 102 = 1 nF, 105 = 1 µF, 106 = 10 µF. Beim Umrechnen hilft: 1 µF = 1.000 nF = 1.000.000 pF. Steht an dritter Stelle eine 8 oder 9, ist das keine Nullenanzahl, sondern ein Multiplikator: 9 = × 0,1 und 8 = × 0,01; also 229 = 2,2 pF und 479 = 4,7 pF. Ein Buchstabe hinter dem Wert gibt die Toleranz an: J = ±5 %, K = ±10 %, M = ±20 %. Steht der Buchstabe in der Mitte, zeigt er Einheit und Komma zugleich: 4n7 = 4,7 nF, p47 = 0,47 pF, 2u2 = 2,2 µF. Zum schnellen Umrechnen nimm den Kondensatorcode-Rechner.

Ganz wichtig: Die meisten keramischen SMD-Kondensatoren (MLCC) sind überhaupt nicht beschriftet. Den Wert dieser kleinen braunen, beigen oder grauen Quader erfährst du nur vom Etikett der Gurtrolle oder mit einem Multimeter, das Kapazität messen kann. Auch die 106 und 104 auf dem AMS1117-Board oben stehen auf der Platine, nicht auf den Kondensatoren. Bei älteren Bauteilen oder manchen Herstellern findest du einen zweistelligen Code aus Buchstabe und Ziffer: Der Buchstabe steht für den E24-Wert (A = 1,0; E = 1,5; J = 2,2; N = 3,3; S = 4,7; W = 6,8), die Ziffer für die Anzahl der Nullen in pF; S3 = 4,7 × 1.000 pF = 4,7 nF. X7R, X5R und C0G (NP0) auf dem Rollenetikett bezeichnen das Dielektrikum: C0G ändert sich mit der Temperatur kaum, X7R und X5R können dagegen mit steigender Gleichspannung einen großen Teil ihrer Kapazität verlieren.

Tantalkondensatoren haben meist ein gelbes, oranges oder schwarzes rechteckiges Gehäuse. Darauf stehen ein pF-Code (106 = 10 µF, 476 = 47 µF, 107 = 100 µF) und oft ein Spannungsbuchstabe: J = 6,3 V, A = 10 V, C = 16 V, D = 20 V, E = 25 V, V = 35 V. Manche Hersteller drucken die Spannung direkt auf. SMD-Aluminium-Elkos sind kleine Metallbecher; der Wert steht direkt in µF darauf, und der schwarze Halbmond oben markiert den Minuspol (−). Aufdrucke wie 2A104J auf Folien- und größeren Keramikkondensatoren bestehen aus drei Teilen: 2A = 100 V, 104 = 100 nF, J = ±5 %. Weitere häufige Spannungscodes sind 1C = 16 V, 1E = 25 V, 1H = 50 V und 2J = 630 V. Mehr über Kondensatorarten liest du in Was ist ein Kondensator?.

SMD-Transistor- und Dioden-Codes (1AM, J3Y, A7, M7)

Auf kleine Gehäuse wie SOT-23 passt die vollständige Typbezeichnung nicht, deshalb tragen Transistoren und Dioden einen 2–3-stelligen Markierungscode (Marking Code). Diese Codes folgen keinem einheitlichen Standard: Derselbe Code kann bei zwei Herstellern völlig verschiedene Bauteile bedeuten, und ein kleiner Buchstabe am Ende ist meist ein Werks- oder Datumscode. Nutze zur Bestimmung drei Hinweise zusammen: Gehäusetyp, Markierungscode und die Aufgabe des Bauteils in der Schaltung. Bei bipolaren Transistoren im SOT-23 ist die Pinfolge meist 1 = Basis, 2 = Emitter, 3 = Kollektor; bei MOSFETs wie dem 2N7002 ist sie 1 = Gate, 2 = Source, 3 = Drain. Pinbelegungen und Vergleichstypen findest du im Transistoren-Werkzeug, die Funktionsweise in Transistor einfach erklärt.

Unbeschrifteten Widerstand messen: Ohmmeter mit dem Arduino

Ist der Code abgerieben, hat das Bauteil die Bauform 0402 oder bist du dir beim Ergebnis unsicher, ist Messen der zuverlässigste Weg. Beim Messen mit dem Multimeter lötest du den Widerstand am besten aus oder hebst wenigstens ein Ende an; parallele Strompfade in der Schaltung lassen den Messwert niedriger erscheinen. Ohne Multimeter kannst du mit dem Arduino ein einfaches Ohmmeter bauen. Die Schaltung ist ein Spannungsteiler: Du schaltest einen Referenzwiderstand mit bekanntem Wert (Rref) in Reihe mit dem zu messenden Widerstand (Rx) und liest die Spannung am Mittelpunkt über einen Analogpin ein. Da der Analogwert des Arduino im Verhältnis zur Versorgungsspannung steht, ist die Formel sehr einfach: Rx = Rref × Messwert / (1024 − Messwert). Am genauesten wird es, wenn Rx nahe an Rref liegt: Mit 10 kΩ als Referenz misst du Widerstände von 1 kΩ bis 100 kΩ auf etwa ±2 % genau. Für Werte um 100 Ω nimm 1 kΩ, für Megaohm 1 MΩ als Referenz und passe die Konstante RREF an; den tatsächlichen Wert der Referenz einmal mit dem Multimeter zu messen und in den Code zu schreiben, verbessert die Genauigkeit deutlich.

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}

Den Arduino rechnen lassen: SMD-Code-Decoder im Seriellen Monitor

Das folgende Programm setzt alle Widerstandsregeln aus diesem Artikel um: Es versteht 3- und 4-stellige Codes, die R-Schreibweise, EIA-96 und 0-Ohm-Brücken. Öffne den Seriellen Monitor mit 9600 Baud und dem Zeilenende "Neue Zeile", tippe einen Code wie 4702 oder 68X ein und drück Enter. Weil der Buchstabe R sowohl Komma als auch EIA-96-Multiplikator sein kann, behandelt das Programm Codes mit R zuerst als Dezimalschreibweise (47R = 47 Ω); der SMD-Code-Rechner folgt derselben Regel. Die E96-Tabelle liegt per PROGMEM im Flash und belegt daher nichts von den 2 KB RAM des Uno. Der Code lässt sich ohne Änderungen auch für den ESP32 kompilieren. Wenn du den Seriellen Monitor zum ersten Mal nutzt, lies Arduino Serieller Monitor.

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}

Messen mit ESP32 und Raspberry Pi Pico

Für das Ohmmeter auf dem ESP32 änderst du den Messpin auf 34 und verbindest das obere Ende von Rref mit dem 3V3-Pin. GPIO 34 gehört zur ADC1-Gruppe, die auch bei aktivem WLAN funktioniert. Anders als beim Uno misst der ADC des ESP32 nicht im Verhältnis zur Versorgungsspannung und ist an den Bereichsenden nicht linear; wenn du in der Formel nur 1024 durch 4096 ersetzt, können die Fehler über 10 Prozent liegen. Nutze stattdessen analogReadMilliVolts(), das kalibrierte Millivolt liefert, und schreib die Formel als Rx = Rref × V / (3300 − V) mit V in Millivolt; trägst du statt 3300 die am 3V3-Pin mit dem Multimeter gemessene Spannung ein, wird das Ergebnis noch genauer. Da der ADC bei etwa 3,1 V in die Sättigung geht, senkst du die Leerlaufschwelle auf rund 3000 mV und hältst den gemessenen Widerstand nahe an der Referenz. Auf dem Raspberry Pi Pico entschlüsselt der folgende MicroPython-Code SMD-Codes und misst zugleich Widerstände an GP26. read_u16() liefert beim Pico Werte von 0 bis 65535, deshalb wird aus 1024 in der Formel hier 65535. Bist du neu beim Pico, starte mit Was ist der 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)

Typische Fehler und Lösungen

Ideen zum Üben mit SMD-Codes

• Board untersuchen: Lies die Codes der Widerstände auf deinem Arduino Nano oder ESP32-Board; finde die 102- oder 103-Codes neben den LEDs und ermittle, welcher Widerstand welche LED versorgt.
• Ohmmeter mit Display: Kombiniere das Ohmmeter oben mit einem I2C-LCD-Display zu einem tragbaren Widerstandsmessgerät.
• Kapazitätsmesser: Bestimme den Wert unbeschrifteter Keramikkondensatoren, indem du sie über einen Widerstand lädst und die RC-Zeitkonstante misst; die Methode steht in Was ist ein Kondensator?.
• Eigene Platine: Entwirf deine erste Platine mit Widerständen und Kondensatoren in 0805; die Schritte findest du in Platinenentwurf mit EasyEDA.
• Batteriespannungsmesser: Baue aus zwei SMD-Widerständen einen Teiler und miss eine 9-V-Batterie mit dem Arduino; die Widerstände wählst du mit dem Spannungsteiler-Rechner.
• Ordnung in der Bauteilkiste: Bewahre ausgelötete SMD-Bauteile in Boxen auf, die mit ihren Codes beschriftet sind; miss unbeschriftete Teile und schreib den Wert aufs Etikett.

SMD-Codes zu lesen wirkt anfangs wie das Knacken einer Geheimschrift, doch sobald du die paar Regeln kennst, verrät dir jeder Widerstand und Kondensator auf einer Platine, welche Aufgabe er hat. Wenn du die Farbringe bedrahteter Widerstände wiederholen willst, schau in Was ist ein Widerstand?. In der BlueGrays-App findest du Projekte, in denen Widerstände eine Schlüsselrolle spielen, von der ersten LED und Lichtmessung mit dem LDR bis zur Temperaturmessung mit NTC und zum digitalen Voltmeter, jeweils mit Schritt-für-Schritt-Schaltplänen und Code.