MOSFET Arduino : piloter ruban LED, moteur et pompe en 12 V

Un montage MOSFET avec Arduino est le moyen le plus efficace de commuter en toute sécurité des charges de plusieurs ampères, comme un ruban LED 12 V, un moteur à courant continu, une pompe à eau ou une serrure à solénoïde, à partir de broches Arduino qui ne fournissent qu'environ 20 mA. Le MOSFET est un interrupteur électronique commandé en tension : applique 5 V sur sa grille (gate) et le chemin entre drain et source devient presque un fil sans résistance ; à 0 V, il est complètement bloqué. Un MOSFET logic level bien choisi ne fait que tiédir en conduisant 3 A sans dissipateur.

Dans cet article, tu vas apprendre comment fonctionne un MOSFET, pourquoi tous les MOSFET ne conviennent pas à l'Arduino (la différence entre IRLZ44N et IRF520), à quoi servent la résistance de grille, la résistance de pull-down et la diode de roue libre, et comment régler vitesse et luminosité en PWM. Plus bas, tu trouveras du code prêt à l'emploi pour un ruban LED, un moteur à courant continu, une pompe et une serrure à solénoïde en 12 V, des exemples pour ESP32 et Raspberry Pi Pico, le calcul de l'échauffement et du dissipateur, ainsi qu'un tableau comparatif MOSFET, transistor et relais.

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

Le MOSFET (Metal Oxide Semiconductor Field Effect Transistor) est un transistor à effet de champ à trois broches : la grille (gate), le drain et la source. La grille est isolée du reste du composant par une fine couche d'oxyde ; aucun courant permanent n'y circule et elle se comporte comme un petit condensateur. Quand la tension entre grille et source (VGS) dépasse un certain seuil, un canal conducteur se forme entre drain et source et le courant de la charge le traverse. Un transistor bipolaire classique se commande par le courant de base, alors que le MOSFET se commande en tension ; la broche Arduino ne fournit du courant que pendant les quelques microsecondes nécessaires pour charger et décharger la grille.

Dans les projets Arduino, on utilise presque toujours un MOSFET canal N placé du côté négatif (GND) de la charge : c'est la commutation côté bas (low-side). Le plus de la charge va directement au plus de l'alimentation externe, son moins va au drain du MOSFET, et la source est reliée au GND. Ainsi, la tension grille-source est tout simplement la tension de la broche Arduino. Voici les valeurs de la fiche technique à vérifier :

MOSFET logic level : IRLZ44N, IRF520 et les autres

L'erreur la plus fréquente consiste à regarder VGS(th) et à se dire « le seuil est de 4 V, l'Arduino donne 5 V, donc ça marche ». La tension de seuil est le point où le canal laisse passer à peine 250 µA ; pour que le MOSFET conduise plusieurs ampères avec une faible résistance, la tension de grille doit être nettement au-dessus. La bonne question est : à quelle VGS la fiche technique garantit-elle le RDS(on) ? S'il est donné pour 4,5 V ou 5 V, le MOSFET devient pleinement passant avec un Arduino 5 V : c'est un MOSFET logic level (à niveau logique). S'il n'est donné que pour 10 V, c'est un MOSFET standard qu'une broche Arduino ne rend passant qu'à moitié. Dans la nomenclature d'International Rectifier (aujourd'hui Infineon), les références qui commencent par IRL (IRLZ44N, IRLB8721, IRL540N) sont logic level, tandis que l'IRFZ44N, l'IRF520 et l'IRF540N sont standard.

La règle à retenir est simple : pour les cartes 5 V comme l'Uno, la Nano et la Mega, choisis un MOSFET dont le RDS(on) est spécifié à 4,5 V ou 5 V. Sur les cartes 3,3 V comme l'ESP32 et la Pico, c'est un peu plus délicat, car les fiches techniques des MOSFET TO-220 courants comme l'IRLZ44N et l'IRLB8721 ne garantissent aucune valeur à 3,3 V ; on y reviendra dans la partie ESP32. Ne choisis pas non plus d'après le boîtier : l'IRLZ44N et l'IRFZ44N ont le même boîtier et un marquage presque identique, mais cette seule lettre (L) change tout pour un Arduino. Tu peux vérifier l'ordre des broches avec l'outil Brochage des transistors ; sur un MOSFET TO-220, face imprimée vers toi, l'ordre de gauche à droite est grille, drain, source (G-D-S) et la languette métallique est reliée au drain.

Câblage MOSFET Arduino : résistance de grille, pull-down et masse commune

Le montage de base comporte cinq éléments : le MOSFET, une résistance de grille, une résistance de pull-down, une diode de roue libre pour les charges inductives et une alimentation externe. Le tableau ci-dessous donne le câblage pour trois cartes ; la charge d'exemple est un ruban LED ou un moteur 12 V. Tous les codes de l'article utilisent ces broches.

La résistance de grille (100 à 220 Ω) limite le courant instantané tiré de la broche pendant la charge de la capacité de grille. La capacité d'entrée de l'IRLZ44N vaut environ 1700 pF ; sans résistance, la broche voit presque un court-circuit à chaque commutation et la ligne de grille se met à osciller (ringing). Avec 220 Ω, le courant de crête ne dépasse pas 5 / 220 ≈ 23 mA, et la grille se charge quand même en quelques microsecondes. La résistance de pull-down (10 kΩ) empêche la grille de rester flottante tant que la broche est en entrée : au démarrage, lors d'un reset ou pendant le téléversement. Une grille flottante peut se charger à moitié à cause des parasites ; le MOSFET reste alors à moitié passant, le moteur tourne tout seul et le MOSFET chauffe très vite. Place la pull-down côté MOSFET, directement entre grille et source : ainsi le MOSFET reste bloqué même si le fil de commande se débranche. Les deux résistances forment un petit pont diviseur, mais l'effet est négligeable : la grille reçoit 5 × 10000 / 10220 ≈ 4,89 V.

Diode de roue libre : pourquoi elle est indispensable avec moteur, pompe et solénoïde

Les charges inductives comme les moteurs, pompes, solénoïdes, bobines de relais et ventilateurs s'opposent à une coupure brutale du courant. Dès que le MOSFET se bloque, l'énergie magnétique de la bobine se libère sous forme d'une surtension sur le drain, bien au-dessus de la tension d'alimentation (V = L × di/dt). Cette pointe peut dépasser la VDS maximale du MOSFET et le détruire, ou créer des parasites qui font redémarrer l'Arduino. La solution : une diode branchée en inverse aux bornes de la charge, cathode (côté bague) vers le plus de l'alimentation, anode vers le drain. En fonctionnement normal, la diode est polarisée en inverse et ne conduit pas ; quand le MOSFET se bloque, le courant de la bobine circule dans la diode et s'éteint en douceur. La diode interne du MOSFET ne remplit pas ce rôle, car elle est placée entre source et drain, pas aux bornes de la charge. Pour aller plus loin, lis Qu'est-ce qu'une diode ?.

Pas à pas : faire varier un ruban LED 12 V avec Arduino

1. Rassemble le matériel : Arduino Uno, IRLZ44N, résistances de 220 Ω et 10 kΩ, un potentiomètre de 10 kΩ, un ruban LED 12 V et un adaptateur 12 V capable de fournir le courant du ruban.
2. Calcule le courant du ruban : un ruban 5050 à 60 LED/m consomme environ 14,4 W par mètre, soit 1,2 A sous 12 V. Deux mètres demandent 2,4 A ; prends un adaptateur avec 20 % de marge (au moins 3 A).
3. Place le MOSFET : relie la source de l'IRLZ44N au rail GND, sa grille à D9 via 220 Ω, et mets 10 kΩ entre grille et GND.
4. Branche la charge : le fil +12V du ruban va au plus de l'adaptateur, le fil négatif au drain du MOSFET. Les contacts d'une breadboard supportent environ 1 A ; au-delà, utilise des borniers à vis ou soude les fils de la charge.
5. Branche le potentiomètre : broches extérieures sur 5V et GND, curseur sur A0.
6. Relie les masses et teste : connecte le moins de l'adaptateur au GND de l'Arduino, téléverse le code, puis branche l'adaptateur.

1// IRLZ44N ile 12 V LED şerit parlaklık kontrolü / 12 V LED strip dimming with an IRLZ44N
2const int STRIP_PIN = 9;    // PWM pini, 220 Ω ile gate'e / PWM pin, to the gate via 220 Ω
3const int POT_PIN = A0;     // potansiyometre orta ucu / potentiometer wiper
4
5void setup() {
6  pinMode(STRIP_PIN, OUTPUT);
7  digitalWrite(STRIP_PIN, LOW);             // açılışta kapalı / off at startup
8  Serial.begin(9600);
9}
10
11void loop() {
12  int pot = analogRead(POT_PIN);            // 0–1023
13  float x = pot / 1023.0;                   // 0.0–1.0
14  int duty = (int)(x * x * 255.0 + 0.5);    // basit gama düzeltmesi / simple gamma correction
15  analogWrite(STRIP_PIN, duty);             // D9'da 490 Hz PWM / 490 Hz PWM on D9
16  Serial.print("Parlaklik / Brightness: %");
17  Serial.println(duty * 100 / 255);
18  delay(50);
19}

analogWrite() génère sur la broche 9 un signal PWM qui s'allume et s'éteint environ 490 fois par seconde ; 0 correspond à complètement éteint et 255 à complètement allumé. Les broches PWM de l'Uno sont 3, 5, 6, 9, 10 et 11 ; les broches 5 et 6 tournent à environ 980 Hz. Comme l'œil ne perçoit pas la luminosité de façon linéaire, mettre au carré la valeur du potentiomètre (une correction gamma simple) donne un réglage bien plus doux dans les faibles niveaux. Tu trouveras le fonctionnement du PWM en détail dans Qu'est-ce que le PWM ?. Calculons aussi l'échauffement : à 2,4 A, l'IRLZ44N dissipe P = I² × RDS(on) = 2,4² × 0,025 ≈ 0,14 W, il est donc à peine tiède au toucher. Pendant ce temps, le ruban LED consomme 28,8 W : la perte dans le MOSFET représente moins d'un pour cent du total.

Régler la vitesse d'un moteur ou d'une pompe en PWM

Un moteur ou une pompe se pilote avec le même montage que le ruban LED ; la seule différence est la diode de roue libre à ajouter aux bornes de la charge. Les moteurs ont aussi un courant de démarrage : un moteur à l'arrêt peut appeler 3 à 8 fois son courant nominal au premier instant. Dimensionne donc le MOSFET et l'alimentation pour le courant de blocage du moteur, et applique un démarrage progressif au lieu de passer d'un coup de 0 à 255. Les mini pompes submersibles consomment environ 0,1 à 0,3 A sous 3 à 6 V, les pompes à membrane 12 V généralement 0,5 à 1 A ; l'IRLZ44N gère les deux avec beaucoup de marge. Alimente toutefois une mini pompe avec une source à sa propre tension (5 à 6 V), pas avec l'adaptateur 12 V ; le montage du MOSFET reste le même. Pour choisir une pompe et monter un arrosage, lis Mini pompe à eau.

1// IRLZ44N ile motor/pompa hız kontrolü ve yumuşak kalkış / Motor or pump speed control with soft start (IRLZ44N)
2const int MOTOR_PIN = 9;     // 220 Ω ile gate'e / to the gate via 220 Ω
3const int POT_PIN = A0;      // hız ayarı / speed setting
4const int MIN_DUTY = 60;     // bunun altında motor yalnızca vızıldar / below this the motor only hums
5
6int current = 0;             // şu anki PWM değeri / current PWM value
7
8void setup() {
9  pinMode(MOTOR_PIN, OUTPUT);
10  digitalWrite(MOTOR_PIN, LOW);
11  // TCCR1B = (TCCR1B & 0b11111000) | 0x02;   // isteğe bağlı: D9/D10 PWM ≈3,9 kHz / optional: D9/D10 PWM ≈3.9 kHz
12}
13
14void loop() {
15  int target = map(analogRead(POT_PIN), 0, 1023, 0, 255);
16  if (target < MIN_DUTY) target = 0;         // çok düşük hızda tamamen durdur / stop completely at very low speed
17
18  if (current < target) current++;           // yavaşça hızlan / speed up gently
19  else if (current > target) current--;      // yavaşça yavaşla / slow down gently
20
21  analogWrite(MOTOR_PIN, current);
22  delay(8);                                  // 0→255 yaklaşık 2 s / 0→255 takes about 2 s
23}

Le code se rapproche d'un pas de la vitesse cible lue sur le potentiomètre toutes les 8 ms : le moteur passe ainsi de 0 à pleine vitesse en 2 secondes environ et le courant de démarrage ne fait pas s'effondrer l'alimentation. MIN_DUTY est la plus petite valeur PWM à laquelle le moteur commence à tourner ; trouve-la en testant ton propre moteur. Le PWM à 490 Hz produit un sifflement audible dans le moteur. La ligne TCCR1B en commentaire porte la fréquence de D9 et D10 à environ 3,9 kHz ; la bibliothèque Servo utilise aussi le Timer1, donc n'utilise pas les deux ensemble. Monter encore plus haut est tentant, mais comme une broche Arduino met quelques microsecondes à charger la grille d'un gros MOSFET à chaque commutation, les pertes de commutation augmentent avec la fréquence : vers 20 kHz, même un moteur de 2 A peut provoquer plus de 1 W de pertes dans le MOSFET. À ces fréquences, on utilise un driver de grille comme le TC4427.

Serrure à solénoïde et charges à usage bref

Les serrures de porte à solénoïde 12 V consomment 0,5 à 1 A, et la plupart ne sont pas prévues pour rester alimentées en continu : si on les laisse activées longtemps, la bobine chauffe. Le code doit donc n'ouvrir la serrure que quelques secondes. Comme le solénoïde est commuté en tout ou rien et non en PWM, une 1N4007 suffit comme diode de roue libre. Dans l'exemple ci-dessous, un appui sur le bouton de D2 ouvre la serrure pendant 3 secondes, puis elle se referme même si le bouton reste enfoncé. Pour la déclencher avec un lecteur de badges RFID ou un clavier matriciel, il suffit de changer la condition du if ; les types de serrures et leur comportement en cas de coupure de courant sont expliqués dans Serrure à solénoïde.

1// Butonla 3 saniyelik solenoid kilit açma / Open a solenoid lock for 3 seconds with a button
2const int LOCK_PIN = 9;                 // 220 Ω ile IRLZ44N gate'ine / to the IRLZ44N gate via 220 Ω
3const int BUTTON_PIN = 2;               // buton D2 ile GND arasında / button between D2 and GND
4const unsigned long OPEN_MS = 3000;     // kilidin açık kalma süresi / how long the lock stays open
5
6void setup() {
7  pinMode(LOCK_PIN, OUTPUT);
8  digitalWrite(LOCK_PIN, LOW);          // kilit kapalı / locked
9  pinMode(BUTTON_PIN, INPUT_PULLUP);    // basılınca LOW / LOW when pressed
10}
11
12void loop() {
13  if (digitalRead(BUTTON_PIN) == LOW) {
14    digitalWrite(LOCK_PIN, HIGH);       // solenoid çeker, kilit açılır / solenoid pulls in, lock opens
15    delay(OPEN_MS);
16    digitalWrite(LOCK_PIN, LOW);        // bobini soğumaya bırak / let the coil cool down
17    while (digitalRead(BUTTON_PIN) == LOW) {}   // buton bırakılana kadar bekle / wait until released
18    delay(50);                          // buton zıplamasını süz / debounce
19  }
20}

Pourquoi le module IRF520 ne suffit pas en 5 V

Le module MOSFET IRF520, très courant dans les kits de démarrage, est une petite carte à borniers vendue avec des valeurs comme « 24 V, 5 A ». À côté du MOSFET, on trouve quelques résistances et une LED témoin ; la plupart des versions n'ont pas de diode de roue libre. Le problème vient du MOSFET lui-même : l'IRF520 est un MOSFET standard avec un seuil de 2 à 4 V, et son RDS(on) de 0,27 Ω n'est garanti que pour VGS = 10 V. D'après les courbes typiques de la fiche technique, avec 5 V sur la grille, l'IRF520 commence à limiter le courant vers 2 A ; sur un exemplaire à seuil élevé, cette limite descend sous 1 A. Le MOSFET ne se comporte alors plus comme un interrupteur, mais comme une résistance variable.

Prenons un exemple : tu pilotes avec le module IRF520 un moteur 12 V qui consomme 2 A. Si 1,5 V chute aux bornes du MOSFET, il dissipe P = 1,5 × 2 = 3 W. Avec une résistance thermique de 62 °C/W pour un boîtier TO-220 sans dissipateur, cela représente environ 186 °C au-dessus de l'ambiante ; le MOSFET surchauffe vite et lâche, ou au mieux le moteur tourne lentement. Les 5 A indiqués sur le module ne valent qu'avec 10 V sur la grille. Voici les bornes du module et leur câblage :

• Remplace le MOSFET : dessoude l'IRF520 du module et soude à sa place un IRLZ44N au même brochage (G-D-S) ; la carte fonctionne pareil, mais devient pleinement passante en 5 V.
• Prends un module logic level : les modules équipés du MOSFET AOD4184A (D4184) offrent un RDS(on) de 9,5 mΩ maximum à 4,5 V et fonctionnent sans souci avec un Arduino 5 V.
• Commande la grille avec une tension plus élevée : un driver de grille comme le TC4427 alimenté en 12 V transforme le signal 5 V ou 3,3 V de l'Arduino en 12 V sur la grille, et l'IRF520 atteint ses vraies performances. Respecte la limite de tension de grille : ±20 V pour l'IRF520, ±16 V pour l'IRLZ44N.
• Garde-le pour les petites charges : en dessous de 1 A (un ruban LED court, une mini pompe), le module IRF520 fonctionne en 5 V avec un échauffement acceptable ; si le MOSFET devient trop chaud pour être touché, réduis la charge.

MOSFET avec ESP32 et Raspberry Pi Pico (3,3 V)

Comme les broches de l'ESP32 et de la Pico ne fournissent que 3,3 V, le choix du MOSFET compte encore plus. La fiche technique de l'IRLZ44N ne spécifie le RDS(on) que jusqu'à 4 V ; d'après les courbes typiques, il laisse encore passer plusieurs ampères vers 3 V, mais ce n'est pas garanti pour un exemplaire à seuil élevé. Règle pratique : sur une carte 3,3 V, utilise l'IRLZ44N ou l'IRLB8721 jusqu'à 2–3 A, mesure la tension drain-source au multimètre pendant que la charge fonctionne et calcule la puissance dissipée avec P = VDS × I ; reste sous 1 W pour un TO-220 sans dissipateur. Pour des courants plus forts, utilise un driver qui porte la grille à 5–12 V, et pour les petites charges un AO3400A, dont le RDS(on) est garanti à 2,5 V. Sur l'ESP32, choisis pour le MOSFET des broches comme GPIO 25, 26, 27, 32 ou 33 : les GPIO 0, 2, 5, 12 et 15 sont des broches de démarrage (strapping), et les GPIO 1, 3, 5, 14 et 15 peuvent passer brièvement à HIGH ou sortir du PWM au boot. Sur ces broches, la charge peut s'allumer toute seule au démarrage, ou la pull-down peut perturber le boot.

Le code ESP32 ci-dessous démarre une pompe via le MOSFET avec un démarrage progressif quand le capteur d'humidité du sol signale une terre sèche, arrose pendant 5 secondes puis l'arrête en douceur. Pour le PWM, il utilise les fonctions ledcAttach() et ledcWrite() du core ESP32 Arduino 3.x ; les anciennes versions 2.x utilisaient à la place ledcSetup() et ledcAttachPin(), et leur ledcWrite() prenait un numéro de canal au lieu d'une broche. Les lignes #if du code choisissent les bons appels selon le core installé, si bien qu'il compile avec les deux versions. Comme la grille est commandée en 3,3 V à travers 100 Ω, la fréquence reste à 1 kHz pour que les pertes de commutation soient négligeables. Mesure les valeurs du capteur en terre sèche et humide, comme dans Capteur d'humidité du sol, et règle le seuil DRY_LEVEL en conséquence.

1// ESP32 + MOSFET ile otomatik sulama pompası / Automatic watering pump with ESP32 + MOSFET
2const int PUMP_PIN = 25;                 // 100 Ω ile gate'e, gate–GND 10 kΩ / to the gate via 100 Ω, 10 kΩ gate–GND
3const int SOIL_PIN = 34;                 // toprak nem sensörü, ADC1 / soil moisture sensor, ADC1
4const int DRY_LEVEL = 2800;              // üstü kuru sayılır, kalibre et / above this counts as dry, calibrate
5const unsigned long WATER_MS = 5000;     // sulama süresi / watering time
6
7void pumpWrite(int duty) {               // 0–255 PWM, iki çekirdek sürümünde / on both core versions
8#if ESP_ARDUINO_VERSION_MAJOR >= 3
9  ledcWrite(PUMP_PIN, duty);             // 3.x: pin numarasıyla / 3.x: by pin number
10#else
11  ledcWrite(0, duty);                    // 2.x: kanal 0 ile / 2.x: by channel 0
12#endif
13}
14
15void pumpRamp(int from, int to) {        // yumuşak hız değişimi / smooth speed change
16  int step = (to > from) ? 5 : -5;
17  for (int d = from; d != to; d += step) {
18    pumpWrite(d);
19    delay(20);
20  }
21  pumpWrite(to);
22}
23
24void setup() {
25  Serial.begin(115200);
26#if ESP_ARDUINO_VERSION_MAJOR >= 3
27  ledcAttach(PUMP_PIN, 1000, 8);         // 1 kHz, 8 bit (0–255); çekirdek 3.x / core 3.x
28#else
29  ledcSetup(0, 1000, 8);                 // çekirdek 2.x: kanal 0 / core 2.x: channel 0
30  ledcAttachPin(PUMP_PIN, 0);
31#endif
32  pumpWrite(0);                          // pompa kapalı / pump off
33}
34
35void loop() {
36  int soil = analogRead(SOIL_PIN);       // 0–4095
37  Serial.printf("Toprak / Soil: %d\n", soil);
38  if (soil > DRY_LEVEL) {
39    pumpRamp(0, 255);                    // yaklaşık 1 s'de tam hıza / full speed in about 1 s
40    delay(WATER_MS);
41    pumpRamp(255, 0);                    // yumuşakça dur / stop gently
42    delay(60000);                        // suyun toprağa yayılmasını bekle / let the water soak in
43  }
44  delay(1000);
45}

Sur la Raspberry Pi Pico, la classe machine.PWM suffit pour générer du PWM en MicroPython ; duty_u16() accepte une valeur de 0 à 65535. Le code ci-dessous donne à un ruban LED 12 V branché sur le MOSFET de GP15 un doux effet de « respiration ». Comme dans l'exemple Arduino, la valeur est mise au carré pour une correction gamma simple, afin que le passage du sombre au clair paraisse naturel. Les broches de la Pico fournissent elles aussi 3,3 V : les règles de choix du MOSFET données pour l'ESP32 s'appliquent ici aussi.

1# Pico + MOSFET ile 12 V LED şerit nefes efekti / 12 V LED strip breathing effect with Pico + MOSFET
2from machine import Pin, PWM
3import time
4
5strip = PWM(Pin(15))          # 100 Ω ile gate'e, gate–GND 10 kΩ / to the gate via 100 Ω, 10 kΩ gate–GND
6strip.freq(1000)              # 1 kHz: titreme görünmez / 1 kHz: no visible flicker
7
8def set_level(x):             # x: 0.0–1.0
9    strip.duty_u16(int(x * x * 65535))   # basit gama düzeltmesi / simple gamma correction
10
11while True:
12    for i in range(101):                 # yavaşça aydınlan / fade in
13        set_level(i / 100)
14        time.sleep_ms(20)
15    for i in range(100, -1, -1):         # yavaşça sön / fade out
16        set_level(i / 100)
17        time.sleep_ms(20)
18    time.sleep_ms(500)

Échauffement, calcul de puissance et choix du dissipateur

L'échauffement d'un MOSFET pleinement passant se calcule avec une seule formule : P = I² × RDS(on). Garde deux points en tête. D'abord, le RDS(on) augmente avec la température ; pour l'IRLZ44N, il vaut à 100 °C environ 1,5 fois sa valeur à 25 °C, il est donc plus réaliste de calculer avec 38 mΩ plutôt que 25 mΩ. Ensuite, le boîtier ne peut évacuer qu'une quantité limitée de chaleur dans l'air : la résistance thermique d'un TO-220 sans dissipateur (RθJA) est de 62 °C/W, chaque watt fait donc monter la puce de 62 °C au-dessus de l'ambiante. Le tableau montre comment chauffe l'IRLZ44N avec 5 V sur la grille et sans dissipateur :

Le dissipateur se dimensionne avec la même logique : Tj = Tambiante + P × (RθJC + RθCS + RθSA). Si 3,8 W sont dissipés à 10 A et que tu veux garder la puce à 100 °C dans une pièce à 30 °C, la résistance thermique totale ne doit pas dépasser (100 − 30) / 3,8 ≈ 18 °C/W. La résistance jonction-boîtier de l'IRLZ44N vaut 1,4 °C/W et un contact avec pâte thermique environ 0,5 °C/W : le dissipateur lui-même doit donc faire 16 °C/W au maximum, ce qui correspond à un petit dissipateur TO-220 à ailettes. La languette métallique du MOSFET est reliée au drain ; si tu montes plusieurs MOSFET sur le même dissipateur, intercale un isolant en mica ou en silicone et une rondelle isolante en plastique pour la vis. La deuxième source de chaleur en PWM, ce sont les pertes de commutation ; négligeables à 490 Hz, elles augmentent avec la fréquence.

MOSFET, transistor ou relais : comparatif

En résumé : pour commander une charge continue rapidement, en silence et en PWM, prends un MOSFET ; pour allumer une lampe ou une prise sur le secteur 230 V, prends un module relais. Pour de petites charges de quelques centaines de milliampères, un transistor bipolaire bon marché fait aussi l'affaire ; le calcul de la résistance de base est expliqué dans Qu'est-ce qu'un transistor ?. Si le même moteur doit tourner dans les deux sens, un seul MOSFET ne suffit pas : il faut un pont en H à quatre interrupteurs, donc un driver moteur L298N ou un module pont en H à MOSFET.

Idées de projets avec un MOSFET

• Éclairage automatique de placard ou d'escalier : quand un capteur PIR détecte un mouvement, allume en douceur un ruban LED 12 V en PWM et éteins-le après un moment.
• Lampe crépusculaire : avec une LDR, augmente progressivement la luminosité du ruban à mesure que la pièce s'assombrit.
• Ventilateur intelligent : accélère un ventilateur de PC 12 V à mesure que la température mesurée par un DHT11 augmente.
• Arrosage automatique des plantes : arrose tes pots tout seul avec un capteur d'humidité du sol et une pompe pilotée par MOSFET ; prévois un MOSFET par pompe.
• Serrure à badge : ouvre une serrure à solénoïde 12 V pendant 3 secondes quand un RFID RC522 lit le bon badge.
• Serre connectée : construis une serre intelligente qui gère ventilateur, pompe et chauffage avec des MOSFET séparés.

Erreurs fréquentes et solutions

Le MOSFET est la façon la plus propre de relier un Arduino à des charges puissantes du monde réel : avec un composant logic level bien choisi, une résistance de grille, une pull-down et une diode pour les charges inductives, tu commandes n'importe quelle charge continue, du ruban LED à la pompe, en silence et avec un excellent rendement. Dans l'application BlueGrays, tu trouveras des projets comme la variation de LED en PWM, le réglage de luminosité au potentiomètre, une station d'arrosage intelligente ou un éclairage intelligent, avec schémas et code pas à pas, pour transformer tout de suite le montage MOSFET appris ici en vrai projet.