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.

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éfixe | Symbole | Facteur | Exemple en électronique |
|---|---|---|---|
| pico | p | 10⁻¹² (0,000 000 000 001) | Condensateur de 22 pF près du quartz |
| nano | n | 10⁻⁹ (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 |
| milli | m | 10⁻³ (0,001) | LED à 20 mA, pas de l'ADC de 4,88 mV |
| (unité de base) | - | 1 | 5 V, 1 A, 1 Ω, 1 F |
| kilo | k | 10³ (1000) | Résistance de pull-up de 10 kΩ, porteuse IR de 38 kHz |
| méga | M | 10⁶ (1 000 000) | Impédance d'entrée de 1 MΩ, horloge de 16 MHz |
| giga | G | 10⁹ | Wi-Fi et Bluetooth à 2,4 GHz |
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.
| pF | nF | µF | Code |
|---|---|---|---|
| 10 pF | 0,01 nF | 0,00001 µF | 100 |
| 22 pF | 0,022 nF | 0,000022 µF | 220 |
| 100 pF | 0,1 nF | 0,0001 µF | 101 |
| 1000 pF | 1 nF | 0,001 µF | 102 |
| 2200 pF | 2,2 nF (2n2) | 0,0022 µF | 222 |
| 4700 pF | 4,7 nF (4n7) | 0,0047 µF | 472 |
| 10 000 pF | 10 nF | 0,01 µF | 103 |
| 47 000 pF | 47 nF | 0,047 µF | 473 |
| 100 000 pF | 100 nF | 0,1 µF | 104 |
| 220 000 pF | 220 nF | 0,22 µF | 224 |
| 470 000 pF | 470 nF | 0,47 µF | 474 |
| 1 000 000 pF | 1000 nF | 1 µF | 105 |
| 10 000 000 pF | 10 000 nF | 10 µF | 106 |
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 ?.
- Note les deux premiers chiffres : 47 pour 474.
- Ajoute autant de zéros que l'indique le troisième chiffre : 47 suivi de 4 zéros donne 470 000 pF.
- Divise par 1000 pour obtenir des nF : 470 000 pF = 470 nF.
- Divise encore par 1000 pour obtenir des µF : 470 nF = 0,47 µF.
- 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 %.
- 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.
| Marquage | Signification | Valeur |
|---|---|---|
| 2n2 | Le n remplace la virgule | 2,2 nF = 2200 pF |
| 4n7 | Le n remplace la virgule | 4,7 nF = 4700 pF |
| µ1 ou u1 | Le µ remplace la virgule | 0,1 µF = 100 nF |
| 4µ7 | Le µ remplace la virgule | 4,7 µF |
| p68 | Le p remplace la virgule | 0,68 pF |
| 109 | Troisième chiffre 9 = ×0,1 | 1,0 pF |
| 104Z | Z = tolérance +80 % / -20 % | 100 nF |
| 35 MFD | Ancienne notation : MFD = microfarad | 35 µF |
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.
| Notation | Valeur | En ohms |
|---|---|---|
| R47 | 0,47 Ω | 0,47 Ω |
| 2R2 | 2,2 Ω | 2,2 Ω |
| 220R | 220 Ω | 220 Ω |
| 1K | 1 kΩ | 1000 Ω |
| 4K7 | 4,7 kΩ | 4700 Ω |
| 47K | 47 kΩ | 47 000 Ω |
| 1M0 | 1 MΩ | 1 000 000 Ω |
| 103 (CMS) | 10 et 3 zéros | 10 000 Ω = 10 kΩ |
| 4701 (CMS, 4 chiffres) | 470 et 1 zéro | 4700 Ω = 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 ?.
| Situation | Valeur typique | En unité de base |
|---|---|---|
| Courant par broche de l'Arduino Uno (recommandé / maximum absolu) | 20 mA / 40 mA | 0,02 A / 0,04 A |
| Courant de fonctionnement d'une LED rouge | 10-20 mA | 0,01-0,02 A |
| ESP32 pendant une émission Wi-Fi | jusqu'à 250 mA | 0,25 A |
| Courant de la puce ESP32 en deep sleep | environ 10 µA | 0,00001 A |
| Pas de l'ADC de l'Arduino Uno (5 V, 10 bits) | 4,88 mV | 0,00488 V |
| Pas de l'ADC de l'ESP32 et du Pico (3,3 V, 12 bits) | environ 0,8 mV | 0,0008 V |
| Courant de blocage d'un servo SG90 | 650-700 mA | environ 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.
| Formule | Association d'unités | Exemple |
|---|---|---|
| I = U / R | V / kΩ = mA | 5 V / 10 kΩ = 0,5 mA |
| R = U / I | V / mA = kΩ | (5 V - 2 V) / 20 mA = 0,15 kΩ = 150 Ω |
| U = I × R | mA × kΩ = V | 2 mA × 4,7 kΩ = 9,4 V |
| P = U × I | V × mA = mW | 5 V × 20 mA = 100 mW |
| τ = R × C | kΩ × µF = ms | 10 kΩ × 100 µF = 1000 ms = 1 s |
| τ = R × C | kΩ × nF = µs | 10 kΩ × 100 nF = 1000 µs = 1 ms |
| τ = R × C | MΩ × µF = s | 1 MΩ × 10 µF = 10 s |
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 / accu | Capacité | Tension | Énergie |
|---|---|---|---|
| Pile bouton CR2032 | 220 mAh | 3 V | 0,66 Wh |
| Pile AA alcaline | environ 2500 mAh | 1,5 V | environ 3,75 Wh |
| Pile 9 V alcaline | environ 500 mAh | 9 V | environ 4,5 Wh |
| LiPo de 1000 mAh | 1000 mAh | 3,7 V | 3,7 Wh |
| Accu 18650 Li-ion | 2600 mAh | 3,7 V | 9,62 Wh |
| Batterie externe de 10 000 mAh | 10 000 mAh | 3,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Ω.
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 ».
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.
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.
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.
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.
Projets à réaliser après cet article
Voir tous les projets
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…

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.

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…

Voltmètre numérique avec écran LCD
Découvre quelle tension fournit une pile ou un adaptateur avec un appareil de mesure fait maison.

Mesure de la température avec NTC et écran LCD 2x16
Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

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.

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.

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.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

