Qu'est-ce qu'un condensateur ? Types, code 104 et constante RC

Un condensateur est un composant de base qui stocke une charge électrique entre deux armatures conductrices qui ne se touchent pas, et la restitue très rapidement quand il le faut. Vois-le comme un petit réservoir d'énergie, mais extrêmement rapide : il fournit de la charge quand la tension baisse, absorbe les pics soudains, bloque le courant continu (DC) une fois chargé, mais laisse passer le courant alternatif (AC) et le bruit. Même une Arduino Uno porte de nombreux condensateurs ; ils stabilisent l'alimentation, empêchent les rebonds des boutons, règlent des durées et transforment un signal PWM en tension lisse.

Dans ce guide, tu vas apprendre comment fonctionne un condensateur, les unités pF, nF et µF, la différence entre condensateurs céramiques, électrolytiques et au tantale, comment lire la polarité et la tension de service, ce que signifient des codes comme 104, la constante de temps RC (τ = R·C) et comment monter des condensateurs en série et en parallèle. Pour finir, nous ferons avec Arduino, ESP32 et Raspberry Pi Pico une expérience qui trace la courbe de charge d'un condensateur et mesure sa capacité.

Qu'est-ce qu'un condensateur et comment fonctionne-t-il ?

À l'intérieur de chaque condensateur se trouvent deux surfaces conductrices séparées par une couche isolante appelée diélectrique. Quand tu appliques une tension à ses bornes, les électrons s'accumulent sur une armature et quittent l'autre ; un champ électrique se forme entre les armatures et l'énergie est stockée dans ce champ. La charge stockée se calcule avec Q = C · U, où C est la capacité en farads et U la tension en volts. L'énergie stockée vaut E = ½ · C · U² ; par exemple, un condensateur de 1000 µF chargé à 16 V contient 0,128 joule. Le courant et la tension sont liés par I = C · ΔU/Δt : le condensateur s'oppose aux variations brusques de sa tension, et c'est pour cela qu'il lisse les fluctuations.

Tu peux imaginer un condensateur comme un réservoir d'eau : vide, il se remplit vite, puis le débit ralentit à mesure qu'il se remplit, jusqu'à s'arrêter. C'est pourquoi, dans un circuit en continu, plus aucun courant ne traverse le condensateur une fois qu'il est chargé. En revanche, plus la fréquence augmente, moins il s'oppose au courant ; cette opposition s'appelle la réactance capacitive et se calcule avec Xc = 1 / (2π · f · C). Un condensateur de 100 nF présente environ 1,6 kΩ à 1 kHz, mais seulement 0,16 Ω à 10 MHz. Autrement dit, pour le bruit haute fréquence, c'est presque un court-circuit, et c'est tout le secret des condensateurs de découplage.

Unités de capacité : pF, nF et µF

Le farad est une unité énorme, c'est pourquoi l'électronique utilise presque toujours ses sous-multiples. La conversion est simple : chaque palier vaut un facteur 1000. 1 µF = 1000 nF = 1 000 000 pF, donc 0,1 µF, 100 nF et 100 000 pF sont la même valeur. Quand le symbole µ n'est pas disponible, on écrit un u (10uF), et sur d'anciens schémas tu peux voir MFD pour microfarad. Les valeurs que tu rencontreras le plus dans les projets Arduino sont 22 pF, 100 nF (0,1 µF), 10 µF, 100 µF et 1000 µF.

Types de condensateurs : céramique, électrolytique, tantale et autres

• Céramique : Petit, bon marché et non polarisé. Sa résistance interne (ESR) est très faible, c'est donc lui qui filtre le mieux le bruit rapide. Sa stabilité dépend du diélectrique : C0G (NP0) est très stable, X7R est bon, tandis que Y5V peut perdre plus de la moitié de sa valeur avec la température et la tension appliquée.
• Électrolytique aluminium : Offre une grande capacité dans un petit volume, mais il est polarisé et le liquide intérieur s'assèche avec le temps. Le boîtier indique une limite de 85 °C ou 105 °C et la durée de vie à cette température (ex. 2000 heures) ; en gros, chaque baisse de 10 °C double sa durée de vie.
• Tantale : Plus petit et plus stable qu'un électrolytique de même valeur, mais sensible à la tension inverse et aux pointes de courant ; quand il lâche, il peut se mettre en court-circuit et brûler. Choisis une tension de service au moins deux fois supérieure à ta tension de travail.
• À film : Non polarisé, stable et à faibles pertes ; utilisé dans les circuits audio, les temporisations précises et les filtres secteur 230 V (classe X2). Son défaut : les grosses valeurs sont encombrantes.
• Supercondensateur : Sa capacité se compte en farads, mais il ne supporte qu'environ 2,7 V par cellule. Il stocke moins d'énergie qu'une batterie ; en échange, il se charge et se décharge en quelques secondes et supporte des centaines de milliers de cycles.

Comment lire la polarité (+/−) et la tension de service

• Électrolytique traversant : La patte longue est le plus (+), la courte le moins (−). La bande claire sur la gaine porte des signes moins et indique le côté négatif. Si les pattes ont été coupées, fie-toi à la bande.
• Électrolytique CMS (boîtier cylindrique) : Le demi-cercle noir ou coloré sur le dessus indique le côté négatif.
• Tantale : Attention, la règle est inversée : la bande ou le trait sur un condensateur au tantale indique la patte positive.
• Céramique et film : Non polarisés ; ils se montent dans n'importe quel sens.
• Sur un schéma : Un condensateur non polarisé est dessiné par deux traits droits parallèles. Pour un modèle polarisé, une armature est dessinée courbe ou pleine et un signe + marque le côté positif.

La tension de service inscrite sur le boîtier (ex. 16 V, 25 V, 50 V) est la tension continue maximale que le condensateur supporte en permanence, et elle ne doit jamais être dépassée. La règle sûre consiste à choisir un condensateur d'au moins 1,5 à 2 fois la tension la plus élevée du circuit : 10 V ou 16 V dans un montage Arduino en 5 V, 25 V avec un adaptateur 12 V, et 35 V ou 50 V en 24 V. Utiliser une tension plus élevée que nécessaire ne pose aucun problème ; le composant est juste plus gros et un peu plus cher.

Lire le code d'un condensateur : que signifie 104 ?

Pour gagner de la place, les condensateurs céramiques et à film indiquent leur valeur avec un code à trois chiffres. L'unité est toujours le picofarad : les deux premiers chiffres donnent le nombre, le troisième le nombre de zéros à ajouter. Donc 104 = 10 suivi de 4 zéros = 100 000 pF = 100 nF = 0,1 µF. Les codes à deux chiffres donnent directement la valeur en pF (22 = 22 pF), et un 0 en troisième position n'ajoute aucun zéro (220 = 22 pF). Dans la notation avec lettre, la lettre sert à la fois d'unité et de virgule : 4n7 = 4,7 nF, 2p2 = 2,2 pF. Pour décoder rapidement, utilise l'outil Code de condensateur.

La lettre qui suit le code indique la tolérance : J = ±5 %, K = ±10 %, M = ±20 %, Z = +80 % / −20 %. Sur les condensateurs à film, un code de tension peut aussi précéder le tout ; par exemple 2A104J signifie 100 V (2A), 100 nF (104) et ±5 % (J). Les codes de tension les plus courants sont 1C = 16 V, 1H = 50 V, 2A = 100 V et 2J = 630 V. Les électrolytiques n'utilisent pas de code ; la valeur est imprimée en clair (470 µF 16 V). Les condensateurs céramiques CMS, eux, ne portent généralement aucun marquage : tu ne peux connaître leur valeur que par l'emballage ou par la mesure.

Charge, décharge et constante de temps RC (τ = R·C)

Quand tu charges un condensateur à travers une résistance, sa tension ne saute pas d'un coup : elle monte selon une courbe exponentielle, Uc = Us · (1 − e^(−t/RC)) (Us est la tension de la source, t le temps écoulé). À la décharge, elle baisse au même rythme : Uc = U0 · e^(−t/RC). Le produit R·C s'appelle la constante de temps et se note τ (tau) ; des ohms multipliés par des farads donnent des secondes. Par exemple, avec une résistance de 10 kΩ et un condensateur de 100 µF, τ = 10 000 × 0,0001 = 1 seconde. Avec 1 kΩ et 100 nF, τ ne vaut que 0,1 milliseconde.

En pratique, on considère qu'un condensateur est entièrement chargé ou déchargé après environ 5τ ; dans l'exemple 10 kΩ et 100 µF, cela fait 5 secondes. Ce comportement est à la base des temporisations, des circuits anti-rebond pour boutons, des lampes qui s'éteignent doucement et du circuit 555. Pour revoir les valeurs de résistances, lis Qu'est-ce qu'une résistance ?, et pour voir comment la courbe change avec d'autres valeurs de R et C, essaie l'outil Constante de temps RC. La relation entre tension, courant et résistance est expliquée en détail dans La loi d'Ohm.

Filtrage et découplage : pourquoi un 100 nF à côté de chaque circuit intégré ?

Les microcontrôleurs et autres circuits intégrés tirent de brèves impulsions de courant, de quelques nanosecondes, à chaque front d'horloge. Si l'alimentation est loin, l'inductance des fils ne suit pas ces demandes soudaines ; de petites chutes et du bruit apparaissent sur l'alimentation, avec pour résultat des redémarrages aléatoires, des lectures analogiques peu fiables ou des blocages. La solution consiste à placer un condensateur céramique de 100 nF entre les broches VCC et GND de chaque circuit, le plus près possible. Il agit comme un minuscule réservoir d'énergie juste à côté de la puce et court-circuite le bruit haute fréquence vers GND. On l'appelle condensateur de découplage (decoupling) ou de bypass. Pour les variations de charge lentes et importantes, on ajoute à l'entrée d'alimentation un électrolytique de 10 à 1000 µF (condensateur réservoir).

• 100 nF pour chaque circuit intégré : Entre VCC et GND, avec des pattes courtes et le plus près possible de la broche d'alimentation de la puce.
• Régulateurs linéaires comme le 7805 : Le fabricant recommande 0,33 µF en entrée et 0,1 µF en sortie ; en pratique, on ajoute souvent 10 à 100 µF en sortie. Plus de détails dans Régulateur de tension 7805.
• Servomoteurs : 100 à 470 µF sur l'alimentation du servo, près de celui-ci, aident à éviter que l'Arduino redémarre quand le servo bouge (Qu'est-ce qu'un servomoteur ?).
• Rubans LED WS2812B : On recommande un condensateur de 500 à 1000 µF, d'au moins 6,3 V, entre les bornes + et − de l'adaptateur (WS2812B NeoPixel).
• Moteurs à courant continu : Un céramique de 100 nF soudé directement entre les bornes du moteur réduit fortement les parasites produits par les balais (Moteur CC avec L298N).
• Modules sans fil : Le courant grimpe d'un coup pendant l'émission. Ajouter 10 µF sur les broches d'alimentation du nRF24L01 et 100 à 470 µF entre 3,3 V et GND sur l'ESP32 réduit les pertes de connexion et les redémarrages par brownout.

En associant une résistance et un condensateur en série, tu obtiens un filtre passe-bas : il laisse passer les fréquences sous un certain seuil et atténue celles au-dessus. La fréquence de coupure vaut fc = 1 / (2π · R · C). La sortie PWM de l'Arduino Uno est un signal carré à 490 Hz (980 Hz sur les broches 5 et 6) ; avec un filtre de 10 kΩ et 10 µF (fc ≈ 1,6 Hz), ce signal devient une tension continue presque plate, ce qui te donne une sortie analogique simple. La contrepartie est le temps de réponse : avec τ = 0,1 s, il faut environ une demi-seconde pour se stabiliser sur une nouvelle valeur. Plus de détails dans Qu'est-ce que le PWM ?. Une alimentation redressée se filtre aussi avec un gros condensateur de lissage, et l'ondulation résiduelle vaut environ ΔU ≈ I / (f · C) : avec 1 A de charge, un redressement double alternance à 100 Hz et 4700 µF, on obtient environ 2,1 V.

Monter des condensateurs en série et en parallèle

Les formules des condensateurs sont exactement l'inverse de celles des résistances. En parallèle, les capacités s'additionnent : C = C1 + C2 + … et la tension de service est celle du composant le plus faible. En série, la capacité totale est même inférieure à celle du plus petit condensateur : 1/C = 1/C1 + 1/C2 + … Deux condensateurs identiques en série donnent la moitié de la capacité et, sur le papier, leurs tensions s'additionnent ; mais comme leurs courants de fuite diffèrent, la tension se répartit inégalement, d'où l'ajout d'une résistance d'équilibrage de même valeur (ex. 100 kΩ) en parallèle sur chacun. S'il te manque une valeur, tu peux l'obtenir en combinant deux condensateurs ; fais le calcul avec l'outil Série / parallèle C, et consulte calcul de résistances en série et en parallèle pour l'équivalent avec des résistances.

Expérience avec Arduino : courbe de charge et mesure de capacité

Le meilleur moyen de voir la théorie de tes propres yeux est de mesurer la tension d'un condensateur pendant sa charge. Une broche numérique de l'Arduino va charger le condensateur à travers une résistance de 10 kΩ, et une entrée analogique va lire sa tension. Le temps nécessaire pour atteindre 63,2 % de la tension de la source correspond à un τ, d'où l'on calcule la capacité avec C = τ / R. Il te faut : une Arduino Uno, un condensateur électrolytique de 100 µF, une résistance de 10 kΩ, une platine d'essai (breadboard) et quelques fils de connexion.

1. Place le condensateur sur la platine d'essai : la patte + dans une rangée, la patte − sur la ligne GND.
2. Relie une extrémité de la résistance de 10 kΩ à D8 et l'autre à la rangée où se trouve la patte + du condensateur.
3. Tire un fil de cette même rangée vers A0 et relie le GND de l'Arduino à la ligne GND de la platine.
4. Téléverse le code ci-dessous et ouvre le moniteur série à 115200 bauds.
5. Le code décharge d'abord le condensateur puis le charge ; toutes les 20 ms, il affiche le temps écoulé et la tension, puis à la fin le τ mesuré et la capacité.
6. Pour voir la courbe sous forme de graphique, mets PLOT à true dans le code, téléverse-le à nouveau et ouvre Outils > Traceur série.

1// Kondansatör şarj eğrisi ve kapasite ölçümü / Capacitor charge curve and capacitance meter
2const int CHARGE_PIN = 8;       // 10 kΩ direnç bu pinden beslenir / the 10 kΩ resistor is driven from this pin
3const int SENSE_PIN = A0;       // kondansatörün + bacağı / capacitor + leg
4const float R_OHM = 10000.0;    // şarj direnci (ohm) / charge resistor (ohms)
5const float VREF = 5.0;         // Uno ADC referansı / Uno ADC reference
6const bool PLOT = false;        // true: Seri Çizici için yalnız gerilim / true: voltage only for the Serial Plotter
7
8void setup() {
9  Serial.begin(115200);
10  pinMode(CHARGE_PIN, OUTPUT);
11}
12
13void loop() {
14  // 1) Boşalt: pin LOW, kondansatör direnç üzerinden boşalır / discharge through the resistor
15  digitalWrite(CHARGE_PIN, LOW);
16  while (analogRead(SENSE_PIN) > 4) { }           // ~20 mV altı; ADC ofsetine pay bırak / below ~20 mV, leaves room for ADC offset
17  delay(1000);                                  // kalan yükü de boşalt / drain what is left
18
19  // 2) Şarj et, eğriyi yazdır, τ'yu yakala / charge, print the curve, catch τ
20  unsigned long t0 = millis();
21  unsigned long lastPrint = 0;
22  unsigned long tauMs = 0;
23  digitalWrite(CHARGE_PIN, HIGH);
24  while (true) {
25    int raw = analogRead(SENSE_PIN);
26    unsigned long t = millis() - t0;
27    if (tauMs == 0 && raw >= 647) tauMs = t;     // 1023 x 0,632 = 647 → bir τ / one τ
28    if (t - lastPrint >= 20) {                   // 20 ms'de bir yazdır / print every 20 ms
29      lastPrint = t;
30      float v = raw * VREF / 1023.0;
31      if (!PLOT) {
32        Serial.print(t);
33        Serial.print('\t');
34      }
35      Serial.println(v, 3);
36    }
37    if (raw >= 1010 || t > 60000) break;         // ~%99 dolu ya da zaman aşımı / ~99% full or timeout
38  }
39
40  // 3) Sonuç: C = τ / R / result: C = τ / R
41  if (!PLOT) {
42    float uF = (tauMs / 1000.0) / R_OHM * 1000000.0;
43    Serial.print(F("tau = "));
44    Serial.print(tauMs);
45    Serial.print(F(" ms   C = "));
46    Serial.print(uF, 1);
47    Serial.println(F(" uF"));
48  }
49  delay(3000);
50}

Voici le principe du code : quand la broche est à LOW, le condensateur se décharge à travers la même résistance de 10 kΩ. Dès que la broche passe à HIGH, millis() commence à compter ; quand la lecture analogique atteint 647 (63,2 % de 1023), le temps écoulé est enregistré comme τ. Quand la lecture atteint 1010 (environ 99 %), la charge est considérée comme terminée. Avec 100 µF et 10 kΩ, tu devrais voir environ 1000 ms et 100 µF. Les électrolytiques ont en général une tolérance de ±20 %, donc des résultats entre 80 et 120 µF sont normaux. Pour en savoir plus sur la mesure du temps, consulte millis et delay.

La même expérience avec ESP32 et Raspberry Pi Pico

Sur l'ESP32, les broches fonctionnent en 3,3 V et l'ADC est sur 12 bits (0–4095). L'ADC de l'ESP32 n'est pas linéaire près des extrémités de sa plage, donc au lieu des valeurs brutes nous utilisons analogReadMilliVolts(), qui renvoie des millivolts calibrés. Comme broche de mesure, nous avons choisi le GPIO 34 du groupe ADC1, qui n'est pas perturbé par le Wi-Fi. Comme l'ADC ne mesure pas de façon fiable au-dessus d'environ 3,1 V, nous détectons la fin de la charge par le temps plutôt que par la tension : une fois τ trouvé, la mesure s'arrête au bout de 5τ. Pour les bases, lis Qu'est-ce que l'ESP32 ?.

1// ESP32 ile kondansatör şarj eğrisi / Capacitor charge curve with ESP32
2const int CHARGE_PIN = 25;      // 10 kΩ direnç bu pinden beslenir / the 10 kΩ resistor is driven from this pin
3const int SENSE_PIN = 34;       // ADC1, yalnız giriş / ADC1, input only
4const float R_OHM = 10000.0;    // şarj direnci (ohm) / charge resistor (ohms)
5
6void setup() {
7  Serial.begin(115200);
8  pinMode(CHARGE_PIN, OUTPUT);
9}
10
11void loop() {
12  digitalWrite(CHARGE_PIN, LOW);                       // boşalt / discharge
13  unsigned long d0 = millis();
14  // ADC ~150 mV altını okuyamaz, 200 mV'a inmesini bekle / the ADC cannot read below ~150 mV, wait for 200 mV
15  while (analogReadMilliVolts(SENSE_PIN) > 200 && millis() - d0 < 60000) { }
16  delay(millis() - d0 + 1000);                         // aynı süre kadar daha bekle / wait as long again
17
18  unsigned long t0 = millis();
19  unsigned long tauMs = 0;
20  digitalWrite(CHARGE_PIN, HIGH);                      // şarj et / charge
21  while (true) {
22    unsigned long t = millis() - t0;
23    uint32_t mv = analogReadMilliVolts(SENSE_PIN);     // kalibre edilmiş mV / calibrated mV
24    if (tauMs == 0 && mv >= 2086) tauMs = t;           // 3300 mV x 0,632 → bir τ / one τ
25    Serial.println(mv);                                // Seri Çizici için / for the Serial Plotter
26    if ((tauMs > 0 && t >= 5 * tauMs) || t > 60000) break;   // 5τ ≈ %99 dolu / 5τ ≈ 99% full
27    delay(20);
28  }
29  Serial.printf("tau = %lu ms   C = %.1f uF\n", tauMs, tauMs / 1000.0 / R_OHM * 1000000.0);
30  delay(3000);
31}

Sur la Raspberry Pi Pico, la même expérience tient en quelques lignes de MicroPython. Les entrées analogiques de la Pico sont GP26, GP27 et GP28 ; read_u16() renvoie la mesure 12 bits mise à l'échelle 0–65535. Le code affiche sur chaque ligne le temps écoulé et la tension, tu peux donc copier la sortie dans un tableur et tracer la courbe toi-même. Si tu ne sais pas encore installer MicroPython sur la Pico, commence par Qu'est-ce que la Raspberry Pi Pico ?.

1# Pico ile kondansatör şarj eğrisi / Capacitor charge curve with Pico
2from machine import Pin, ADC
3import time
4
5charge = Pin(15, Pin.OUT)       # 10 kΩ direnç bu pinden beslenir / resistor driven from this pin
6adc = ADC(26)                   # GP26 = ADC0, kondansatörün + bacağı / capacitor + leg
7R = 10000                       # şarj direnci (ohm) / charge resistor (ohms)
8
9def volts():
10    return adc.read_u16() * 3.3 / 65535
11
12charge.value(0)                 # önce boşalt / discharge first
13d0 = time.ticks_ms()
14while volts() > 0.1 and time.ticks_diff(time.ticks_ms(), d0) < 60000:
15    pass                        # ADC sıfırda birkaç on mV gösterebilir / the ADC may read a few tens of mV at 0 V
16time.sleep_ms(time.ticks_diff(time.ticks_ms(), d0) + 1000)   # aynı süre kadar daha bekle / wait as long again
17
18t0 = time.ticks_ms()
19charge.value(1)                 # şarjı başlat / start charging
20tau = None
21while True:
22    t = time.ticks_diff(time.ticks_ms(), t0)
23    v = volts()
24    if tau is None and v >= 3.3 * 0.632:    # 2,086 V → bir τ / one τ
25        tau = t
26    print(t, round(v, 3))
27    if (tau is not None and t >= 5 * tau) or t > 60000:
28        break
29    time.sleep_ms(20)
30
31if tau is not None:
32    print("tau =", tau, "ms  C =", round(tau / 1000 / R * 1e6, 1), "uF")

Idées de projets avec des condensateurs

• Anti-rebond matériel : Place 100 nF à 1 µF aux bornes du bouton ; avec une résistance de tirage (pull-up) de 10 kΩ, cela forme un filtre avec τ = 1 à 10 ms, et les rebonds s'éteignent avant d'atteindre ton code.
• Tension analogique à partir du PWM : Avec un filtre RC, transforme une sortie PWM en tension lisse de 0 à 5 V et mesure-la au multimètre.
• LED clignotante avec un 555 : Dans le circuit 555, deux résistances et un condensateur fixent la fréquence : f ≈ 1,44 / ((R1 + 2·R2) · C). Calcule les valeurs avec l'outil Temporisateur 555.
• Lampe qui s'éteint doucement : Après l'interrupteur, place un condensateur de 1000 µF en parallèle sur l'alimentation de la LED et de sa résistance ; quand tu coupes le courant avec l'interrupteur, la LED ne s'éteint pas d'un coup mais faiblit à mesure que le condensateur se décharge. La résistance et la capacité fixent ensemble la durée.
• Capteurs capacitifs : Un capteur capacitif d'humidité du sol mesure la capacité modifiée par l'eau dans la terre ; comme ses électrodes ne sont pas exposées, il ne se corrode pas.
• Capacimètre simple : Associe l'expérience ci-dessus à un écran LCD I2C et affiche la valeur de tes condensateurs.

Erreurs fréquentes et solutions

• Croire que 104 vaut 104 µF : 104 vaut 100 nF ; les codes à trois chiffres sont toujours en picofarads.
• Monter un électrolytique à l'envers : Le condensateur chauffe, gonfle ou éclate ; la patte côté bande va vers GND (sur un tantale, la bande indique le plus).
• Choisir une tension de service trop faible : Un condensateur de 10 V sur une ligne 12 V lâche vite ; garde une marge d'au moins 1,5 à 2 fois.
• Placer le condensateur de découplage trop loin : À 10 cm de la puce, un 100 nF perd son effet à cause de l'inductance des fils ; garde des pattes courtes et place-le au pied des broches d'alimentation.
• L'Arduino redémarre quand un moteur démarre : La tension d'alimentation chute un instant ; alimente le moteur séparément, ajoute 100 à 470 µF sur l'alimentation et relie les masses (Pourquoi mon Arduino redémarre-t-il tout seul ?).
• Erreur "Failed to connect to ESP32: Timed out waiting for packet header" sur l'ESP32 : Sur certaines cartes, le circuit de programmation automatique rate le bon timing ; ajouter un condensateur de 1 à 10 µF entre EN et GND évite souvent d'avoir à appuyer sur le bouton BOOT.

Après la résistance et la LED, le condensateur est le composant le plus fondamental à connaître ; une fois que tu as compris τ = R·C et pris l'habitude de mettre 100 nF à côté de chaque circuit intégré, tes montages deviennent bien plus stables. Comme étape suivante, passe à la bobine avec Qu'est-ce qu'une bobine ?. Dans l'application BlueGrays, tu trouveras des projets de LED commandée par bouton, de mesure de lumière avec LDR, de variation de LED en PWM et de WS2812B avec schémas et code pas à pas, pour essayer tout de suite dans de vrais circuits ce que tu as appris sur les condensateurs.