Bases · 13 min de lecture

Convertir nF en µF : tableau, code condensateur et unités

Convertir nF en µF facilement : tableau pF-nF-µF, code condensateur 104 et 2n2, kΩ, mA, mV, mAh en Wh et erreurs d'unités fréquentes dans le code Arduino.

Pour convertir nF en µF, une seule règle suffit : 1 µF = 1000 nF et 1 nF = 1000 pF. Pour passer des nF aux µF, tu divises par 1000 ; pour passer des µF aux nF, tu multiplies par 1000 : 100 nF = 0,1 µF, 4,7 µF = 4700 nF. Le 104 imprimé sur un condensateur céramique désigne exactement ces 100 nF, soit 0,1 µF. Presque toutes les conversions d'unités en électronique se font par paliers de mille ; une fois les préfixes assimilés, les calculs de résistances, de courant, de tension et de batteries deviennent bien plus simples.

Dans ce guide, nous avons réuni les préfixes p, n, µ, m, k et M dans un seul tableau. Tu apprendras à lire les codes des condensateurs (104, 2n2, 474J), les notations 4K7 et R47 des résistances, à passer des mA aux A et des mV aux V, à convertir la capacité d'une batterie de mAh en Wh, et les raccourcis d'unités qui permettent d'appliquer la loi d'Ohm de tête. Pour finir, nous verrons les erreurs d'unités les plus courantes dans le code Arduino, ESP32 et Raspberry Pi Pico, et comment les écrire correctement.

Condensateurs électrolytiques marqués 470 µF 16 V et 220 µF 16 V
Sur les condensateurs électrolytiques, la valeur est écrite en clair (470 µF, 16 V) ; les petits condensateurs céramiques utilisent plutôt des codes comme 104.

Préfixes SI : que signifient p, n, µ, m, k et M ?

En électronique, les valeurs couvrent une plage énorme : un microcontrôleur en veille consomme quelques microampères, un moteur plusieurs ampères ; le condensateur à côté d'un quartz peut faire 22 picofarads et celui en sortie d'une alimentation 2200 microfarads. C'est pourquoi, au lieu d'aligner des zéros, on utilise un préfixe. Chaque préfixe multiplie l'unité de base par une puissance de 10, et ceux de l'électronique sont tous espacés d'un facteur 1000. Les règles sont les mêmes pour les volts, ampères, ohms, farads, henrys, watts et hertz.

PréfixeSymboleFacteurExemple en électronique
picop10⁻¹² (0,000 000 000 001)Condensateur de 22 pF près du quartz
nanon10⁻⁹ (0,000 000 001)Condensateur de découplage de 100 nF, période d'horloge de 62,5 ns
microµ (u)10⁻⁶ (0,000 001)Condensateur de 10 µF, courant de veille de 10 µA
millim10⁻³ (0,001)LED à 20 mA, pas de l'ADC de 4,88 mV
(unité de base)-15 V, 1 A, 1 Ω, 1 F
kilok10³ (1000)Résistance de pull-up de 10 kΩ, porteuse IR de 38 kHz
mégaM10⁶ (1 000 000)Impédance d'entrée de 1 MΩ, horloge de 16 MHz
gigaG10⁹Wi-Fi et Bluetooth à 2,4 GHz
Monter ou descendre d'un préfixe revient à décaler la virgule de trois rangs. En passant d'une petite unité à une plus grande, le nombre diminue (2200 pF = 2,2 nF) ; en passant d'une grande à une plus petite, il augmente (0,1 µF = 100 nF). Si ton clavier n'a pas de µ, on écrit u à la place : 10uF, c'est la même chose que 10 µF.

Tableau de conversion pF, nF et µF

Ce qui déroute le plus avec les condensateurs, c'est qu'une même valeur peut s'écrire dans trois unités. Le schéma indique 0,1 µF, la boutique en ligne 100 nF, le composant 104, et c'est pourtant la même pièce. Pour convertir des nF en µF, divise par 1000 ; pour passer des pF aux nF, divise encore par 1000. Dans l'autre sens, multiplie par 1000. Le tableau rassemble les valeurs les plus courantes avec les codes que tu trouveras imprimés dessus ; il mérite d'être imprimé et affiché au-dessus de ton plan de travail.

pFnFµFCode
10 pF0,01 nF0,00001 µF100
22 pF0,022 nF0,000022 µF220
100 pF0,1 nF0,0001 µF101
1000 pF1 nF0,001 µF102
2200 pF2,2 nF (2n2)0,0022 µF222
4700 pF4,7 nF (4n7)0,0047 µF472
10 000 pF10 nF0,01 µF103
47 000 pF47 nF0,047 µF473
100 000 pF100 nF0,1 µF104
220 000 pF220 nF0,22 µF224
470 000 pF470 nF0,47 µF474
1 000 000 pF1000 nF1 µF105
10 000 000 pF10 000 nF10 µF106

Lire le code d'un condensateur : combien de nF pour 104 ?

Sur les petits condensateurs céramiques et à film, la valeur complète ne tient pas : on y imprime un code à trois chiffres dont l'unité est toujours le picofarad. Les deux premiers chiffres donnent la valeur, le troisième le nombre de zéros à ajouter. Pour 104, tu ajoutes quatre zéros derrière 10 : 100 000 pF, soit 100 nF ou 0,1 µF. Si tu ne veux pas calculer de tête, le calculateur de code de condensateur le fait en une seconde ; le fonctionnement des condensateurs est expliqué dans Qu'est-ce qu'un condensateur ?.

  1. Note les deux premiers chiffres : 47 pour 474.
  2. Ajoute autant de zéros que l'indique le troisième chiffre : 47 suivi de 4 zéros donne 470 000 pF.
  3. Divise par 1000 pour obtenir des nF : 470 000 pF = 470 nF.
  4. Divise encore par 1000 pour obtenir des µF : 470 nF = 0,47 µF.
  5. Regarde la lettre après le code : J signifie ±5 %, K ±10 % et M ±20 % de tolérance. Un 474J est donc un condensateur de 0,47 µF à ±5 %.
  6. Si le code est précédé de 2A ou 1H, c'est la tension de service : 1H = 50 V, 2A = 100 V, 2J = 630 V.
MarquageSignificationValeur
2n2Le n remplace la virgule2,2 nF = 2200 pF
4n7Le n remplace la virgule4,7 nF = 4700 pF
µ1 ou u1Le µ remplace la virgule0,1 µF = 100 nF
4µ7Le µ remplace la virgule4,7 µF
p68Le p remplace la virgule0,68 pF
109Troisième chiffre 9 = ×0,11,0 pF
104ZZ = tolérance +80 % / -20 %100 nF
35 MFDAncienne notation : MFD = microfarad35 µF
Sur les condensateurs anciens ou de fabrication américaine, MFD et même mF désignent des microfarads : les « 35 MFD » d'un condensateur de ventilateur de plafond ou de climatiseur font 35 µF, pas 35 millifarads. De même, MMFD sur les vieux schémas signifie picofarads. Quand tu achètes une pièce de rechange, interprète l'unité selon le contexte ; un condensateur de cette taille ne peut de toute façon pas faire des millifarads.

Unités des résistances : Ω, kΩ, MΩ et la notation 4K7

L'unité de base des résistances est l'ohm (Ω), mais la plupart des valeurs que tu verras dans les montages Arduino sont de l'ordre du kiloohm : 220 Ω pour une LED, 10 kΩ en pull-up, 1 MΩ pour une entrée à haute impédance. Sur les schémas et les nomenclatures, une lettre remplace la virgule, car un petit point peut disparaître à l'impression alors qu'une lettre reste lisible. R signifie ohms, K kiloohms et M mégohms, et la position de la lettre marque la virgule. Pour décoder les anneaux de couleur, consulte notre guide du code couleur des résistances ou le calculateur de code couleur ; pour les codes comme 103 et 4701 sur les composants CMS, lis les codes des résistances CMS.

NotationValeurEn ohms
R470,47 Ω0,47 Ω
2R22,2 Ω2,2 Ω
220R220 Ω220 Ω
1K1 kΩ1000 Ω
4K74,7 kΩ4700 Ω
47K47 kΩ47 000 Ω
1M01 MΩ1 000 000 Ω
103 (CMS)10 et 3 zéros10 000 Ω = 10 kΩ
4701 (CMS, 4 chiffres)470 et 1 zéro4700 Ω = 4,7 kΩ

Le code à trois chiffres fonctionne de la même façon sur les résistances et les bobines, mais l'unité de base change : picofarads sur un condensateur, ohms sur une résistance CMS et microhenrys sur une bobine. Ainsi, 101 sur un condensateur vaut 100 pF, sur une résistance CMS 100 Ω et sur une bobine 100 µH. N'interprète jamais un code sans savoir sur quel composant il se trouve.

Courant et tension : convertir mA en A, µA et mV en V

Pour le courant, tu passeras surtout des mA aux A : 1 A = 1000 mA et 1 mA = 1000 µA. Une LED qui consomme 20 mA consomme 0,02 A ; les 10 µA d'un ESP32 en deep sleep valent 0,01 mA, soit 0,00001 A. La tension suit les mêmes paliers : 1 V = 1000 mV. L'ADC 10 bits de l'Arduino Uno découpe 5 V en 1024 parts, chaque pas vaut donc 5 / 1024 = 0,00488 V, soit 4,88 mV. Les fiches techniques des capteurs donnent des rapports comme des mV par degré (10 mV/°C pour le LM35) ou des mV par ampère (185 mV/A pour l'ACS712-5A) ; les utiliser dans la bonne unité détermine la précision de ta mesure. La lecture analogique est détaillée dans Qu'est-ce qu'un ADC ?.

SituationValeur typiqueEn unité de base
Courant par broche de l'Arduino Uno (recommandé / maximum absolu)20 mA / 40 mA0,02 A / 0,04 A
Courant de fonctionnement d'une LED rouge10-20 mA0,01-0,02 A
ESP32 pendant une émission Wi-Fijusqu'à 250 mA0,25 A
Courant de la puce ESP32 en deep sleepenviron 10 µA0,00001 A
Pas de l'ADC de l'Arduino Uno (5 V, 10 bits)4,88 mV0,00488 V
Pas de l'ADC de l'ESP32 et du Pico (3,3 V, 12 bits)environ 0,8 mV0,0008 V
Courant de blocage d'un servo SG90650-700 mAenviron 0,7 A

Raccourcis d'unités pour la loi d'Ohm : V, mA et kΩ

Inutile de tout convertir en unités de base avant de calculer. Si tu associes les préfixes de façon à ce qu'ils s'annulent, le résultat sort directement dans la bonne unité. L'association la plus pratique : des volts divisés par des kiloohms donnent des milliampères. Applique 5 V à une résistance de pull-up de 10 kΩ et il circule 5 / 10 = 0,5 mA, sans jongler avec les zéros. Selon la même logique, des milliampères multipliés par des kiloohms donnent des volts, et des volts multipliés par des milliampères donnent des milliwatts. Ça marche aussi pour la charge d'un condensateur : des kiloohms multipliés par des microfarads donnent des millisecondes. Pour revoir les bases, lis La loi d'Ohm, ou utilise le calculateur de loi d'Ohm pour un résultat rapide.

FormuleAssociation d'unitésExemple
I = U / RV / kΩ = mA5 V / 10 kΩ = 0,5 mA
R = U / IV / mA = kΩ(5 V - 2 V) / 20 mA = 0,15 kΩ = 150 Ω
U = I × RmA × kΩ = V2 mA × 4,7 kΩ = 9,4 V
P = U × IV × mA = mW5 V × 20 mA = 100 mW
τ = R × CkΩ × µF = ms10 kΩ × 100 µF = 1000 ms = 1 s
τ = R × CkΩ × nF = µs10 kΩ × 100 nF = 1000 µs = 1 ms
τ = R × CMΩ × µF = s1 MΩ × 10 µF = 10 s
La deuxième ligne du tableau est en fait un calcul de résistance pour LED : retire des 5 V la chute de 2 V de la LED, divise les 3 V restants par 20 mA et tu obtiens 0,15 kΩ. Si cette valeur n'existe pas dans la série normalisée, prends la suivante au-dessus (150 Ω ou 220 Ω). Pour expérimenter avec la constante de temps d'un circuit RC, essaie le calculateur de constante de temps RC.

mAh et Wh : convertir la capacité d'une batterie

Les mAh (milliampères-heures) indiquent quel courant une batterie peut fournir et pendant combien d'heures, tandis que les Wh (wattheures) indiquent l'énergie qu'elle contient réellement. Pour comparer des batteries de tensions différentes, il faut des Wh, car une pile AA de 2000 mAh et un accu lithium de 2000 mAh ne stockent pas la même énergie. La formule est simple : Wh = mAh × V / 1000. Un accu 18650 de 2600 mAh sous 3,7 V stocke 2600 × 3,7 / 1000 = 9,62 Wh. La limite de 100 Wh imposée par les compagnies aériennes pour les batteries externes en cabine correspond à environ 27 000 mAh sous 3,7 V.

Pour estimer l'autonomie, divise la capacité par le courant moyen : heures = mAh / mA. En pratique, on n'utilise pas toute la batterie et le régulateur perd de l'énergie, donc multiplier le résultat par 0,7-0,8 est plus réaliste. Un projet ESP32 qui consomme 80 mA en moyenne tient environ 2600 / 80 × 0,8 = 26 heures sur un accu de 2600 mAh. Les 10 000 mAh imprimés sur une batterie externe concernent ses cellules de 3,7 V ; une fois élevés à 5 V avec un rendement d'environ 85 %, il reste à peu près 10 000 × 3,7 × 0,85 / 5 ≈ 6300 mAh utilisables. Pour le calcul détaillé, lis Que signifie mAh ? ou essaie le calculateur d'autonomie de batterie.

Pile / accuCapacitéTensionÉnergie
Pile bouton CR2032220 mAh3 V0,66 Wh
Pile AA alcalineenviron 2500 mAh1,5 Venviron 3,75 Wh
Pile 9 V alcalineenviron 500 mAh9 Venviron 4,5 Wh
LiPo de 1000 mAh1000 mAh3,7 V3,7 Wh
Accu 18650 Li-ion2600 mAh3,7 V9,62 Wh
Batterie externe de 10 000 mAh10 000 mAh3,7 V (cellule)37 Wh

Temps et fréquence : ms, µs, Hz, kHz et MHz

Fréquence et période sont inverses l'une de l'autre : T = 1 / f. Comme le hertz vaut « un par seconde », l'inverse des kHz donne des millisecondes et celui des MHz des microsecondes. Les servomoteurs sont pilotés à 50 Hz, une impulsion arrive donc toutes les 1 / 50 = 0,02 s = 20 ms. La plupart des broches PWM de l'Arduino Uno tournent à environ 490 Hz avec une période de 2,04 ms ; les broches 5 et 6 à 980 Hz avec 1,02 ms (plus de détails dans Qu'est-ce que le PWM ?). Avec une horloge de 16 MHz, un cycle dure 62,5 ns. Ne confonds pas non plus les deux fonctions de temps d'Arduino : millis() renvoie des millisecondes, micros() des microsecondes, et delayMicroseconds() n'est précise que jusqu'à 16 383 µs ; pour des attentes plus longues, utilise la temporisation avec millis.

Les unités de vitesse reposent sur les mêmes conversions. Pour le capteur à ultrasons HC-SR04, la vitesse du son est de 343 m/s ; convertie en cm/µs, cela donne 34 300 cm / 1 000 000 µs = 0,0343 cm/µs. Comme le capteur renvoie la durée aller-retour de l'écho, distance = durée (µs) × 0,0343 / 2 : un écho de 1000 µs correspond donc à 17,15 cm. Si tu sais d'où vient ce 0,0343, tu peux trouver toi-même le bon facteur pour obtenir le résultat en mètres ou en pouces.

Erreurs d'unités dans le code Arduino : convertir la lecture de l'ADC en mV et en V

Même quand la conversion est juste sur le papier, deux pièges t'attendent dans le code. Le premier est le dépassement de int : sur l'Arduino Uno, un int contient au maximum 32 767, mais 1023 × 5000 font 5 115 000 et le résultat devient absurde. Le second est la division entière : 4700 / 1000 donne 4 et non 4,7, car la division de deux entiers supprime la partie décimale. La solution : faire la multiplication en long et écrire 1000.0 au lieu de 1000 quand tu veux un résultat décimal. Le croquis ci-dessous convertit correctement la tension sur A0 en mV et en V, puis calcule la vraie tension d'entrée d'un pont diviseur de tension de 10 kΩ et 4,7 kΩ.

C++ (Arduino IDE)
1// ADC değerini mV ve V'a çevirme / Converting ADC readings to mV and V
2const int SENSOR_PIN = A0;
3const long VREF_MV = 5000;        // Uno referansı 5000 mV / Uno reference 5000 mV
4const float R1_KOHM = 10.0;       // üst direnç 10 kΩ / top resistor 10 kΩ
5const float R2_KOHM = 4.7;        // alt direnç 4,7 kΩ / bottom resistor 4.7 kΩ
6
7void setup() {
8  Serial.begin(9600);
9}
10
11void loop() {
12  int raw = analogRead(SENSOR_PIN);              // 0-1023
13
14  // YANLIŞ: int ile raw * 5000 taşar / WRONG: raw * 5000 overflows an int
15  // int wrongMv = raw * 5000 / 1024;
16
17  long mv = (long)raw * VREF_MV / 1024;          // doğru: long ile mV / correct: mV using long
18  float volts = mv / 1000.0;                     // mV -> V, 1000.0 ondalıklı böler / 1000.0 keeps decimals
19  float vin = volts * (R1_KOHM + R2_KOHM) / R2_KOHM;  // kΩ / kΩ birimsizdir / kΩ over kΩ is unitless
20
21  Serial.print("ham / raw: ");  Serial.print(raw);
22  Serial.print("  mV: ");       Serial.print(mv);
23  Serial.print("  V: ");        Serial.print(volts, 3);
24  Serial.print("  Vin: ");      Serial.println(vin, 2);
25  delay(500);
26}

Le transtypage (long)raw fait calculer la multiplication sur 32 bits, donc rien ne déborde. Nous divisons par 1024 car c'est la formule de la fiche technique de l'ATmega328P ; l'écart avec 1023 est d'environ 0,1 pour cent. Écrire les résistances du pont en kΩ ne pose aucun problème, puisque les unités s'annulent dans le rapport. Avec ce pont, A0 reçoit au plus 5 V alors que tu peux mesurer jusqu'à environ 15,6 V en entrée.

Décodeur de code de condensateur : tape 104 dans le moniteur série

Pour que le décodage devienne un réflexe, écrivons un petit outil. Le programme lit le code à trois chiffres que tu tapes dans le moniteur série et affiche sa valeur en pF, nF et µF. Il gère aussi les cas particuliers où le troisième chiffre vaut 8 ou 9 (×0,01 et ×0,1). Règle simplement la fin de ligne du moniteur série sur « Nouvelle ligne ».

C++ (Arduino IDE)
1// Kondansatör kodu çözücü / Capacitor code decoder
2// Seri Monitör'e 104, 222, 475 gibi bir kod yaz / Type a code such as 104, 222 or 475
3
4void printValue(float pf) {
5  Serial.print(pf, 1);              Serial.print(F(" pF = "));
6  Serial.print(pf / 1000.0, 3);     Serial.print(F(" nF = "));
7  Serial.print(pf / 1000000.0, 6);  Serial.println(F(" uF"));
8}
9
10void setup() {
11  Serial.begin(9600);
12  Serial.println(F("Kod yaz (or. 104) / Type a code (e.g. 104)"));
13}
14
15void loop() {
16  if (!Serial.available()) return;
17  String code = Serial.readStringUntil('\n');
18  code.trim();
19
20  if (code.length() != 3 || !isDigit(code[0]) || !isDigit(code[1]) || !isDigit(code[2])) {
21    Serial.println(F("3 haneli kod yaz / Enter a 3-digit code"));
22    return;
23  }
24
25  int digits = (code[0] - '0') * 10 + (code[1] - '0');  // ilk iki hane / first two digits
26  int mult = code[2] - '0';                             // üçüncü hane / third digit
27  float pf = digits;
28
29  if (mult == 9) pf *= 0.1;          // 9 = ×0,1 / 9 means ×0.1
30  else if (mult == 8) pf *= 0.01;    // 8 = ×0,01 / 8 means ×0.01
31  else for (int i = 0; i < mult; i++) pf *= 10;  // sıfır ekle / append zeros
32
33  Serial.print(code); Serial.print(F(" -> "));
34  printValue(pf);
35}

Conversions d'unités sur l'ESP32 et le Raspberry Pi Pico

L'ADC de l'ESP32 est sur 12 bits et renvoie 0-4095, mais les broches fonctionnent en 3,3 V et l'ADC dérive un peu différemment sur chaque carte. Il vaut donc mieux utiliser la fonction analogReadMilliVolts() du core plutôt que de convertir toi-même la valeur brute : elle exploite l'étalonnage gravé en usine dans la puce et renvoie directement des millivolts. Avec l'atténuation par défaut de 11 dB, la plage mesurable va jusqu'à environ 3,1 V, et les résultats les plus précis se situent entre 0,15 et 2,45 V.

C++ (Arduino IDE)
1// ESP32: ham ADC değeri ve kalibrasyonlu mV / raw ADC value and calibrated mV
2const int ADC_PIN = 34;   // yalnız giriş pini, ADC1 / input-only pin, ADC1
3
4void setup() {
5  Serial.begin(115200);
6  analogReadResolution(12);   // 0-4095
7}
8
9void loop() {
10  int raw = analogRead(ADC_PIN);
11  unsigned long mv = analogReadMilliVolts(ADC_PIN);   // fabrika kalibrasyonu / factory calibration
12  float volts = mv / 1000.0;                          // mV -> V
13  Serial.printf("ham/raw: %d  mV: %lu  V: %.3f\n", raw, mv, volts);
14  delay(500);
15}

Sur le Raspberry Pi Pico, la fonction read_u16() de MicroPython ramène la valeur sur 0-65535 alors que l'ADC n'a que 12 bits. Le facteur de conversion doit donc être 3,3 / 65535 et non 3,3 / 4095 ; avec le mauvais facteur, le résultat est 16 fois trop grand. La résolution réelle reste de 3,3 V / 4096 ≈ 0,8 mV.

MicroPython
1# Pico: ADC değerini mV ve V'a çevirme / converting ADC readings to mV and V
2from machine import ADC
3import time
4
5adc = ADC(26)              # GP26 = ADC0
6CONV = 3.3 / 65535         # read_u16() 0-65535 aralığı / range of read_u16()
7
8while True:
9    raw = adc.read_u16()
10    volts = raw * CONV
11    mv = volts * 1000      # V -> mV
12    print("ham/raw:", raw, " mV:", round(mv), " V:", round(volts, 3))
13    time.sleep(0.5)

Erreurs d'unités fréquentes et solutions

  • Confondre m et M : entre 1 mΩ (milliohm) et 1 MΩ (mégohm), il y a un facteur d'un milliard. Le m minuscule veut dire milli, le M majuscule méga ; fais attention à la casse sur le schéma.
  • Lire 104 comme 104 pF : le troisième chiffre est le nombre de zéros, la valeur est donc 100 000 pF. Seuls les marquages à deux chiffres comme 22 et 47 sont directement en picofarads ; avec un code à trois chiffres, même 220 signifie 22 pF et non 220 pF.
  • Comparer des mAh sans regarder la tension : pour comparer des batteries de tensions différentes, passe en Wh, sinon une pile 9 V paraîtra plus faible et une pile AA plus forte qu'elles ne le sont.
  • Division entière : sous Arduino, 3 / 2 donne 1. Si tu veux des décimales, écris l'un des nombres sous la forme 3.0 ou utilise float.
  • Dépassement de int : des produits comme analogRead() × 5000 dépassent la limite de 32 767 du Uno. Convertis en (long) avant de multiplier.
  • Confondre W et Wh : le W est une puissance instantanée, le Wh l'énergie consommée quand cette puissance dure une heure. Un montage de 2 W tient 5 heures sur une batterie de 10 Wh, pertes non comprises.
  • Oublier la puissance de la résistance : 1/4 W, c'est 250 mW. Une résistance de 100 Ω sous 12 V dissipe 1,44 W et grille une résistance classique d'un quart de watt ; fais toujours le calcul de puissance.
Quand un résultat te semble louche, écris les unités à côté des nombres et simplifie-les. Si tu n'obtiens pas l'unité attendue (mA, ms, Wh), un préfixe s'est perdu quelque part dans la formule. Cette habitude attrape la plupart des erreurs alors qu'elles sont encore sur le papier, à l'examen comme à l'établi.

Une fois les préfixes et les raccourcis d'unités bien acquis, lire une fiche technique, choisir un composant et écrire le bon facteur dans ton code devient beaucoup plus rapide. Pour passer à la pratique, les projets voltmètre numérique sur écran LCD, mesure de luminosité avec une LDR, mesure de température avec une CTN et deep sleep de l'ESP32 de l'application BlueGrays montrent pas à pas, avec schéma et code, comment se calculent les lectures de l'ADC, les courants et l'autonomie d'une batterie.

Questions fréquentes

Combien de nF pour un condensateur 104 ?

Le code 104 se lit 10 suivi de quatre zéros : 100 000 pF. Cela fait 100 nF, soit 0,1 µF. C'est le condensateur de découplage qu'on trouve sur l'alimentation de presque tous les montages Arduino.

Combien de nF dans 1 µF ?

1 µF vaut 1000 nF. Pour convertir des nF en µF, divise par 1000 : par exemple, 470 nF = 0,47 µF et 22 nF = 0,022 µF.

Que veut dire 2n2 sur un condensateur ?

Dans 2n2, la lettre n indique à la fois l'unité (nanofarad) et la virgule : la valeur est donc 2,2 nF, soit 2200 pF. Le même condensateur peut aussi porter le code à trois chiffres 222.

Comment convertir des mAh en Wh ?

Multiplie les mAh par la tension nominale de la batterie et divise par 1000 : Wh = mAh × V / 1000. Un accu 18650 de 3,7 V et 2600 mAh stocke environ 9,6 Wh.

Que signifie 4K7 sur une résistance ?

Dans 4K7, le K indique à la fois les kiloohms et la virgule : la valeur est donc 4,7 kΩ, soit 4700 Ω. C'est l'une des valeurs de pull-up les plus utilisées sur les lignes I2C.

Que signifie MFD sur un condensateur ?

MFD est une ancienne notation du microfarad. Un condensateur de démarrage ou permanent marqué 35 MFD fait donc 35 µF ; la mention voisine MMFD désigne des picofarads.

Voir tous les projets
Mesurer l'intensité lumineuse avec une LDR
AR-11Débutant

Mesurer l'intensité lumineuse avec une LDR

Envie de voir en chiffres à quel point ta chambre est lumineuse ? Le LDR, une petite pièce sensible à la lumière, mesure la lumière ambiante, et l'Arduino écrit la valeur sur l'écran de ton…

4.6(83)
143
Mesure de l'intensité lumineuse avec le module LDR ESP32
ES-11Débutant

Mesure de l'intensité lumineuse avec le module LDR ESP32

Suivi en temps réel sur le moniteur série de la valeur brute de l'ADC du module LDR et du pourcentage relatif de luminosité calculé à partir de références dans l'obscurité et à la lumière. Ce pourcentage n'est pas une mesure en lux. Permet de comprendre le principe de calibrage du module. Il est préférable de réaliser cet exercice avant le projet 10, car il sert à déterminer la valeur seuil.

4.6(36)
55
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

HC-SR04 Mesure de la distance (affichage en série)

Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

4.6(50)
82
Voltmètre numérique avec écran LCD
AR-56Intermédiaire
Premium

Voltmètre numérique avec écran LCD

Découvre quelle tension fournit une pile ou un adaptateur avec un appareil de mesure fait maison.

4.5(27)
36
Mesure de la température avec NTC et écran LCD 2x16
AR-44Débutant
Premium

Mesure de la température avec NTC et écran LCD 2x16

Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

4.5(33)
44
Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
ES-13Intermédiaire
Premium

Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)

Dans ce projet, nous contrôlons la luminosité d'une LED de manière analogique à l'aide d'un potentiomètre. La broche ADC de l'ESP32 lit la tension entre 0 et 3,3 V provenant du potentiomètre, puis cette valeur est convertie en signal PWM (modulation de largeur d'impulsion) envoyé à la LED. Ainsi, la LED s'allume et s'éteint progressivement. Avec Arduino Core 3.0+, analogWrite() est utilisable directement; sur ESP32-S2/S3, la résolution de l'ADC est fixée à 12 bits.

4.5(19)
32
Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
ES-33Avancé
Premium

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)

Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

4.3(10)
16
Réglage de la fréquence avec buzzer
AR-14Intermédiaire

Réglage de la fréquence avec buzzer

Tu contrôles le son d'un buzzer avec quatre boutons : l'un lance le son, l'autre le coupe, et les deux derniers le rendent plus aigu ou plus grave.

4.6(69)
120