Composants électroniques de base : symboles, unités et rôles

Les composants électroniques de base sont les briques de tout circuit : des pièces qui limitent le courant, stockent de l'énergie, ne laissent passer le courant que dans un sens, commutent, amplifient un signal ou protègent le circuit. Résistance, condensateur, bobine, diode, LED, transistor, MOSFET, circuit intégré, relais, régulateur de tension, fusible, bouton-poussoir, potentiomètre et quartz : du chargeur de téléphone à la carte Arduino, presque tous les appareils électroniques contiennent plusieurs de ces quatorze composants. Chacun a son propre symbole sur le schéma, une lettre repère (comme R, C, L, D ou Q) et une unité qui exprime sa valeur. Savoir les reconnaître est la première étape pour lire un schéma électronique et réaliser tes propres projets sans erreur.

Dans ce guide, nous réunissons d'abord les quatorze composants dans un tableau récapitulatif avec leur lettre repère, leur unité, leur symbole, leur aspect et leur rôle typique. Nous expliquons ensuite la différence entre composants passifs et actifs, le fonctionnement de chaque pièce, les valeurs que tu rencontreras et les erreurs les plus fréquentes ; à la fin de chaque partie, tu trouveras un lien vers l'article détaillé consacré à ce composant. Dans la dernière partie, nous montons un circuit pour Arduino, ESP32 et Raspberry Pi Pico qui associe potentiomètre, résistance, LED, bouton, transistor, diode, condensateur et relais, et tu verras comment tester les composants avec un Arduino et un multimètre.

Quels sont les composants électroniques ? Tableau récapitulatif

Le tableau ci-dessous compare d'un coup d'œil les quatorze composants de cet article. La lettre repère est l'abréviation placée au début de l'étiquette de chaque pièce sur le schéma ; des numéros comme R1, C3 ou Q2 distinguent les pièces du même type. La colonne unité indique dans quelle grandeur la valeur est donnée : la résistance se mesure en ohms (Ω), le condensateur en farads (F), la bobine en henrys (H) et le quartz en hertz (Hz). Les diodes, transistors et relais n'ont pas d'unité unique ; tu les choisis selon la tension (V) et le courant (A) qu'ils supportent. Les symboles suivent la norme IEC utilisée en Europe ; sur les schémas américains (ANSI), certains sont dessinés autrement.

Composants passifs et actifs

Les composants électroniques sont généralement classés en deux grandes familles. Les composants passifs n'apportent pas d'énergie au circuit et ne peuvent pas amplifier un signal ; ils se contentent de la dissiper (résistance), de la stocker (condensateur, bobine) ou de la filtrer. Les composants actifs utilisent l'énergie d'une alimentation pour commander un autre courant ou amplifier un signal ; transistors, MOSFET et circuits intégrés en font partie. Les diodes et les LED sont à la frontière : comme elles n'apportent aucun gain, elles sont passives au sens strict, mais comme elles sont faites du même semi-conducteur que les transistors, beaucoup de manuels les rangent parmi les composants actifs. Si la question tombe à un examen, retiens la définition de ton manuel. Les relais, boutons et fusibles sont souvent classés à part, comme composants électromécaniques ou de protection.

Résistance : le composant qui limite le courant

La résistance est le composant le plus simple : elle s'oppose au courant qui la traverse et transforme une partie de l'énergie en chaleur. Son unité est l'ohm (Ω), et la relation entre tension, courant et résistance est donnée par U = R × I, la loi d'Ohm. Sur Arduino, tu l'utiliseras surtout pour deux choses : limiter le courant d'un composant comme une LED et réaliser un pont diviseur de tension. Par exemple, pour allumer une LED rouge à 15 mA depuis une broche de 5 V, il faut (5 − 2) / 0,015 = 200 Ω ; on choisit la valeur normalisée supérieure, 220 Ω. La valeur des résistances traversantes se lit grâce aux anneaux de couleur : rouge-rouge-marron-or signifie 220 Ω avec une tolérance de ±5 %. Les résistances sont fabriquées dans des valeurs normalisées appelées série E12 (10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82 et leurs multiples de dix). Aussi importante que la valeur, la puissance admissible : les résistances des montages amateurs font généralement 1/4 W, et si la puissance calculée avec P = R × I² la dépasse, elles chauffent et grillent. Tu peux décoder les anneaux avec l'outil Code couleur des résistances ; pour en savoir plus, lis Qu'est-ce qu'une résistance ? et La loi d'Ohm.

Condensateur : une petite réserve d'énergie très rapide

Un condensateur stocke des charges électriques sur deux armatures conductrices séparées par un isolant et peut les restituer très rapidement. Son unité est le farad (F), mais comme un farad est énorme, on utilise en pratique le picofarad (pF), le nanofarad (nF) et le microfarad (µF) : 1 µF = 1 000 nF = 1 000 000 pF. Une fois chargé, il bloque le courant continu, tandis que les signaux rapides et les parasites le traversent. C'est pourquoi on place un condensateur céramique de découplage de 100 nF près des broches d'alimentation de chaque circuit intégré, et des électrolytiques de 100 à 1000 µF sur l'alimentation des moteurs et des servos. Les condensateurs céramiques ne sont pas polarisés et leur valeur est imprimée sous forme de code : 104 signifie 10 suivi de quatre zéros, soit 100 000 pF = 100 nF. Les électrolytiques sont polarisés ; la bande claire sur le boîtier repère la patte négative, et branchés à l'envers ils peuvent gonfler et éclater. Associé à une résistance, la constante de temps τ = R × C fixe la vitesse de charge ; avec 10 kΩ et 100 µF, τ = 1 seconde. Tu peux décoder les marquages avec l'outil Code des condensateurs et lire les types et les calculs dans Qu'est-ce qu'un condensateur ?.

Bobine (inductance) : le composant qui s'oppose aux variations brusques de courant

Une bobine est obtenue en enroulant un fil conducteur, généralement autour d'un noyau en poudre de fer ou en ferrite ; elle stocke l'énergie dans un champ magnétique. Son unité est le henry (H) ; en électronique, tu verras surtout des microhenrys (µH) et des millihenrys (mH). Contrairement au condensateur, la bobine s'oppose aux variations brusques du courant : la tension à ses bornes vaut U = L × di/dt. Elle laisse donc passer le continu presque sans opposition mais freine les hautes fréquences ; cette opposition se calcule avec XL = 2π × f × L. Tu la croiseras le plus souvent sous la forme de la grosse bobine noire des convertisseurs abaisseurs à découpage comme le LM2596 (typiquement 33 à 47 µH), où elle stocke l'énergie à chaque cycle de commutation et la transmet à la charge. Les relais, moteurs, buzzers et haut-parleurs contiennent eux aussi des bobines qui, lorsqu'on coupe leur courant, produisent une pointe de tension inverse ; pour l'absorber, on branche une diode en inverse aux bornes des charges inductives. La valeur des petites bobines traversantes est marquée par des anneaux de couleur, comme les résistances, en µH ; tu peux la lire avec l'outil Code des bobines et en savoir plus dans Qu'est-ce qu'une bobine ?.

Diode et LED : un sens unique pour le courant

Une diode est un semi-conducteur qui laisse passer le courant dans un seul sens, de l'anode vers la cathode ; dans l'autre sens, presque aucun courant ne circule. Lorsqu'elle conduit, une tension de seuil apparaît à ses bornes : environ 0,6 à 1 V pour une diode au silicium et 0,15 à 0,6 V pour une diode Schottky. La bague grise ou blanche du boîtier repère la cathode et correspond à la barre du symbole. Les modèles les plus courants sont la diode de redressement 1N4007 (1 A, 1000 V), la diode de signal rapide 1N4148 et la Schottky 1N5819 à faible chute de tension. Une diode a quatre rôles principaux : transformer l'alternatif en continu (redressement), protéger le circuit d'une pile branchée à l'envers, absorber les surtensions inverses des charges inductives comme les relais et les moteurs (diode de roue libre) et, pour la diode Zener, maintenir une tension fixe. Comparatifs et méthodes de test détaillés dans Qu'est-ce qu'une diode ?.

Une LED (diode électroluminescente) est une diode qui émet de la lumière quand un courant la traverse et qui, comme toute diode, ne fonctionne que dans un sens. La patte longue est l'anode (+), la courte la cathode (−) ; le dôme présente aussi un méplat côté cathode. La règle d'or : toujours une résistance en série. Une LED ne limite pas elle-même son courant ; dès que la tension dépasse un peu sa tension directe, le courant s'envole et la LED ou la broche de l'Arduino est endommagée. La résistance se calcule avec R = (Ualim − ULED) / I. Les LED standard de 5 mm fonctionnent bien entre 10 et 20 mA ; les rouges et les jaunes ont une tension directe d'environ 2 V, les bleues, blanches et vert vif d'environ 3 V. Tu peux faire le calcul avec l'outil Résistance pour LED, consulter la tension de chaque couleur avec Tensions des LED et en lire davantage dans Qu'est-ce qu'une LED ?.

Transistor et MOSFET : des interrupteurs électroniques

Un transistor bipolaire (BJT) est un semi-conducteur à trois pattes qui commande un courant de collecteur bien plus grand à l'aide d'un petit courant de base. Ses pattes sont la base (B), le collecteur (C) et l'émetteur (E), et son gain s'exprime par IC = hFE × IB. Il existe deux types, NPN et PNP ; dans les projets Arduino, le NPN, émetteur relié à GND, est de loin le plus courant. Comme une broche d'Arduino ne peut pas fournir sans risque beaucoup plus de 20 mA environ, les relais, moteurs, buzzers et rubans LED sont pilotés par un transistor. Entre la broche et la base, il faut toujours une résistance : pour piloter un relais 5 V (environ 71 mA) avec un 2N2222A, 680 Ω conviennent sur un Arduino Uno et 470 Ω sur l'ESP32 et le Pico en 3,3 V. Pour les petites charges on utilise le BC547 (100 mA), pour les charges moyennes le 2N2222A (600 mA) et jusqu'à quelques ampères le Darlington TIP120 (5 A). Comme le brochage change d'un modèle à l'autre, vérifie-le avec l'outil Brochage des transistors ; les régimes de fonctionnement et les calculs sont dans Qu'est-ce qu'un transistor ?.

Le MOSFET est lui aussi un transistor, mais il se commande en tension et non en courant. Ses bornes sont la grille (G, gate), le drain (D) et la source (S). La grille est isolée du canal par une fine couche d'oxyde, si bien qu'au repos elle ne consomme presque aucun courant ; quand la tension grille-source dépasse nettement la tension de seuil (VGS(th)), la résistance drain-source (RDS(on)) tombe à quelques milliohms. C'est pour cela qu'un MOSFET chauffe beaucoup moins qu'un transistor bipolaire à fort courant. Avec un Arduino, le plus important est de choisir un modèle logic level : l'IRLZ44N conduit pleinement avec 5 V sur la grille, alors que le très répandu IRF540N demande 10 V et chauffe sous 5 V. Pour les broches 3,3 V de l'ESP32 et du Pico, on choisit des modèles à seuil plus bas comme l'IRLB8721 ou l'AO3400. On place une résistance de 100 à 220 Ω en série avec la grille et une résistance de rappel de 10 kΩ entre grille et GND. Les schémas de câblage sont dans Utiliser un MOSFET avec Arduino.

Circuit intégré : des milliers de composants sur une puce

Un circuit intégré (CI, puce) est un circuit tout prêt dans lequel des milliers, voire des milliards de composants comme des transistors, des résistances et des condensateurs sont réunis sur un seul morceau de silicium. Sur le schéma, il est généralement dessiné comme une boîte aux broches numérotées, avec la lettre U ou IC. Les versions compatibles avec une breadboard sont en boîtier DIP (DIP-8, DIP-14, DIP-16), tandis que les cartes finies utilisent des boîtiers CMS bien plus petits (SOIC, TSSOP). Pour câbler correctement, repère d'abord la broche 1 : cherche l'encoche en demi-lune à une extrémité ou le petit point dans un coin. En regardant la puce de dessus, encoche à gauche, la broche en bas à gauche est la 1 et la numérotation tourne dans le sens inverse des aiguilles d'une montre. Les circuits intégrés que tu croiseras le plus souvent sont le temporisateur NE555, le 74HC595 qui multiplie les sorties, l'amplificateur opérationnel LM358, les puces de portes logiques et l'ATmega328P à 28 broches, le cerveau de l'Arduino Uno. Prends l'habitude de placer un condensateur de 100 nF entre VCC et GND de chaque circuit intégré, le plus près possible.

Relais : commuter une grosse charge avec un petit signal

Un relais est un interrupteur électromécanique : quand un courant traverse sa bobine, le champ magnétique attire un contact métallique. Comme le côté contacts est isolé électriquement de la bobine, tu peux allumer une lampe sur le secteur ou une pompe 12 V avec un signal de 5 V. Les contacts s'appellent COM (commun), NO (normalement ouvert) et NC (normalement fermé) : bobine non alimentée, COM est relié à NC ; quand la bobine colle, COM bascule sur NO. Le relais SRD-05VDC-SL-C des kits Arduino a une bobine d'environ 70 Ω et consomme environ 71 mA sous 5 V, bien plus qu'une broche ne peut fournir. C'est pourquoi un relais est toujours piloté par un transistor, avec une diode de roue libre branchée en inverse aux bornes de la bobine. Les modules relais prêts à l'emploi intègrent déjà le transistor, la diode et une LED d'état. Les petits interrupteurs dont les deux fines lames, enfermées dans une ampoule de verre, se ferment à l'approche d'un aimant s'appellent des interrupteurs reed (ILS) et équipent les capteurs de porte et de fenêtre.

Régulateur de tension : une alimentation stable et sûre

Un régulateur de tension maintient une tension constante en sortie même si la tension d'entrée varie. L'exemple le plus connu est le 7805 : il fournit 5 V à partir d'une entrée de 7 à 35 V et peut débiter jusqu'à 1,5 A avec un dissipateur. Face imprimée vers toi, ses pattes sont de gauche à droite entrée (IN), GND et sortie (OUT). Le 7805 est un régulateur linéaire : il transforme la différence de tension en chaleur. La puissance dissipée vaut P = (Uentrée − Usortie) × I : en tirant 0,5 A sous 5 V à partir de 12 V, on produit 3,5 W de chaleur, trop pour un boîtier TO-220 sans dissipateur. Pour une sortie de 3,3 V, on utilise l'AMS1117-3.3, présent aussi sur beaucoup de cartes ESP32 ; c'est un régulateur à faible chute (LDO), il suffit que l'entrée dépasse la sortie d'environ 1,1 à 1,3 V. S'il te faut beaucoup de courant et un bon rendement, un convertisseur abaisseur à découpage comme le LM2596 fournit jusqu'à 3 A avec un rendement d'environ 80 à 90 %. N'oublie pas les condensateurs d'entrée et de sortie ; les détails sont dans Le régulateur de tension 7805 et Alimenter un Arduino.

Fusible : la ceinture de sécurité du circuit

Un fusible est un composant de protection qui coupe le circuit en fondant, ou en augmentant fortement sa résistance, lorsque le courant dépasse une valeur donnée. Son vrai rôle n'est pas de protéger l'électronique, mais d'éviter qu'un court-circuit fasse chauffer ou brûler les câbles, les batteries et l'alimentation. Il porte son courant nominal (par ex. 1 A) et la tension maximale qu'il supporte (par ex. 250 V). La lettre qui précède compte aussi : un fusible F (rapide) fond dès une surintensité brutale, tandis qu'un fusible T (temporisé) supporte le bref appel de courant des moteurs et des gros condensateurs à la mise sous tension. Choisis un calibre d'environ 1,25 à 1,5 fois le courant normal et place le fusible sur la ligne positive, le plus près possible de la source. Les fusibles en verre (5×20 mm) et les fusibles automobiles à lame se remplacent après avoir fondu ; les fusibles PTC (réarmables) coupent le courant en chauffant et reviennent à l'état normal en refroidissant. L'Arduino Uno possède un tel fusible PTC sur son entrée USB, qui protège le port USB de ton ordinateur au-delà de 500 mA. Pour savoir si ta carte est vraiment hors service, consulte Mon Arduino est-il grillé ?.

Bouton et interrupteur : ouvrir et fermer le circuit à la main

Un bouton-poussoir est un interrupteur fugitif qui ne fait contact que tant que tu appuies et s'ouvre quand tu relâches. Un interrupteur (à glissière, à levier ou à bascule) reste dans la position où tu le laisses. Le type de contact se décrit par des abréviations : SPST est un simple marche-arrêt, SPDT un inverseur qui relie une borne commune à l'une de deux sorties, et DPDT inverse deux circuits séparés en même temps. Le bouton 6×6 mm des kits pour breadboard a quatre pattes mais seulement deux contacts distincts : les pattes sont reliées deux à deux à l'intérieur, donc le plus sûr est de le brancher par deux pattes en diagonale. Pour le relier à un Arduino, il faut une résistance de pull-up ou de pull-down afin que la broche ne reste jamais en l'air ; le plus simple est d'activer dans le code, avec INPUT_PULLUP, la résistance interne de 20 à 50 kΩ de l'ATmega328P. La broche lit alors LOW tant que le bouton est enfoncé. Les contacts mécaniques rebondissent pendant quelques millisecondes à l'appui ; on filtre ce phénomène par logiciel en attendant 20 à 50 ms (anti-rebond). Détails dans Brancher un bouton sur Arduino.

Potentiomètre : une résistance réglable

Un potentiomètre est une résistance réglable à trois pattes dont la borne centrale (le curseur) glisse sur une piste résistive quand tu tournes l'axe. La résistance entre les pattes extérieures est fixe (par ex. 10 kΩ), tandis qu'entre la patte centrale et l'une des pattes extérieures elle varie de 0 à 10 kΩ. Si tu relies les pattes extérieures à 5V et GND et la centrale à une entrée analogique, le potentiomètre devient un pont diviseur de tension réglable, et la fonction analogRead() de l'Arduino Uno lit une valeur de 0 à 1023. La lettre sur le boîtier indique la courbe : sur la plupart des modèles, B signifie linéaire et A logarithmique (pour le volume) ; un B10K est un potentiomètre linéaire de 10 kΩ. Les petites versions soudées sur la carte et réglées une fois pour toutes au tournevis s'appellent des trimmers (potentiomètres ajustables) ; on s'en sert pour le contraste d'un écran LCD ou le seuil d'un capteur. Détails et exemples de projets dans Qu'est-ce qu'un potentiomètre ?.

Quartz : le battement de cœur du circuit

Un quartz (résonateur à quartz) est une fine lamelle de quartz qui vibre à une fréquence très stable quand on lui applique une tension ; c'est l'effet piézoélectrique. Son unité est le hertz (Hz), et sa valeur est imprimée en MHz ou en kHz (par ex. 16.000 = 16 MHz). Les microcontrôleurs exécutent leurs instructions au rythme de l'horloge fixée par cette vibration, et la précision des fonctions de temps comme delay() et millis() en dépend. Les cartes Arduino à ATmega328P tournent à 16 MHz (l'Uno R3 d'origine utilise pour cela un résonateur céramique moins cher à la place d'un quartz, tandis que beaucoup de clones ont un quartz en boîtier métallique) ; deux petits condensateurs de 22 pF sont généralement placés entre les pattes du quartz et GND. Sous le capot métallique des modules ESP32 se trouve un quartz de 40 MHz, et le Raspberry Pi Pico en possède un de 12 MHz. Les modules d'horloge utilisent un quartz de 32,768 kHz, car cette valeur vaut 2 puissance 15 : divisée par deux 15 fois, elle donne exactement 1 Hz, soit une impulsion par seconde. C'est ainsi que les modules RTC gardent l'heure exacte même quand l'Arduino est éteint.

Lire les composants et leurs valeurs sur un schéma

Sur un schéma, chaque composant porte deux informations : son repère, formé d'une lettre et d'un numéro (R1, C2, Q1, U3), et sa valeur (220, 100n, BC547). Les mêmes repères sont sérigraphiés sur le circuit imprimé, ce qui permet de retrouver facilement la R7 du schéma sur la carte. Dans les valeurs, la lettre de l'unité remplace souvent la virgule ; ainsi, sur une petite impression, la virgule ne peut pas disparaître et la valeur ne risque pas d'être lue dix fois trop grande. Nous expliquons pas à pas comment lire un schéma dans Comment lire un schéma électronique ; voici les notations que tu verras le plus souvent :

• 4k7, 1M, 2R2, 0R : Respectivement 4,7 kΩ, 1 MΩ et 2,2 Ω ; la lettre R remplace la virgule dans les valeurs en ohms. 0R est une résistance de zéro ohm servant de pont.
• 100n, 104, 0.1u : Les trois désignent la même valeur, 100 nF ; comme le clavier n'a pas de µ, on écrit u à la place.
• 10u/16V : Condensateur électrolytique de 10 µF supportant 16 V ; cette tension doit valoir au moins 1,5 fois la plus haute tension du circuit.
• L1 4u7 : Bobine de 4,7 µH ; comme le repère commence par L, l'unité est le henry.
• D1 1N4007, Q1 BC547, U1 NE555 : Pour les semi-conducteurs, on écrit la référence au lieu d'une valeur ; leurs caractéristiques figurent dans la fiche technique (datasheet) du modèle.
• 472 ou 01C : Ce sont des codes imprimés sur les résistances CMS ; 472 signifie 47 suivi de deux zéros, soit 4,7 kΩ. Pour les codes à lettres, vois Codes des résistances CMS et l'outil Code CMS.

Pratique : huit composants dans un même circuit

Le meilleur moyen d'ancrer la théorie est de faire travailler les composants ensemble. Dans le circuit que nous allons monter, un potentiomètre règle la luminosité d'une LED, une résistance de 220 Ω limite son courant et un bouton allume ou éteint un relais à chaque appui ; le relais est commandé par un transistor 2N2222A piloté via une résistance de base. Une diode 1N4007 branchée en inverse aux bornes de la bobine du relais protège le transistor, et un condensateur de 100 nF entre le curseur du potentiomètre et GND réduit le bruit de la lecture analogique. Inutile pour l'instant de brancher quoi que ce soit sur les contacts du relais ; tu l'entendras cliquer quand il commute. Si c'est ta première breadboard, lis d'abord Qu'est-ce qu'une breadboard ?.

1// Elektronik devre elemanları deneyi / Electronic components experiment
2// Pot -> LED parlaklığı, buton -> transistör + röle / pot -> LED brightness, button -> transistor + relay
3#if defined(ESP32)
4const int POT_PIN = 34;       // ADC1, yalnızca giriş / ADC1, input only
5const int LED_PIN = 18;       // 220 Ω üzerinden LED / LED via 220 Ω
6const int BUTTON_PIN = 4;     // diğer bacak GND'ye / other leg to GND
7const int RELAY_PIN = 23;     // 470 Ω ile 2N2222A beyzine / to the 2N2222A base via 470 Ω
8const int ADC_MAX = 4095;     // 12 bit ADC
9const float VREF = 3.3;
10#else
11const int POT_PIN = A0;
12const int LED_PIN = 9;        // PWM pini (~) / PWM pin (~)
13const int BUTTON_PIN = 2;     // diğer bacak GND'ye / other leg to GND
14const int RELAY_PIN = 7;      // 680 Ω ile 2N2222A beyzine / to the 2N2222A base via 680 Ω
15const int ADC_MAX = 1023;     // 10 bit ADC
16const float VREF = 5.0;
17#endif
18
19bool relayOn = false;
20int lastReading = HIGH;             // son ham okuma / last raw reading
21int stableState = HIGH;             // zıplamadan arınmış durum / debounced state
22unsigned long lastChange = 0;       // son değişim anı / time of last change
23unsigned long lastPrint = 0;
24
25void setup() {
26  pinMode(LED_PIN, OUTPUT);
27  pinMode(RELAY_PIN, OUTPUT);
28  digitalWrite(RELAY_PIN, LOW);           // açılışta röle kapalı / relay off at startup
29  pinMode(BUTTON_PIN, INPUT_PULLUP);      // dahili pull-up direnci / internal pull-up resistor
30  Serial.begin(115200);
31}
32
33void loop() {
34  // 1) Potansiyometre -> LED parlaklığı (PWM) / potentiometer -> LED brightness (PWM)
35  int pot = analogRead(POT_PIN);
36  analogWrite(LED_PIN, map(pot, 0, ADC_MAX, 0, 255));
37
38  // 2) Buton -> röle, 30 ms zıplama filtresi / button -> relay, 30 ms debounce
39  int reading = digitalRead(BUTTON_PIN);
40  if (reading != lastReading) {
41    lastChange = millis();
42    lastReading = reading;
43  }
44  if (millis() - lastChange > 30 && reading != stableState) {
45    stableState = reading;
46    if (stableState == LOW) {             // basıldı / pressed
47      relayOn = !relayOn;
48      digitalWrite(RELAY_PIN, relayOn ? HIGH : LOW);
49    }
50  }
51
52  // 3) Yarım saniyede bir rapor / report every half second
53  if (millis() - lastPrint >= 500) {
54    lastPrint = millis();
55    Serial.print("Pot: ");
56    Serial.print(pot * VREF / ADC_MAX, 2);
57    Serial.print(" V | Röle / relay: ");
58    Serial.println(relayOn ? "AÇIK / ON" : "KAPALI / OFF");
59  }
60}

Le code effectue trois tâches indépendantes dans la même loop(), sans qu'aucune ne fasse attendre les autres. analogRead() lit la tension au curseur du potentiomètre et map() la convertit dans la plage 0–255 ; grâce à la PWM, la luminosité de la LED suit cette valeur. Le bouton est lu avec millis() au lieu de delay() : si la lecture reste identique pendant 30 ms, il s'agit d'un véritable appui et l'état du relais est inversé. Quand la broche passe à HIGH, le 2N2222A se sature, le courant traverse la bobine du relais et le contact bascule sur NO avec un clic ; quand la broche passe à LOW, l'énergie de la bobine s'évacue sans danger par la 1N4007. Grâce à la ligne #if defined(ESP32), le même code se compile sur ESP32 avec ses propres broches et son CAN 12 bits. Ouvre le moniteur série à 115200 bauds pour suivre en direct la tension du potentiomètre et l'état du relais.

Le même circuit avec Raspberry Pi Pico et MicroPython

Pour faire tourner le même circuit sur un Raspberry Pi Pico en MicroPython, câble-le selon la colonne Pico du tableau et alimente la bobine du relais par la broche VBUS, qui fournit le 5 V de l'USB. Comme la fonction read_u16() du Pico renvoie des valeurs de 0 à 65535, la lecture peut être transmise directement à la fonction duty_u16() de la PWM, sans conversion. Si tu enregistres le code sur le Pico sous le nom main.py avec Thonny, il démarre tout seul à chaque mise sous tension. Si tu débutes en MicroPython, commence par Qu'est-ce que le Raspberry Pi Pico ?.

1# Pico: pot -> LED parlaklığı, buton -> transistör + röle / pot -> LED brightness, button -> transistor + relay
2from machine import Pin, ADC, PWM
3import time
4
5pot = ADC(26)                            # GP26 = ADC0, pot orta ucu / pot wiper
6led = PWM(Pin(15))                       # GP15, 220 Ω üzerinden LED / LED via 220 Ω
7led.freq(1000)                           # 1 kHz PWM
8button = Pin(14, Pin.IN, Pin.PULL_UP)    # diğer bacak GND'ye / other leg to GND
9relay = Pin(16, Pin.OUT, value=0)        # 470 Ω ile 2N2222A beyzine / to the 2N2222A base via 470 Ω
10
11relay_on = False
12last = 1
13last_print = time.ticks_ms()
14
15while True:
16    raw = pot.read_u16()                 # 0-65535
17    led.duty_u16(raw)                    # parlaklık / brightness
18
19    now = button.value()
20    if now == 0 and last == 1:           # basıldı / pressed
21        time.sleep_ms(30)                # zıplamayı bekle / wait out the bounce
22        if button.value() == 0:
23            relay_on = not relay_on
24            relay.value(1 if relay_on else 0)
25    last = now
26
27    if time.ticks_diff(time.ticks_ms(), last_print) >= 500:
28        last_print = time.ticks_ms()
29        state = "AÇIK / ON" if relay_on else "KAPALI / OFF"
30        print("Pot: {:.2f} V | Röle / relay: {}".format(raw * 3.3 / 65535, state))
31    time.sleep_ms(5)

Mesurer une résistance et la tension directe d'une LED avec Arduino

Un Arduino peut aussi devenir un petit instrument de mesure pour identifier tes composants. Place la résistance de valeur inconnue entre A1 et GND et une résistance connue de 10 kΩ entre 5V et A1 ; les deux forment un pont diviseur, et la résistance inconnue se calcule avec Rx = 10 kΩ × lecture / (1023 − lecture). La mesure est la plus précise quand la résistance inconnue est proche de la référence (environ 1 à 100 kΩ). Pour la seconde mesure, relie le 5V à l'anode d'une LED à travers une résistance de 220 Ω, sa cathode à GND et son anode aussi à A2 : la tension lue sur A2 est la tension directe de la LED à environ 8 à 14 mA. Ouvre le moniteur série à 9600 bauds, branche une à une des LED de différentes couleurs et compare avec le tableau plus haut.

1// Arduino ile direnç ve LED ileri gerilimi ölçme / Measuring a resistor and an LED's forward voltage with Arduino
2const float VCC = 5.0;          // Uno besleme gerilimi / Uno supply voltage
3const float R_REF = 10000.0;    // 5V ile A1 arası bilinen direnç / known resistor between 5V and A1
4
5void setup() {
6  Serial.begin(9600);
7}
8
9void loop() {
10  int raw = analogRead(A1);     // bilinmeyen direnç A1 ile GND arasında / unknown resistor between A1 and GND
11  if (raw >= 1023) {
12    Serial.println("Direnç takılı değil / no resistor connected");
13  } else {
14    float rx = R_REF * raw / (1023.0 - raw);   // gerilim bölücü formülü / voltage divider formula
15    Serial.print("R = ");
16    Serial.print(rx, 0);
17    Serial.println(" ohm");
18  }
19
20  float vf = analogRead(A2) * VCC / 1023.0;    // 5V - 220 Ω - A2 - LED - GND
21  Serial.print("LED Vf = ");
22  Serial.print(vf, 2);
23  Serial.println(" V");
24  Serial.println();
25  delay(1000);
26}

Tester les composants au multimètre

Quand un circuit ne marche pas, le coupable est souvent un composant de mauvaise valeur ou défectueux. Le multimètre te permet de tester chaque pièce en quelques secondes ; mesure toujours hors tension et, si possible, composant retiré du circuit, car les autres pièces faussent la lecture. Nous expliquons en détail l'usage de chaque calibre dans Comment utiliser un multimètre.

Idées de projets avec ces composants

• Feu tricolore : Ton premier projet à sorties séquentielles, avec trois LED et trois résistances de 220 Ω ; les étapes sont dans Feu tricolore avec Arduino.
• Veilleuse automatique : Un pont diviseur formé d'une LDR et d'une résistance de 10 kΩ détecte l'obscurité, et un transistor allume un ruban LED 12 V.
• Clignotant sans Arduino : Une LED qui clignote une fois par seconde avec un NE555, deux résistances et un condensateur ; modifie R et C pour régler la fréquence.
• Chenillard : Pilote huit LED avec seulement trois broches grâce à un 74HC595 (Chenillard avec Arduino).
• Voltmètre numérique : Mesure des tensions supérieures à la limite de 5 V de l'Arduino avec un pont diviseur à deux résistances (Fabriquer un voltmètre avec Arduino).
• Prise connectée : Allume une lampe depuis ton téléphone avec un relais et un ESP32 ; les règles de sécurité sont dans Qu'est-ce qu'un module relais ?.

Erreurs fréquentes et solutions

Apprendre les composants électroniques de base, c'est comme apprendre l'alphabet d'une langue : une fois que tu sais ce que font la résistance, le condensateur, la diode, le transistor et les autres, chaque nouveau schéma et chaque module deviennent plus faciles à comprendre. Pour la suite, tu peux lire un à un les articles détaillés de chaque composant, passer aux calculs de circuits avec les lois de Kirchhoff et consulter le guide du kit de démarrage Arduino pour choisir les pièces à acheter. Dans l'application BlueGrays, tu peux suivre pas à pas, avec schémas et code, des projets qui utilisent ces composants : faire clignoter une LED, commander une LED avec un bouton, une veilleuse à LDR, un servo piloté par potentiomètre ou une lampe secteur commandée par relais.