Code résistance CMS : lire 103, 4702, 01C et 4R7 facilement

Le code d'une résistance CMS (SMD en anglais) est le court marquage de trois ou quatre caractères imprimé sur les résistances montées en surface à la place des anneaux de couleur ; il donne la valeur en ohms. Une fois la règle apprise, il se lit très facilement : 103 = 10 kΩ, 4702 = 47 kΩ, 4R7 = 4,7 Ω et 01C = 10 kΩ. Dans un code à trois chiffres, les deux premiers forment la valeur et le dernier indique le nombre de zéros à ajouter ; dans un code à quatre chiffres, ce sont les trois premiers qui forment la valeur. La lettre R remplace la virgule, et les codes composés de deux chiffres et d'une lettre se lisent dans la table EIA-96.

Les Arduino Nano, les cartes de développement ESP32, les modules capteurs et les cartes régulatrices sont presque entièrement couverts de ces minuscules composants. Pour réparer un module, savoir quelle résistance alimente la LED de ta carte, trouver la valeur d'une résistance de pull-up ou dessiner ton propre circuit imprimé, tu dois savoir lire ces codes. En plus des résistances, ce guide t'explique les codes des condensateurs CMS (104 = 100 nF), les tailles comme 0603, 0805 et 1206, les courts marquages des transistors et diodes CMS, et comment mesurer avec Arduino un composant qui ne porte aucune inscription.

Qu'est-ce qu'une résistance CMS, et pourquoi pas de code couleur ?

CMS (composant monté en surface, SMD en anglais) désigne un composant dont les broches ne traversent pas la carte : il est soudé directement sur des pastilles à la surface du circuit imprimé. Une résistance CMS est un petit bloc de céramique aux extrémités métallisées ; la couche noire du dessus protège la couche résistive et porte le code. Une résistance 0805 ne mesure que 2 × 1,25 mm, il n'est donc pas pratique d'y peindre quatre anneaux de couleur : la valeur est imprimée sous forme de code en chiffres blancs. Sur les boîtiers 0402 et plus petits, même ce code ne tient pas, et ces composants n'ont aucun marquage. N'oublie pas que le code n'indique que la résistance : les limites de puissance et de tension dépendent de la taille du boîtier, et la tolérance se devine généralement au type de code.

Comment lire un code CMS à 3 chiffres

Le format le plus courant est le code à trois chiffres. Les deux premiers chiffres forment la partie significative de la valeur, et le troisième indique combien de zéros ajouter derrière, autrement dit la puissance de dix. Avec 103, on ajoute trois zéros à 10 : 10 000 Ω = 10 kΩ. De même, 472 = 47 et deux zéros = 4 700 Ω = 4,7 kΩ ; 221 = 220 Ω ; 334 = 330 kΩ et 105 = 1 000 000 Ω = 1 MΩ. Ces codes sont surtout utilisés sur les résistances à ±5 %, et les valeurs viennent de la 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 et 91, ainsi que leurs multiples de dix. Si la valeur lue ne figure pas dans cette liste, soit tu lis le code à l'envers, soit le composant n'est pas une résistance.

Code à 4 chiffres et lettre R : 4702, 1002, 4R7

Le code à quatre chiffres est utilisé sur les résistances de précision à ±1 %. La logique est la même, mais la partie significative compte trois chiffres : les trois premiers forment la valeur et le quatrième le nombre de zéros. 1002 = 100 et deux zéros = 10 000 Ω = 10 kΩ ; 4702 = 47 kΩ ; 1001 = 1 kΩ ; 1000 = 100 Ω ; 2201 = 2,2 kΩ ; 1004 = 1 MΩ. Trois chiffres significatifs permettent aussi d'écrire des valeurs intermédiaires de la série E96, comme 49,9 kΩ (4992) ou 4,99 kΩ (4991). En bref, la même résistance de 10 kΩ peut se présenter sous la forme 103, 1002 ou 01C selon le fabricant et la précision : les trois ont la même valeur.

Les valeurs inférieures à 10 Ω ne peuvent pas s'écrire avec un nombre de zéros, c'est pourquoi la lettre R prend la place de la virgule. 4R7 = 4,7 Ω, 2R2 = 2,2 Ω, 1R0 = 1 Ω et R47 = 0,47 Ω. La version à quatre caractères suit la même règle : 10R0 = 10 Ω, 4R70 = 4,7 Ω. Les très petites valeurs sont généralement des résistances de shunt servant à mesurer un courant : R100 = 0,1 Ω (tu la verras sur les modules de mesure de courant comme l'INA219) et R010 = 0,01 Ω, soit 10 mΩ. Les schémas et les nomenclatures utilisent la même idée avec les lettres k et M : 4k7 = 4,7 kΩ, 2M2 = 2,2 MΩ. On préfère cette notation car une virgule perdue à l'impression pourrait transformer 4,7 kΩ en 47 kΩ.

Comment lire un code EIA-96 (01C, 68X, 85B)

Quatre chiffres ne tiennent pas sur une résistance à 1 % en boîtier 0603. On utilise alors un système à trois caractères appelé EIA-96 : les deux premiers chiffres (01 à 96) sont le numéro d'ordre de la valeur dans la série E96, et la lettre finale est le multiplicateur. La valeur n° 01 est 100, la n° 68 est 499 et la n° 85 est 750. Ainsi, 01C = 100 × 100 = 10 kΩ, 68X = 499 × 0,1 = 49,9 Ω et 85B = 750 × 10 = 7,5 kΩ. Impossible ici de calculer à partir des chiffres : il faut chercher la valeur dans la table. Le plus rapide est de saisir le code dans l'outil Code CMS, qui comprend les codes à 3 et 4 chiffres, la notation avec R et l'EIA-96.

Soulignement, zéro ohm et autres cas particuliers

• Soulignement : Certains fabricants soulignent le code à trois chiffres des résistances à 1 % dont la valeur appartient à la série E24. Le trait ne change pas la valeur ; il signale une résistance de précision et indique le sens de lecture.
• 0, 00 ou 000 : C'est une résistance de zéro ohm servant de strap (pont). On l'utilise pour relier deux pistes du circuit imprimé ou pour activer ou désactiver une option ; en 0603 et 0805, elle supporte généralement 1 à 2 A.
• Résistances sans marquage : Les composants en 0402, 0201 et plus petits n'ont aucun code. On ne connaît leur valeur qu'en les mesurant ou grâce à l'étiquette du rouleau.
• Réseaux de résistances : Les réseaux qui réunissent quatre résistances côte à côte dans un même boîtier portent un seul code ; un réseau marqué 103 contient quatre résistances de 10 kΩ. On en trouve souvent sur des cartes comme l'Arduino Uno.
• Résistances cylindriques (MELF) : Ces résistances CMS ont la forme d'un petit cylindre et portent des anneaux de couleur comme les résistances traversantes. Tu peux décoder les couleurs avec l'outil Code couleur.
• Inductances CMS : Les inductances utilisent des codes semblables, mais en microhenrys : 101 = 100 µH, 4R7 = 4,7 µH. Tu peux les lire avec l'outil Code d'inductance.

Tailles CMS : que signifient 0603, 0805 et 1206 ?

Le code de taille indique les dimensions physiques du composant, pas sa valeur. Dans le système impérial, le plus répandu, les deux premiers chiffres donnent la longueur et les deux derniers la largeur en centièmes de pouce : 0805 correspond à 0,08 × 0,05 pouce, soit environ 2,0 × 1,25 mm. Dans le système métrique, la même pièce s'écrit 2012, en dixièmes de millimètre. Plus le boîtier est grand, plus la résistance supporte de puissance et de tension. Les tailles les plus faciles à souder à la main sont 1206 et 0805 ; le 0603 se soude bien avec des brucelles et une panne fine, tandis que le 0402 et plus petit demandent une loupe et de la patience. Les valeurs ci-dessous sont typiques ; les limites exactes varient un peu d'un fabricant à l'autre.

Les puissances sont en général données pour une température ambiante de 70 °C et diminuent quand il fait plus chaud ; travailler autour de la moitié de la limite est donc une bonne habitude. Calcule la puissance dissipée par une résistance avec P = U × I ou P = R × I². Exemple : pour alimenter une LED rouge à 20 mA sous 5 V, il faut (5 − 2) / 0,02 = 150 Ω, et la résistance dissipe 3 V × 0,02 A = 0,06 W. Une 0603 (0,1 W) le supporte, mais une 0805 a plus de marge. Si tu alimentes la même LED en 12 V, il faut 510 Ω et la puissance monte à 10 V × 0,02 A = 0,2 W ; une 1206 serait à la limite, choisis donc une 1210 ou un boîtier plus grand. Pour revoir ces calculs, consulte Loi d'Ohm expliquée.

Code des condensateurs CMS : 104 = 100 nF

Les codes de condensateurs suivent la même logique que ceux des résistances, mais l'unité est le picofarad (pF) : les deux premiers chiffres forment la valeur et le troisième le nombre de zéros. 104 = 10 et quatre zéros = 100 000 pF = 100 nF = 0,1 µF. 103 = 10 nF, 102 = 1 nF, 105 = 1 µF, 106 = 10 µF. Pour convertir les unités, retiens que 1 µF = 1 000 nF = 1 000 000 pF. Si tu vois un 8 ou un 9 en troisième position, ce n'est pas un nombre de zéros mais un multiplicateur : 9 = × 0,1 et 8 = × 0,01 ; ainsi 229 = 2,2 pF et 479 = 4,7 pF. Une lettre après la valeur indique la tolérance : J = ±5 %, K = ±10 %, M = ±20 %. Quand la lettre est au milieu, elle indique à la fois l'unité et la virgule : 4n7 = 4,7 nF, p47 = 0,47 pF, 2u2 = 2,2 µF. Pour convertir rapidement un code, utilise l'outil Code de condensateur.

Point important : la plupart des condensateurs céramiques CMS (MLCC) ne portent aucun marquage. La valeur de ces petits blocs marron, beiges ou gris ne se connaît que par l'étiquette du rouleau ou avec un multimètre capable de mesurer les capacités. Les inscriptions 106 et 104 vues sur la carte AMS1117 plus haut sont imprimées sur la carte, pas sur les condensateurs. Sur des composants anciens ou chez certains fabricants, tu peux trouver un code de deux caractères formé d'une lettre et d'un chiffre : la lettre donne la valeur de la série E24 (A = 1,0 ; E = 1,5 ; J = 2,2 ; N = 3,3 ; S = 4,7 ; W = 6,8) et le chiffre le nombre de zéros en pF ; S3 = 4,7 × 1 000 pF = 4,7 nF. Les mentions X7R, X5R et C0G (NP0) sur l'étiquette du rouleau désignent le diélectrique : le C0G varie à peine avec la température, alors que les X7R et X5R peuvent perdre une grande partie de leur capacité quand la tension continue appliquée augmente.

Les condensateurs au tantale ont généralement un boîtier rectangulaire jaune, orange ou noir. Ils portent un code en pF (106 = 10 µF, 476 = 47 µF, 107 = 100 µF) et souvent une lettre de tension : J = 6,3 V, A = 10 V, C = 16 V, D = 20 V, E = 25 V, V = 35 V. Certains fabricants impriment directement la tension. Les électrolytiques aluminium CMS sont de petits boîtiers métalliques cylindriques ; la valeur est imprimée en µF et le demi-cercle noir sur le dessus indique la borne négative (−). Les marquages comme 2A104J sur les condensateurs film et les gros céramiques se décomposent en trois parties : 2A = 100 V, 104 = 100 nF, J = ±5 %. Autres codes de tension courants : 1C = 16 V, 1E = 25 V, 1H = 50 V et 2J = 630 V. Tu trouveras plus de détails sur les types de condensateurs dans Qu'est-ce qu'un condensateur ?.

Codes des transistors et diodes CMS (1AM, J3Y, A7, M7)

Le nom complet ne tient pas sur les petits boîtiers comme le SOT-23 : les transistors et les diodes portent donc un code de marquage (marking code) de 2 ou 3 caractères. Ces codes ne suivent pas une norme unique : le même code peut désigner des composants totalement différents chez deux fabricants, et une petite lettre à la fin est souvent un code d'usine ou de date. Pour identifier un composant, combine trois indices : le type de boîtier, le code de marquage et le rôle du composant dans le circuit. Pour les transistors bipolaires en SOT-23, l'ordre des broches est généralement 1 = base, 2 = émetteur, 3 = collecteur ; pour les MOSFET comme le 2N7002, c'est 1 = grille (gate), 2 = source, 3 = drain. Pour les brochages et les équivalents, consulte l'outil Transistors, et pour leur fonctionnement, lis Transistor : fonctionnement, NPN, PNP.

Mesurer une résistance sans marquage ou illisible : un ohmmètre avec Arduino

Si le code est effacé, si le composant est un 0402 ou si tu doutes du résultat, le plus fiable est de mesurer. Avec un multimètre, dessoude la résistance si possible, ou au moins soulève une extrémité ; les chemins en parallèle dans le circuit donnent une lecture plus faible que la valeur réelle. Si tu n'as pas de multimètre, tu peux fabriquer un ohmmètre simple avec Arduino. Le montage est un pont diviseur de tension : tu mets en série une résistance de référence de valeur connue (Rref) et la résistance à mesurer (Rx), puis tu lis la tension au point milieu sur une entrée analogique. Comme la lecture analogique de l'Arduino est proportionnelle à sa tension d'alimentation, la formule est très simple : Rx = Rref × lecture / (1024 − lecture). Le résultat est le plus précis quand Rx est proche de Rref : avec une référence de 10 kΩ, tu mesures les résistances de 1 kΩ à 100 kΩ à environ ±2 % près. Pour des valeurs autour de 100 Ω, prends une référence de 1 kΩ, et pour les mégohms, une de 1 MΩ, puis mets à jour la constante RREF ; mesurer une fois la valeur réelle de la référence au multimètre et l'écrire dans le code améliore nettement la précision.

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}

Laisser l'Arduino décoder : un décodeur de codes CMS dans le moniteur série

Le programme ci-dessous applique toutes les règles de cet article pour les résistances : il comprend les codes à 3 et 4 chiffres, la notation avec R, l'EIA-96 et les straps de 0 ohm. Ouvre le moniteur série à 9600 bauds avec la fin de ligne « Nouvelle ligne », tape un code comme 4702 ou 68X et appuie sur Entrée. Comme la lettre R peut être à la fois une virgule et un multiplicateur EIA-96, le programme interprète d'abord les codes contenant un R comme une notation décimale (47R = 47 Ω) ; l'outil Code CMS suit la même règle. La table E96 est stockée en mémoire flash avec PROGMEM, elle n'occupe donc pas les 2 Ko de RAM de l'Uno. Le code se compile et fonctionne aussi sur ESP32 sans aucune modification. Si tu utilises le moniteur série pour la première fois, jette un œil à Moniteur série 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}

Mesurer avec l'ESP32 et le Raspberry Pi Pico

Pour utiliser l'ohmmètre sur un ESP32, passe la broche de mesure sur 34 et relie l'extrémité haute de Rref à la broche 3V3. Le GPIO 34 fait partie du groupe ADC1, qui fonctionne même quand le Wi-Fi est actif. Contrairement à celui de l'Uno, l'ADC de l'ESP32 ne mesure pas en proportion de sa tension d'alimentation et n'est pas linéaire près des extrémités de sa plage : remplacer simplement 1024 par 4096 dans la formule peut donner des erreurs de plus de 10 pour cent. Utilise plutôt analogReadMilliVolts(), qui renvoie des millivolts calibrés, et écris la formule Rx = Rref × V / (3300 − V), avec V en millivolts ; si tu remplaces 3300 par la tension mesurée au multimètre sur la broche 3V3, le résultat est encore meilleur. Comme l'ADC sature vers 3,1 V, abaisse le seuil de circuit ouvert à environ 3000 mV et garde la résistance mesurée proche de la référence. Sur le Raspberry Pi Pico, le code MicroPython ci-dessous décode les codes CMS et mesure aussi une résistance sur GP26. La fonction read_u16() du Pico renvoie une valeur de 0 à 65535, donc le 1024 de la formule devient ici 65535. Si tu débutes avec le Pico, commence par Qu'est-ce que le 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)

Erreurs fréquentes et solutions

Idées pour s'entraîner avec les codes CMS

• Inspecte ta carte : Lis les codes des résistances de ton Arduino Nano ou de ta carte ESP32 ; repère les codes 102 ou 103 à côté des LED et déduis quelle résistance alimente quelle LED.
• Ohmmètre avec écran : Associe l'ohmmètre ci-dessus à un écran LCD I2C pour fabriquer un mesureur de résistance portable.
• Capacimètre : Trouve la valeur de condensateurs céramiques sans marquage en les chargeant à travers une résistance et en mesurant la constante de temps RC ; la méthode est dans Qu'est-ce qu'un condensateur ?.
• Ton propre circuit imprimé : Dessine ton premier PCB avec des résistances et des condensateurs 0805 ; les étapes sont dans Concevoir un PCB avec EasyEDA.
• Mesure de tension de pile : Monte un diviseur avec deux résistances CMS et mesure une pile de 9 V avec Arduino ; choisis les résistances avec l'outil Pont diviseur.
• Boîte à composants rangée : Range les composants CMS dessoudés dans des boîtes étiquetées avec leurs codes ; mesure ceux qui n'ont pas de marquage et note leur valeur sur l'étiquette.

Lire les codes CMS ressemble au début à déchiffrer un message codé, mais dès que tu connais quelques règles, chaque résistance et chaque condensateur d'une carte te dit à quoi il sert. Si tu veux revoir le fonctionnement des résistances à anneaux de couleur, consulte Qu'est-ce qu'une résistance ?. Dans l'application BlueGrays, tu trouveras des projets où les résistances jouent un rôle clé, de l'allumage d'une LED et la mesure de lumière avec une LDR jusqu'à la mesure de température avec une CTN et au voltmètre numérique, chacun avec schémas de câblage et code pas à pas.