Guides · 11 min de lecture

Contrôle de ventilateur Arduino : PWM selon la température

Contrôle de ventilateur Arduino : pilote un ventilateur 2 fils avec un MOSFET, un 4 broches en PWM 25 kHz, lis le RPM. Code Uno, ESP32, Pico.

Le contrôle de ventilateur Arduino est la façon la plus pratique de régler automatiquement la vitesse d'un ventilateur selon la température : un capteur mesure l'ambiance, l'Arduino convertit cette valeur en vitesse et pilote le ventilateur avec un signal PWM. Ainsi, le ventilateur tourne lentement et en silence quand il fait frais, accélère quand la chaleur monte et ne fait pas de bruit inutile à plein régime. Caissons d'imprimante 3D, boîtiers d'alimentation, couvercles d'aquarium, serres et boîtiers de PC sont les usages les plus courants.

Dans ce guide, nous voyons deux méthodes : piloter un ventilateur simple à 2 fils en PWM avec un MOSFET logic-level, et gérer un ventilateur PC 4 broches par sa propre ligne de commande en PWM 25 kHz tout en lisant sa vitesse sur la sortie tacho (tachymètre). Tu verras pas à pas les codes pour Arduino Uno, ESP32 et Raspberry Pi Pico, la courbe température-vitesse avec map, l'hystérésis et les astuces pour un ventilateur vraiment silencieux.

Capteur de température numérique DS18B20
DS18B20 : capteur de température numérique à un seul fil de données, précision ±0,5 °C. C'est lui qui mesure la température dans ce contrôle de ventilateur.

Qu'est-ce que le contrôle de ventilateur avec Arduino et comment ça marche ?

Les ventilateurs d'ordinateur sont des moteurs DC sans balais : un petit circuit de commande interne alimente les bobines à tour de rôle. Il y a deux façons de changer la vitesse : baisser la tension appliquée ou allumer et éteindre la tension très rapidement. La seconde est le PWM, le langage naturel des microcontrôleurs. Avec un rapport cyclique de 50 %, le ventilateur reçoit de l'énergie la moitié du temps ; l'inertie de l'hélice lisse ces impulsions et il tourne à peu près à mi-vitesse. Tu trouveras les bases du PWM dans l'article Qu'est-ce que le PWM ?. Le plus important est le nombre de fils du ventilateur, car c'est lui qui détermine le montage.

CaractéristiqueVentilateur 2 filsVentilateur 3 filsVentilateur PWM 4 broches
FilsRouge (+), noir (GND)+, GND, tacho jaune ou vertGND, +12 V, tacho, PWM
Contrôle de vitessePWM sur l'alimentation via MOSFETPWM sur l'alimentation ou baisse de tensionLigne PWM séparée, 25 kHz
Lecture du régimeNonOui (perturbée pendant le PWM)Oui, indépendante du PWM
Composants en plusMOSFET, diode, résistancesMOSFET, diode, résistancesSeulement une pull-up de 10 kΩ
Vitesse minimaleS'arrête sous 30–40 % de rapport cycliqueS'arrête sous 30–40 % de rapport cycliqueTourne en général à 20–30 % du régime, ne s'arrête pas
Usage typiqueVentilateurs de boîtier et d'appareilsAnciens ventilateurs de PCVentilateurs de PC et de processeurs modernes

Piloter un ventilateur 2 fils en PWM avec un MOSFET

Une broche d'Arduino délivre 5 V et peut fournir en toute sécurité environ 20 mA au maximum ; elle ne peut pas alimenter directement un ventilateur 12 V qui consomme 0,1–0,3 A. On place donc un MOSFET à canal N utilisé comme interrupteur côté bas (low-side) : le fil rouge du ventilateur va au +12 V externe, le fil noir au drain (D) du MOSFET, et la source (S) à la masse. La broche Arduino commande la grille (G) via une résistance de 220 Ω. La résistance de 10 kΩ entre grille et source empêche le ventilateur de démarrer tout seul pendant l'allumage ou le reset de l'Arduino. Une diode montée en inverse aux bornes du ventilateur (cathode côté +12 V) absorbe la surtension générée par la bobine à la coupure. Le fonctionnement du MOSFET est détaillé dans Utiliser un MOSFET avec Arduino.

ComposantValeur conseilléeRôle
MOSFET canal N (Uno, 5 V)IRLZ44N, IRL540N, IRLB8721Coupe et rétablit la masse du ventilateur en PWM
MOSFET canal N (ESP32/Pico, 3,3 V)AO3400, IRLML2502Conduit pleinement avec une tension de grille de 3,3 V
Résistance de grille100–220 ΩLimite le courant de la broche, réduit les oscillations du signal
Pull-down de grille10 kΩ (entre grille et source)Garde le MOSFET bloqué au démarrage
Diode de roue libre1N5819 (Schottky) ou 1N4007Absorbe la surtension générée par la bobine
AlimentationAdaptateur 12 V, au moins 2 fois le courant du ventilateurAlimente le ventilateur indépendamment de l'Arduino
L'erreur la plus fréquente est d'utiliser des MOSFET non logic-level comme l'IRFZ44N ou l'IRF540N. Ces composants sont conçus pour une tension de grille de 10 V ; à 5 V ils restent à moitié ouverts, le ventilateur tourne lentement et le MOSFET chauffe. Choisis ceux qui ont la lettre L dans leur nom (IRLZ44N, IRL540N). De plus, la masse de l'Arduino et celle de l'adaptateur 12 V doivent absolument être reliées ; sans masse commune, le signal PWM n'a pas de référence et le ventilateur ne tourne pas ou se comporte de façon aléatoire.

Tableau de branchement : Arduino Uno, ESP32 et Pico

Le tableau ci-dessous couvre à la fois le branchement direct du ventilateur 4 broches et la grille du MOSFET pour un ventilateur 2 fils ; dans les deux montages, le PWM sort de la même broche. Comme capteur de température, nous utilisons le DS18B20, qui fonctionne sur toutes les cartes et existe en version étanche ; les détails sont dans Capteur de température DS18B20.

ConnexionArduino UnoESP32Raspberry Pi Pico
PWM du ventilateur (bleu) ou grille du MOSFETD9GPIO 25GP16
Tacho du ventilateur (vert) + pull-up 10 kΩD2 (pull-up vers 5V)GPIO 26 (pull-up vers 3V3)GP17 (pull-up vers 3V3)
Données DS18B20 + pull-up 4,7 kΩD4GPIO 4GP15
DS18B20 VDD5V3V33V3
Ventilateur +12 V (jaune)Adaptateur 12 V externeAdaptateur 12 V externeAdaptateur 12 V externe
Ventilateur GND (noir)GND (commun avec l'adaptateur)GND (commun avec l'adaptateur)GND (commun avec l'adaptateur)
Ne relie jamais la résistance pull-up de la ligne tacho au 12 V. La sortie tacho est à collecteur ouvert : le ventilateur ne fait que tirer la ligne vers la masse, et c'est ta pull-up qui définit le niveau haut. Si tu la relies au 12 V, tu forces l'entrée de l'Arduino et tu peux griller instantanément la broche 3,3 V de l'ESP32 ou du Pico. Relie toujours la pull-up à la tension logique de la carte (5 V pour l'Uno, 3,3 V pour l'ESP32 et le Pico).

Pas à pas : piloter un ventilateur 2 fils selon la température (Arduino Uno)

  1. Dans l'IDE Arduino, installe les bibliothèques OneWire et DallasTemperature depuis le Gestionnaire de bibliothèques.
  2. Branche le DS18B20 : VDD sur 5V, GND sur GND, données sur D4 ; place une résistance de 4,7 kΩ entre la ligne de données et 5V.
  3. Monte le circuit MOSFET : rouge du ventilateur au +12 V, noir au drain, source à GND, grille sur D9 via 220 Ω, et 10 kΩ entre grille et source.
  4. Place la diode en inverse sur les bornes du ventilateur : cathode (côté bague) au +12 V, l'autre extrémité au fil noir du ventilateur.
  5. Relie la masse de l'adaptateur à la masse de l'Arduino, téléverse le code et ouvre le moniteur série à 9600 bauds.
  6. Chauffe le capteur avec tes doigts ; passé 30 °C, observe le ventilateur démarrer par une brève impulsion à pleine puissance, puis accélérer avec la température.
C++ (Arduino IDE)
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const byte FAN_PIN  = 9;     // MOSFET gate (220 ohm) / MOSFET gate (220 ohm)
5const byte TEMP_PIN = 4;     // DS18B20 veri / DS18B20 data
6
7const float T_ON    = 30.0;  // fan bu sıcaklıkta açılır / fan turns on here
8const float T_OFF   = 27.0;  // fan bu sıcaklıkta kapanır / fan turns off here
9const float T_MAX   = 45.0;  // tam hız sıcaklığı / full speed temperature
10const int   PWM_MIN = 80;    // fanın dönebildiği en düşük değer / lowest value that keeps the fan spinning
11
12OneWire oneWire(TEMP_PIN);
13DallasTemperature sensors(&oneWire);
14bool fanOn = false;
15int lastPwm = 0;
16
17void setup() {
18  Serial.begin(9600);
19  pinMode(FAN_PIN, OUTPUT);
20  // Timer1 ön bölücü = 1: D9 ve D10'da ~31 kHz PWM / Timer1 prescaler = 1: ~31 kHz PWM on D9 and D10
21  TCCR1B = (TCCR1B & 0b11111000) | 0x01;
22  sensors.begin();
23}
24
25void loop() {
26  sensors.requestTemperatures();               // ~750 ms sürer / takes ~750 ms
27  float t = sensors.getTempCByIndex(0);
28  int pwm;
29
30  if (t == DEVICE_DISCONNECTED_C) {
31    pwm = 255;                                 // sensör yok: tam hız / no sensor: full speed
32  } else {
33    if (!fanOn && t >= T_ON)  fanOn = true;    // histerezis / hysteresis
34    if (fanOn && t <= T_OFF)  fanOn = false;
35    if (fanOn) {
36      float tc = constrain(t, T_OFF, T_MAX);
37      pwm = map((long)(tc * 10), (long)(T_OFF * 10), (long)(T_MAX * 10), PWM_MIN, 255);
38    } else {
39      pwm = 0;
40    }
41  }
42
43  if (lastPwm == 0 && pwm > 0) {               // kalkış darbesi / kick start
44    analogWrite(FAN_PIN, 255);
45    delay(500);
46  }
47  analogWrite(FAN_PIN, pwm);
48  lastPwm = pwm;
49
50  Serial.print(F("Sicaklik: "));
51  Serial.print(t, 1);
52  Serial.print(F(" C  PWM: "));
53  Serial.println(pwm);
54  delay(250);
55}
Ligne / réglageÀ quoi ça sert ?
TCCR1B = (TCCR1B & 0b11111000) | 0x01Met le prédiviseur du Timer1 à 1 ; le PWM de D9 et D10 passe de 490 Hz à environ 31,4 kHz et le bourdonnement du ventilateur disparaît
T_ON / T_OFFHystérésis : le ventilateur s'allume à 30 °C mais ne s'éteint qu'en redescendant à 27 °C ; pas de va-et-vient à la température limite
map(...)Convertit linéairement la plage 27–45 °C en 80–255 de PWM ; les valeurs sont multipliées par 10 pour ne pas perdre les décimales
PWM_MIN = 80Valeur minimale à laquelle le ventilateur tourne sans s'arrêter (environ 31 %) ; trouve-la par essais avec ton ventilateur
Impulsion de démarrageÀ l'arrêt, on donne d'abord 0,5 seconde à pleine puissance ; les ventilateurs qui ne démarrent pas avec un faible rapport cyclique partent ainsi sans problème
DEVICE_DISCONNECTED_CSi le capteur est débranché ou illisible, le ventilateur passe à pleine vitesse ; l'appareil ne surchauffe pas en cas de panne

Courbe température-vitesse avec map et hystérésis

La courbe température-vitesse définit quelle vitesse appliquer à quelle température. La forme la plus simple est une droite à deux points : vitesse minimale à la température basse, pleine vitesse à la température haute, une ligne droite entre les deux. La fonction map() d'Arduino fait exactement cela ; mais comme elle travaille avec des entiers, convertir une valeur comme 31,6 °C en 316 préserve la précision. map prolonge aussi linéairement les valeurs hors de la plage, il faut donc d'abord limiter l'entrée avec constrain() ; sinon tu obtiens à 60 °C une valeur absurde supérieure à 255. Les détails de la fonction sont dans La fonction map d'Arduino. Le tableau ci-dessous montre les valeurs de la courbe pour la plage 25–45 °C et une vitesse minimale de 20 % ; la pente est de 4 % par degré.

TempératureVitesse du ventilateur (%)PWM 8 bits (0–255)Uno Timer1 OCR1A (0–320)
25 °C et moins205164
30 °C40102128
35 °C60153192
40 °C80204256
45 °C et plus100255320

Ventilateur PC 4 broches : PWM 25 kHz et lecture du tacho

Les ventilateurs 4 broches respectent le standard Intel : broche 1 GND (noir), broche 2 +12 V (jaune), broche 3 tacho (vert), broche 4 commande PWM (bleu). Le ventilateur est toujours alimenté en 12 V complets ; sa vitesse dépend du signal PWM sur la ligne bleue, et le standard demande pour ce signal une fréquence de 25 kHz (21–28 kHz acceptés). À l'intérieur du ventilateur, une résistance tire la ligne PWM vers le haut ; si la ligne est laissée en l'air, il tourne donc à pleine vitesse. La sortie tacho produit 2 impulsions par tour. Tu comptes les impulsions avec une interruption et tu calcules le régime avec la formule : RPM = (nombre d'impulsions ÷ 2) × (60 ÷ durée de mesure en secondes). Si tu as compté 40 impulsions en 1 seconde, le ventilateur tourne à 1200 RPM.

C++ (Arduino IDE)
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const byte PWM_PIN  = 9;        // OC1A -> fan mavi kablo / fan blue wire
5const byte TACH_PIN = 2;        // INT0 -> fan yeşil kablo / fan green wire
6const byte TEMP_PIN = 4;        // DS18B20 veri / DS18B20 data
7const uint16_t PWM_TOP = 320;   // 16 MHz / (2 * 320) = 25 kHz
8
9const float T_MIN = 25.0;       // altında en düşük hız / minimum speed below this
10const float T_MAX = 45.0;       // üstünde tam hız / full speed above this
11const byte DUTY_MIN = 20;       // yüzde / percent
12
13OneWire oneWire(TEMP_PIN);
14DallasTemperature sensors(&oneWire);
15
16volatile uint16_t tachPulses = 0;
17unsigned long lastCalc = 0;
18
19void tachISR() {
20  tachPulses++;                 // her düşen kenar bir darbe / each falling edge is one pulse
21}
22
23void setFanPercent(byte percent) {
24  if (percent > 100) percent = 100;
25  OCR1A = (uint32_t)PWM_TOP * percent / 100;
26}
27
28void setup() {
29  Serial.begin(9600);
30  pinMode(PWM_PIN, OUTPUT);
31  TCCR1A = 0;
32  TCCR1B = 0;
33  TCNT1  = 0;
34  TCCR1A = _BV(COM1A1) | _BV(WGM11);   // OC1A normal çıkış, mod 10 / OC1A non-inverting, mode 10
35  TCCR1B = _BV(WGM13) | _BV(CS10);     // faz doğru PWM, TOP = ICR1, ön bölücü 1 / phase correct, TOP = ICR1, prescaler 1
36  ICR1 = PWM_TOP;
37  setFanPercent(DUTY_MIN);
38
39  pinMode(TACH_PIN, INPUT_PULLUP);      // harici 10k pull-up önerilir / external 10k pull-up recommended
40  attachInterrupt(digitalPinToInterrupt(TACH_PIN), tachISR, FALLING);
41  sensors.begin();
42  lastCalc = millis();
43}
44
45void loop() {
46  sensors.requestTemperatures();
47  float t = sensors.getTempCByIndex(0);
48
49  byte duty;
50  if (t == DEVICE_DISCONNECTED_C) {
51    duty = 100;                         // sensör yok: tam hız / no sensor: full speed
52  } else {
53    float tc = constrain(t, T_MIN, T_MAX);
54    duty = map((long)(tc * 10), (long)(T_MIN * 10), (long)(T_MAX * 10), DUTY_MIN, 100);
55  }
56  setFanPercent(duty);
57
58  unsigned long now = millis();
59  unsigned long elapsed = now - lastCalc;
60  lastCalc = now;
61  noInterrupts();
62  uint16_t pulses = tachPulses;
63  tachPulses = 0;
64  interrupts();
65  unsigned long rpm = (unsigned long)pulses * 30000UL / elapsed;   // 2 darbe = 1 tur / 2 pulses = 1 turn
66
67  Serial.print(F("Sicaklik: "));
68  Serial.print(t, 1);
69  Serial.print(F(" C  Duty: %"));
70  Serial.print(duty);
71  Serial.print(F("  RPM: "));
72  Serial.println(rpm);
73  delay(1000);
74}

La fonction analogWrite d'Arduino ne peut pas produire 25 kHz ; nous configurons donc directement le Timer1. Avec le mode 10 (PWM à phase correcte, valeur haute ICR1), la fréquence vaut 16 MHz ÷ (2 × 1 × ICR1) ; ICR1 = 320 donne exactement 25 kHz. La valeur du rapport cyclique s'écrit dans le registre OCR1A entre 0 et 320, soit environ 0,3 % par pas. La ligne tacho est reliée à l'interruption INT0 sur D2 ; à chaque front descendant, le compteur augmente de un. Dans loop, les interruptions sont coupées très brièvement pour lire et remettre à zéro le compteur en toute sécurité. Tu trouveras la logique des interruptions dans l'article Interruptions Arduino.

Régler le Timer1 de cette façon désactive analogWrite sur D9 et D10 ainsi que la bibliothèque Servo, qui utilise le Timer1. Si ton projet comprend aussi un servo, garde le ventilateur sur le Timer1 et passe pour le servo à une bibliothèque utilisant le Timer2 comme ServoTimer2, ou porte le projet sur ESP32. De plus, la plupart des ventilateurs 4 broches continuent de tourner à leur régime minimal même à 0 % de rapport cyclique ; pour l'arrêter complètement, il faut couper son alimentation 12 V avec un MOSFET à canal P séparé ou un relais.

Contrôle de ventilateur avec ESP32 (25 kHz via LEDC)

Sur l'ESP32, le PWM passe par le module LEDC et tu peux régler 25 kHz en une seule ligne ; grâce à l'horloge de 80 MHz, une résolution de 8 bits est facile à obtenir à cette fréquence. Dans le core Arduino 3.x, les fonctions LEDC travaillent avec le numéro de broche, et dans le 2.x avec le numéro de canal ; le code ci-dessous compile dans les deux versions grâce au test ESP_ARDUINO_VERSION_MAJOR. Sur l'ESP32, chaque GPIO peut recevoir une interruption ; nous utilisons le GPIO 26 pour le tacho et protégeons le compteur par une section critique (portMUX) pour éviter un accès simultané depuis et hors de l'interruption. Si tu utilises un ventilateur 2 fils, tu peux relier le GPIO 25 à la grille d'un MOSFET qui conduit pleinement à 3,3 V et utiliser le même code ; dans ce cas, ignore les lignes du tacho.

C++ (Arduino IDE)
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const int PWM_PIN  = 25;      // fan mavi kablo / fan blue wire
5const int TACH_PIN = 26;      // fan yeşil kablo (10k -> 3V3) / fan green wire (10k -> 3V3)
6const int TEMP_PIN = 4;       // DS18B20 veri / DS18B20 data
7const int PWM_FREQ = 25000;   // 25 kHz
8const int PWM_RES  = 8;       // 0-255
9const int PWM_CH   = 0;       // yalnız core 2.x / core 2.x only
10
11const float T_MIN = 25.0;
12const float T_MAX = 45.0;
13const int DUTY_MIN = 51;      // ~%20 / ~20 %
14
15OneWire oneWire(TEMP_PIN);
16DallasTemperature sensors(&oneWire);
17
18volatile uint32_t tachPulses = 0;
19portMUX_TYPE tachMux = portMUX_INITIALIZER_UNLOCKED;
20unsigned long lastCalc = 0;
21
22void IRAM_ATTR tachISR() {
23  portENTER_CRITICAL_ISR(&tachMux);
24  tachPulses++;
25  portEXIT_CRITICAL_ISR(&tachMux);
26}
27
28void fanWrite(int duty) {
29#if ESP_ARDUINO_VERSION_MAJOR >= 3
30  ledcWrite(PWM_PIN, duty);           // core 3.x: pin ile / by pin
31#else
32  ledcWrite(PWM_CH, duty);            // core 2.x: kanal ile / by channel
33#endif
34}
35
36void setup() {
37  Serial.begin(115200);
38#if ESP_ARDUINO_VERSION_MAJOR >= 3
39  ledcAttach(PWM_PIN, PWM_FREQ, PWM_RES);
40#else
41  ledcSetup(PWM_CH, PWM_FREQ, PWM_RES);
42  ledcAttachPin(PWM_PIN, PWM_CH);
43#endif
44  fanWrite(DUTY_MIN);
45  pinMode(TACH_PIN, INPUT_PULLUP);
46  attachInterrupt(digitalPinToInterrupt(TACH_PIN), tachISR, FALLING);
47  sensors.begin();
48  lastCalc = millis();
49}
50
51void loop() {
52  sensors.requestTemperatures();
53  float t = sensors.getTempCByIndex(0);
54  int duty;
55  if (t == DEVICE_DISCONNECTED_C) {
56    duty = 255;                       // sensör yok: tam hız / no sensor: full speed
57  } else {
58    float tc = constrain(t, T_MIN, T_MAX);
59    duty = map((long)(tc * 10), (long)(T_MIN * 10), (long)(T_MAX * 10), DUTY_MIN, 255);
60  }
61  fanWrite(duty);
62
63  unsigned long now = millis();
64  unsigned long elapsed = now - lastCalc;
65  lastCalc = now;
66  portENTER_CRITICAL(&tachMux);
67  uint32_t pulses = tachPulses;
68  tachPulses = 0;
69  portEXIT_CRITICAL(&tachMux);
70  unsigned long rpm = (unsigned long)pulses * 30000UL / elapsed;   // 2 darbe = 1 tur / 2 pulses = 1 turn
71
72  Serial.printf("Sicaklik: %.1f C  Duty: %d%%  RPM: %lu\n", t, duty * 100 / 255, rpm);
73  delay(1000);
74}

Contrôle de ventilateur avec Raspberry Pi Pico et MicroPython

Le matériel PWM du Pico produit facilement 25 kHz et, en MicroPython, la valeur du rapport cyclique se donne sur 16 bits entre 0 et 65535. Les modules onewire et ds18x20 nécessaires au DS18B20 sont déjà inclus dans la version MicroPython du Pico, tu n'as aucun fichier à copier. Nous comptons les impulsions du tacho avec Pin.irq ; désactiver brièvement les interruptions pendant la lecture du compteur évite qu'il soit lu à moitié mis à jour. Si MicroPython est nouveau pour toi, l'article Les bases de MicroPython est un bon point de départ.

MicroPython
1import machine, onewire, ds18x20, time
2from machine import Pin, PWM
3
4fan = PWM(Pin(16))                      # fan mavi kablo / fan blue wire
5fan.freq(25000)                         # 25 kHz
6tach = Pin(17, Pin.IN, Pin.PULL_UP)     # 10k -> 3V3 önerilir / 10k -> 3V3 recommended
7ds = ds18x20.DS18X20(onewire.OneWire(Pin(15)))
8roms = ds.scan()
9if not roms:
10    raise RuntimeError("DS18B20 bulunamadi / not found")
11
12T_MIN, T_MAX = 25.0, 45.0
13DUTY_MIN = 20                           # yüzde / percent
14
15pulses = 0
16def on_pulse(pin):
17    global pulses
18    pulses += 1                         # her düşen kenar / each falling edge
19
20tach.irq(trigger=Pin.IRQ_FALLING, handler=on_pulse)
21
22def set_percent(p):
23    p = max(0, min(100, p))
24    fan.duty_u16(int(p * 65535 / 100))
25
26def temp_to_percent(t):
27    if t <= T_MIN:
28        return DUTY_MIN
29    if t >= T_MAX:
30        return 100
31    return DUTY_MIN + (t - T_MIN) * (100 - DUTY_MIN) / (T_MAX - T_MIN)
32
33set_percent(DUTY_MIN)
34last = time.ticks_ms()
35while True:
36    ds.convert_temp()
37    time.sleep_ms(750)                  # 12 bit dönüşüm süresi / 12-bit conversion time
38    t = ds.read_temp(roms[0])
39    duty = temp_to_percent(t)
40    set_percent(duty)
41
42    now = time.ticks_ms()
43    elapsed = time.ticks_diff(now, last)
44    last = now
45    state = machine.disable_irq()
46    count = pulses
47    pulses = 0
48    machine.enable_irq(state)
49    rpm = count * 30000 // elapsed      # 2 darbe = 1 tur / 2 pulses = 1 turn
50    print("Sicaklik: {:.1f} C  Duty: %{}  RPM: {}".format(t, int(duty), rpm))
51    time.sleep_ms(250)

Astuces pour un ventilateur silencieux

  • Passe la fréquence PWM au-dessus du seuil d'audition : le PWM par défaut de 490 Hz provoque un bourdonnement net dans les bobines. 31 kHz sur un ventilateur 2 fils et 25 kHz sur un 4 broches suppriment complètement ce bruit.
  • Change la vitesse en douceur : au lieu de passer d'un coup de 30 % à 90 %, n'augmente le rapport cyclique que de quelques pour cent par seconde ; l'oreille remarque bien plus les changements brusques de régime qu'un souffle constant.
  • Utilise l'hystérésis : si le ventilateur s'allume et s'éteint sans cesse à la température limite, tu entends un clic à chaque démarrage et un bruit irrégulier ; laisse 2–3 °C entre les seuils d'allumage et d'extinction.
  • Fais la moyenne des mesures : de petites fluctuations du capteur font varier la vitesse du ventilateur. Une moyenne des 5 à 10 dernières mesures calme la courbe ; pour les méthodes, consulte l'article filtrage des données de capteur.
  • Fais tourner un gros ventilateur lentement : un ventilateur de 120 mm à 800 RPM assure un débit d'air proche de celui d'un 80 mm à 2500 RPM, bien plus silencieusement.
  • Coupe les vibrations : monte le ventilateur avec des plots en caoutchouc ou un joint en silicone et ne place pas la grille ou le filtre trop près de l'hélice ; les vibrations mécaniques sont souvent plus bruyantes que le bruit électrique.
  • Choisis bien la vitesse minimale : trouve par essais la plus faible valeur de rapport cyclique à laquelle le ventilateur continue de tourner et place la limite basse de la courbe légèrement au-dessus ; un ventilateur qui rame à la limite fait un bruit irrégulier.

Idées de projets avec le contrôle de ventilateur

  • Thermostat intelligent : un contrôleur qui gère le chauffage par relais et le ventilateur en PWM ; détails dans l'article thermostat Arduino.
  • Refroidisseur de caisson d'imprimante 3D : un ventilateur d'extraction silencieux qui garde l'intérieur sous 35 °C et affiche le régime à l'écran ; pour l'écran, consulte le guide écran OLED.
  • Ventilation de serre : des ventilateurs qui travaillent avec la température et l'humidité ; le projet de serre intelligente en est une bonne base.
  • Refroidisseur Peltier : refroidis le dissipateur de la face chaude d'un module Peltier avec un ventilateur qui accélère selon la température de cette face ; voir Module Peltier.
  • Domotique : suis depuis ton téléphone le régime du ventilateur et la température avec l'ESP32 via MQTT et Home Assistant.
  • Température constante avec PID : au lieu d'une courbe linéaire, utilise la régulation PID pour construire un système de ventilation qui maintient une boîte à exactement 30 °C.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
Le ventilateur ne tourne pas du toutLa masse n'est pas commune ou le MOSFET n'est pas logic-levelRelie les masses de l'adaptateur et de l'Arduino, utilise un MOSFET de la série L comme l'IRLZ44N
Le ventilateur 4 broches est toujours à pleine vitesseLa ligne PWM est sur la mauvaise broche ou laissée en l'airVérifie que le fil bleu va à D9, GPIO 25 ou GP16 et que la masse est commune
Un léger bourdonnement sort du ventilateurPWM par défaut de 490 HzPasse la fréquence à 25–31 kHz
Le ventilateur s'arrête à basse vitesseLe rapport cyclique est sous le seuil de démarrage du ventilateurAugmente PWM_MIN et utilise une impulsion de démarrage
Le RPM reste toujours à 0Pas de pull-up sur le tacho ou mauvaise brocheRelie 10 kΩ à la tension logique, utilise une broche compatible interruption
Les valeurs de RPM sont très élevées et instablesCâble long, bruit, ou PWM côté bas d'un ventilateur 3 filsRaccourcis le câble, éloigne la ligne tacho du fil PWM ; sur un 3 fils, ne lis le régime qu'à pleine vitesse
L'Arduino redémarre quand le ventilateur démarreLe ventilateur et la carte sont sur la même alimentation faibleUtilise un adaptateur 12 V séparé pour le ventilateur, ajoute une diode et un condensateur de 100 µF
Le MOSFET chauffe beaucoupMOSFET 5 V sur une carte 3,3 V ou diode manquanteChoisis un MOSFET à faible seuil comme l'AO3400, monte la diode de roue libre
Pour trouver la valeur minimale à laquelle ton ventilateur tourne, fais un petit test : pars de 100 % de rapport cyclique, baisse-le de 5 % toutes les 3 secondes et surveille le RPM dans le moniteur série. La valeur à laquelle le régime tombe à zéro, plus 5–10 %, est un choix sûr pour la limite basse de la courbe. Sur un ventilateur 2 fils sans sortie tacho, tu peux faire le même test à l'œil et à l'oreille.

Le contrôle de ventilateur selon la température est l'un des sujets les plus formateurs, car il réunit dans un seul projet lecture de capteur, PWM, interruptions et électronique de puissance. En commençant par un simple ventilateur 2 fils puis en passant à un ventilateur PC 4 broches, tu auras construit un vrai système de refroidissement qui mesure son régime et tourne en silence. Dans l'application BlueGrays, tu peux étudier pas à pas, avec schémas et codes, les projets qui servent de base à cet article, comme la mesure de température avec le DHT11 ou les applications PWM avec ESP32 et Pico.

Questions fréquentes

Comment contrôler un ventilateur 12 V avec Arduino ?

Tu ne peux pas brancher un ventilateur 12 V directement sur une broche d'Arduino : elle délivre 5 V et au maximum environ 20 mA. Un ventilateur 2 fils se commande côté bas avec un MOSFET à canal N logic-level comme l'IRLZ44N, en appliquant le PWM. Un ventilateur 4 broches est alimenté directement en 12 V et l'Arduino ne pilote que la ligne PWM bleue ; dans les deux cas, les masses doivent être communes.

Pourquoi la fréquence PWM d'un ventilateur 4 broches doit-elle être de 25 kHz ?

Le standard Intel des ventilateurs 4 broches définit pour le signal de commande une plage de 21–28 kHz, avec 25 kHz comme cible. Cette fréquence dépasse la limite d'audition humaine (environ 20 kHz), donc les bobines ne bourdonnent pas. Beaucoup de ventilateurs réagissent mal au PWM par défaut de 490 Hz de l'Arduino ou font du bruit.

Comment calcule-t-on le RPM d'un ventilateur ?

La sortie tacho des ventilateurs de PC produit 2 impulsions par tour. Tu divises par 2 le nombre d'impulsions comptées sur une durée donnée et tu ramènes à la minute : RPM = impulsions ÷ 2 × 60 ÷ durée (en secondes). Par exemple, si tu as compté 50 impulsions en 1 seconde, le ventilateur tourne à 1500 RPM.

Peut-on contrôler un ventilateur 3 fils en PWM ?

Oui, tu peux ralentir un ventilateur 3 fils comme un ventilateur 2 fils, en appliquant le PWM sur son alimentation avec un MOSFET. Mais comme l'électronique du ventilateur n'est pas alimentée pendant les phases coupées du PWM, le signal tacho est perturbé et la lecture du régime n'est pas fiable. Pour mesurer correctement le régime, utilise un ventilateur 4 broches ou baisse la tension du 3 fils avec un convertisseur DC-DC.

Pourquoi le ventilateur s'arrête ou ne démarre pas à basse vitesse ?

Chaque ventilateur a un niveau de puissance minimal pour continuer à tourner et un autre pour démarrer à l'arrêt ; la plupart des ventilateurs 12 V ne démarrent pas sous environ 5–7 V. La solution est de placer la limite basse de la courbe un peu au-dessus de cette valeur et de lancer le ventilateur à l'arrêt par une impulsion d'une demi-seconde à pleine puissance. La plupart des ventilateurs 4 broches, eux, ne s'arrêtent pas à faible rapport cyclique et tournent à leur régime minimal.

Quel MOSFET utiliser pour le contrôle d'un ventilateur ?

Sur les cartes 5 V comme l'Arduino Uno, les MOSFET logic-level comme l'IRLZ44N, l'IRL540N ou l'IRLB8721 conviennent. Pour la sortie 3,3 V de l'ESP32 et du Pico, choisis des composants qui conduisent pleinement avec une tension de grille de 2,5 V, comme l'AO3400 ou l'IRLML2502. L'IRFZ44N et l'IRF540N demandent 10 V de grille ; avec un microcontrôleur, ils restent à moitié ouverts et chauffent.

Voir tous les projets
Température et humidité avec DHT11
AR-55Intermédiaire

Température et humidité avec DHT11

Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

4.7(47)
83
ESP32 LED Fade avec PWM
ES-8Débutant

ESP32 LED Fade avec PWM

Modifiez la luminosité de la LED en douceur de 0 à max, de max à 0. Nous contrôlons le PWM avec analogWrite() comme dans Arduino - la même syntaxe avec ESP32 Arduino Core 3.0+ fonctionne sans problème. La définition du pin + pinMode + analogWrite est suffisante.

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Effet Respiration)
PI-14Débutant

Raspberry Pi Pico PWM LED Fade (Effet Respiration)

La LED ne clignote plus — elle respire ! Grâce au PWM (modulation de largeur d'impulsion) du Raspberry Pi Pico, la luminosité monte puis descend lentement. Apprends la classe machine.PWM, duty_u16() (luminosité 16 bits 0–65535), la fréquence PWM, les boucles range() et la sortie quasi analogique. Base du mélange de couleurs RGB, du contrôle moteur, des servos et du buzzer.

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

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

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

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

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

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

4.5(33)
44
ESP32 DHT22 Température et humidité (avec écran LCD)
ES-15Intermédiaire

ESP32 DHT22 Température et humidité (avec écran LCD)

Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

4.8(38)
57
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

4.7(7)
12
Station d'irrigation intelligente
AR-83Avancé
Premium

Station d'irrigation intelligente

Un jardinier qui arrose tes plantes tout seul pour qu'elles ne sèchent pas pendant tes vacances.

5.0(42)
57