Guide · 10 min di lettura

Controllo ventola Arduino: velocità con PWM in base alla temperatura

Controllo ventola con Arduino: ventola a 2 fili con MOSFET e PWM, ventola PC a 4 pin con PWM a 25 kHz e lettura RPM dal tachimetro. Codice per Uno, ESP32 e Pico.

Il controllo ventola con Arduino è il modo più pratico per regolare automaticamente la velocità di una ventola in base alla temperatura: un sensore misura l'ambiente, Arduino trasforma il valore in una velocità e pilota la ventola con un segnale PWM. Così la ventola gira lenta e silenziosa quando fa fresco, accelera quando la temperatura sale e non fa rumore inutile a pieno regime. Camere di stampanti 3D, contenitori di alimentatori, coperchi di acquari, serre e case per PC sono le applicazioni più comuni.

In questa guida vediamo due strade: pilotare con PWM una semplice ventola a 2 fili tramite un MOSFET logic-level, e gestire una ventola PC a 4 pin dal suo ingresso di controllo con PWM a 25 kHz, leggendo i giri dall'uscita tachimetrica. Vedrai passo dopo passo il codice funzionante per Arduino Uno, ESP32 e Raspberry Pi Pico, la curva temperatura-velocità con map, l'isteresi e i trucchi per una ventola davvero silenziosa.

Sensore di temperatura digitale DS18B20
DS18B20: sensore digitale con un solo filo dati e precisione di ±0,5 °C. Lo usiamo per misurare la temperatura nel controllo ventola di questo articolo.

Cos'è il controllo ventola con Arduino e come funziona?

Le ventole per computer sono motori DC brushless: un piccolo circuito interno alimenta le bobine in sequenza. Per cambiare la velocità ci sono due modi: abbassare la tensione applicata oppure accendere e spegnere la tensione molto velocemente. Il secondo metodo è il PWM, il linguaggio naturale dei microcontrollori. Con un duty cycle del 50% la ventola riceve energia metà del tempo; l'inerzia dell'elica smorza gli impulsi e la ventola gira a circa metà velocità. Trovi le basi del PWM in Cos'è il PWM?. La cosa più importante è il numero di fili della ventola, perché determina il circuito da costruire.

CaratteristicaVentola a 2 filiVentola a 3 filiVentola PWM a 4 pin
FiliRosso (+), nero (GND)+, GND, giallo o verde tachimetroGND, +12 V, tachimetro, PWM
Controllo velocitàPWM sull'alimentazione con MOSFETPWM sull'alimentazione o riduzione della tensioneLinea PWM separata, 25 kHz
Lettura giriNoSì (si disturba durante il PWM)Sì, indipendente dal PWM
Componenti extraMOSFET, diodo, resistenzeMOSFET, diodo, resistenzeSolo pull-up da 10 kΩ
Velocità minimaSi ferma sotto il 30–40% di dutySi ferma sotto il 30–40% di dutyDi solito gira al 20–30% e non si ferma
Uso tipicoVentole per case e dispositiviVecchie ventole PCVentole PC e CPU moderne

Pilotare una ventola a 2 fili con MOSFET e PWM

Un pin di Arduino dà 5 V e può erogare in sicurezza al massimo circa 20 mA: non può pilotare direttamente una ventola da 12 V che assorbe 0,1–0,3 A. Per questo si inserisce un MOSFET a canale N usato come interruttore low-side: il filo rosso della ventola va ai 12 V esterni, il nero al drain (D) del MOSFET, mentre il source (S) va a GND. Il pin di Arduino pilota il gate (G) tramite una resistenza da 220 Ω. La resistenza da 10 kΩ tra gate e source evita che la ventola parta da sola quando Arduino si accende o si resetta. Un diodo in antiparallelo ai capi della ventola (catodo dal lato +12 V) assorbe il picco di tensione generato dalla bobina allo spegnimento. Il funzionamento del MOSFET è spiegato meglio in Usare il MOSFET con Arduino.

ComponenteValore consigliatoFunzione
MOSFET a canale N (Uno, 5 V)IRLZ44N, IRL540N, IRLB8721Apre e chiude con PWM la linea GND della ventola
MOSFET a canale N (ESP32/Pico, 3,3 V)AO3400, IRLML2502Conduce completamente con 3,3 V sul gate
Resistenza di gate100–220 ΩLimita la corrente del pin e riduce le oscillazioni del segnale
Pull-down del gate10 kΩ (tra gate e source)Tiene il MOSFET spento all'avvio
Diodo flyback1N5819 (Schottky) o 1N4007Assorbe il picco di tensione della bobina
AlimentazioneAlimentatore 12 V, almeno il doppio della corrente della ventolaAlimenta la ventola indipendentemente da Arduino
L'errore più comune è usare MOSFET non logic-level come IRFZ44N o IRF540N. Sono progettati per una tensione di gate di 10 V; a 5 V restano semiaperti, la ventola gira piano e il MOSFET si scalda. Scegli quelli con la lettera L nel nome (IRLZ44N, IRL540N). Inoltre il GND di Arduino e quello dell'alimentatore a 12 V devono essere collegati insieme: senza massa comune il segnale PWM non ha riferimento e la ventola non gira o si comporta in modo casuale.

Tabella dei collegamenti: Arduino Uno, ESP32 e Pico

La tabella seguente copre sia il collegamento diretto della ventola a 4 pin sia il gate del MOSFET per la ventola a 2 fili; in entrambi i circuiti il PWM esce dallo stesso pin. Come sensore di temperatura usiamo il DS18B20, che funziona su tutte le schede ed esiste anche in versione impermeabile; i dettagli sono in Sensore di temperatura DS18B20.

CollegamentoArduino UnoESP32Raspberry Pi Pico
PWM ventola (blu) o gate del MOSFETD9GPIO 25GP16
Tachimetro ventola (verde) + pull-up 10 kΩD2 (pull-up a 5V)GPIO 26 (pull-up a 3V3)GP17 (pull-up a 3V3)
Dati DS18B20 + pull-up 4,7 kΩD4GPIO 4GP15
VDD DS18B205V3V33V3
Ventola +12 V (giallo)Alimentatore esterno 12 VAlimentatore esterno 12 VAlimentatore esterno 12 V
GND ventola (nero)GND (in comune con l'alimentatore)GND (in comune con l'alimentatore)GND (in comune con l'alimentatore)
Non collegare mai la resistenza di pull-up del tachimetro ai 12 V. L'uscita del tachimetro è open collector: la ventola porta la linea solo a GND, il livello alto lo decide la tua resistenza di pull-up. Con 12 V stressi l'ingresso di Arduino e il pin a 3,3 V di ESP32 e Pico può bruciarsi subito. Collega sempre il pull-up alla tensione logica della scheda (5 V per Uno, 3,3 V per ESP32 e Pico).

Passo dopo passo: ventola a 2 fili in base alla temperatura (Arduino Uno)

  1. Nell'IDE di Arduino installa dal Gestore librerie le librerie OneWire e DallasTemperature.
  2. Collega il DS18B20: VDD a 5V, GND a GND, pin dati a D4; metti una resistenza da 4,7 kΩ tra il pin dati e 5V.
  3. Costruisci il circuito del MOSFET: rosso della ventola a +12 V, nero al drain, source a GND, gate a D9 tramite 220 Ω e 10 kΩ tra gate e source.
  4. Monta il diodo in antiparallelo alla ventola: catodo (lato con la striscia) a +12 V, l'altro capo al filo nero della ventola.
  5. Collega il GND dell'alimentatore al GND di Arduino, carica il codice e apri il Monitor Seriale a 9600 baud.
  6. Scalda il sensore con le dita; superati i 30 °C la ventola parte con un breve impulso a piena potenza e poi accelera con la temperatura.
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}
Riga / impostazioneA cosa serve
TCCR1B = (TCCR1B & 0b11111000) | 0x01Imposta il prescaler di Timer1 a 1; il PWM su D9 e D10 passa da 490 Hz a circa 31,4 kHz e il ronzio della ventola scompare
T_ON / T_OFFIsteresi: la ventola si accende a 30 °C ma si spegne solo quando scende a 27 °C; niente accensioni e spegnimenti continui vicino alla soglia
map(...)Mappa linearmente l'intervallo 27–45 °C sull'intervallo PWM 80–255; i valori sono moltiplicati per 10 per non perdere i decimali
PWM_MIN = 80Il valore minimo con cui la ventola gira senza fermarsi (circa 31%); trovalo sperimentando con la tua ventola
Impulso di avvioA ventola ferma si dà prima mezzo secondo di piena potenza; le ventole che non partono con un duty basso si avviano così senza problemi
DEVICE_DISCONNECTED_CSe il sensore si stacca o non risponde la ventola va a piena velocità; in caso di guasto il dispositivo non si surriscalda

Curva temperatura-velocità con map e isteresi

La curva temperatura-velocità definisce quale velocità applicare a ogni temperatura. La forma più semplice è una retta a due punti: velocità minima alla temperatura inferiore, velocità massima a quella superiore e una linea retta nel mezzo. La funzione map() di Arduino fa esattamente questo; ma poiché lavora con numeri interi, convertire un valore come 31,6 °C in 316 prima di passarlo mantiene la precisione. Dato che map estende linearmente anche i valori fuori intervallo, devi prima limitare l'ingresso con constrain(); altrimenti a 60 °C otterresti un valore privo di senso oltre 255. I dettagli della funzione sono in La funzione map di Arduino. La tabella seguente mostra i valori della curva per l'intervallo 25–45 °C e una velocità minima del 20%; la pendenza è del 4% per grado.

TemperaturaVelocità ventola (%)PWM a 8 bit (0–255)OCR1A Timer1 Uno (0–320)
25 °C e meno205164
30 °C40102128
35 °C60153192
40 °C80204256
45 °C e più100255320

Ventola PC a 4 pin: PWM a 25 kHz e lettura del tachimetro

Le ventole a 4 pin seguono lo standard Intel: pin 1 GND (nero), pin 2 +12 V (giallo), pin 3 tachimetro (verde), pin 4 controllo PWM (blu). La ventola è sempre alimentata a 12 V pieni; la velocità la decide il segnale PWM sulla linea blu e lo standard richiede per questo segnale una frequenza di 25 kHz (accettati 21–28 kHz). Dentro la ventola c'è una resistenza che tira su la linea PWM, quindi se la linea resta scollegata la ventola gira a piena velocità. L'uscita del tachimetro genera 2 impulsi per giro. Conti gli impulsi con un interrupt e calcoli i giri con la formula: RPM = (numero impulsi ÷ 2) × (60 ÷ tempo di misura in secondi). Se in 1 secondo conti 40 impulsi, la ventola gira a 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 funzione analogWrite di Arduino non può generare 25 kHz, perciò configuriamo direttamente Timer1. Scegliendo la modalità 10 (PWM a fase corretta, valore massimo ICR1) la frequenza è 16 MHz ÷ (2 × 1 × ICR1); con ICR1 = 320 si ottengono esattamente 25 kHz. Il valore del duty si scrive nel registro OCR1A tra 0 e 320, quindi ogni passo vale circa lo 0,3%. La linea del tachimetro è collegata all'interrupt INT0 su D2; a ogni fronte di discesa il contatore aumenta di uno. Nel loop gli interrupt vengono disattivati per un attimo per leggere e azzerare il contatore in sicurezza. La logica degli interrupt è in Arduino Interrupt.

Configurare Timer1 in questo modo disattiva analogWrite su D9 e D10 e la libreria Servo, che usa Timer1. Se nel progetto c'è anche un servo, lascia la ventola su Timer1 e passa per il servo a una libreria che usa Timer2 come ServoTimer2, oppure porta il progetto su ESP32. Inoltre molte ventole a 4 pin continuano a girare al minimo anche con duty allo 0%; se vuoi fermarla del tutto devi togliere l'alimentazione a 12 V con un MOSFET a canale P separato o con un relè.

Controllo ventola con ESP32 (25 kHz con LEDC)

Su ESP32 il PWM si gestisce con l'unità LEDC e puoi impostare 25 kHz in una riga; grazie al clock a 80 MHz a questa frequenza si ottiene facilmente una risoluzione a 8 bit. Nell'Arduino core 3.x le funzioni LEDC lavorano con il numero del pin, nella 2.x con il numero del canale; il codice seguente compila con entrambe le versioni grazie al controllo di ESP_ARDUINO_VERSION_MAJOR. Su ESP32 ogni GPIO può generare interrupt; per il tachimetro usiamo il GPIO 26 e proteggiamo il contatore con una sezione critica (portMUX) perché non venga letto dentro e fuori dall'interrupt contemporaneamente. Se usi una ventola a 2 fili, collega il GPIO 25 al gate di un MOSFET che conduce completamente a 3,3 V e usa lo stesso codice, ignorando le righe del tachimetro.

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}

Controllo ventola con Raspberry Pi Pico e MicroPython

L'hardware PWM del Pico genera facilmente 25 kHz e in MicroPython il duty si indica a 16 bit tra 0 e 65535. I moduli onewire e ds18x20 necessari per il DS18B20 sono già inclusi nella versione MicroPython del Pico, non devi copiare altri file. Contiamo gli impulsi del tachimetro con Pin.irq; disattivare gli interrupt per un attimo durante la lettura del contatore evita che il valore venga aggiornato a metà. Se sei nuovo a MicroPython, Le basi di MicroPython è un buon punto di partenza.

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)

Trucchi per una ventola silenziosa

  • Porta la frequenza PWM sopra il limite dell'udito: il PWM predefinito a 490 Hz crea un ronzio evidente nelle bobine. 31 kHz per la ventola a 2 fili e 25 kHz per quella a 4 pin eliminano del tutto questo rumore.
  • Cambia la velocità gradualmente: invece di passare di colpo dal 30% al 90%, aumenta il duty di pochi punti percentuali al secondo; l'orecchio nota i cambi bruschi di giri molto più di un ronzio costante.
  • Usa l'isteresi: se la ventola si accende e si spegne di continuo alla temperatura di soglia, a ogni avvio senti un clic e un rumore irregolare; lascia 2–3 °C tra le soglie di accensione e spegnimento.
  • Fai la media delle misure: piccole oscillazioni del sensore fanno ballare la velocità. Mediare le ultime 5–10 misure calma la curva; per i metodi guarda l'articolo sul filtraggio dei dati dei sensori.
  • Fai girare lenta una ventola grande: una ventola da 120 mm a 800 RPM garantisce un flusso d'aria simile a una da 80 mm a 2500 RPM, con molto meno rumore.
  • Elimina le vibrazioni: monta la ventola con tasselli di gomma o guarnizioni in silicone e non mettere griglia e filtro troppo vicini all'elica; la vibrazione meccanica spesso fa più rumore di quella elettrica.
  • Scegli bene la velocità minima: trova sperimentando il duty più basso con cui la ventola continua a girare e metti il limite inferiore della curva un po' sopra; una ventola che gira al limite produce un suono irregolare.

Idee di progetto con il controllo ventola

  • Termostato intelligente: un controllore che gestisce il riscaldatore con un relè e la ventola con il PWM; i dettagli sono nell'articolo sul termostato Arduino.
  • Raffreddamento per camera della stampante 3D: una ventola di estrazione silenziosa che mantiene la camera sotto i 35 °C e mostra i giri sul display; per il display guarda la guida al display OLED.
  • Ventilazione per serra: ventole che lavorano insieme a temperatura e umidità; il progetto serra intelligente è una buona base.
  • Raffreddamento Peltier: raffredda il dissipatore sul lato caldo del modulo Peltier con una ventola che accelera in base alla temperatura di quel lato; vedi il modulo Peltier.
  • Domotica: con ESP32 controlla dal telefono giri e temperatura della ventola tramite MQTT e Home Assistant.
  • Temperatura costante con PID: al posto della curva lineare usa il controllo PID per realizzare un sistema di ventole che mantiene una scatola esattamente a 30 °C.

Errori comuni e come risolverli

SintomoCausa probabileSoluzione
La ventola non giraGND non in comune o MOSFET non logic-levelCollega i GND di alimentatore e Arduino, usa un MOSFET serie L come IRLZ44N
La ventola a 4 pin va sempre a piena velocitàLinea PWM sul pin sbagliato o scollegataControlla che il filo blu vada a D9, GPIO 25 o GP16 e che il GND sia in comune
La ventola emette un ronzio sottilePWM predefinito a 490 HzPorta la frequenza a 25–31 kHz
La ventola si ferma a bassa velocitàDuty sotto la soglia di avvio della ventolaAumenta PWM_MIN e usa l'impulso di avvio
Gli RPM risultano sempre 0Manca il pull-up del tachimetro o pin sbagliatoCollega 10 kΩ alla tensione logica, usa un pin con supporto interrupt
RPM molto alti e instabiliCavo lungo, rumore o PWM low-side su ventola a 3 filiAccorcia il cavo, separa la linea del tachimetro da quella PWM; con ventola a 3 fili leggi i giri solo a piena velocità
Arduino si resetta quando la ventola parteVentola e scheda alimentate dalla stessa sorgente deboleUsa un alimentatore a 12 V separato per la ventola, aggiungi diodo e condensatore da 100 µF
Il MOSFET si scalda moltoMOSFET da 5 V su scheda a 3,3 V o diodo mancanteScegli un MOSFET a bassa soglia come AO3400, monta il diodo flyback
Per trovare il valore minimo di rotazione della tua ventola fai un breve test: parti dal 100% di duty, riducilo del 5% ogni 3 secondi e osserva gli RPM nel Monitor Seriale. Un valore del 5–10% sopra quello in cui i giri scendono a zero è una scelta sicura per il limite inferiore della curva. Con una ventola a 2 fili senza uscita tachimetrica puoi fare lo stesso test a occhio e a orecchio.

Il controllo ventola in base alla temperatura riunisce in un solo progetto lettura dei sensori, PWM, interrupt ed elettronica di potenza, ed è per questo uno degli argomenti più efficaci da imparare. Partendo da una semplice ventola a 2 fili e passando a una ventola PC a 4 pin, avrai costruito un vero sistema di raffreddamento silenzioso che misura i propri giri. Nell'app BlueGrays trovi passo dopo passo, con schemi e codice, i progetti alla base di questo articolo, come la misura della temperatura con DHT11 e le applicazioni PWM con ESP32 e Pico.

Domande frequenti

Come si controlla una ventola a 12 V con Arduino?

Non puoi collegare una ventola da 12 V direttamente a un pin di Arduino: il pin dà 5 V e al massimo circa 20 mA. La ventola a 2 fili si commuta sul lato low-side con un MOSFET a canale N logic-level come IRLZ44N, applicando il PWM. Con le ventole a 4 pin la ventola è alimentata direttamente a 12 V e Arduino pilota solo la linea PWM blu; in entrambi i casi i GND devono essere in comune.

Perché il PWM di una ventola a 4 pin deve essere a 25 kHz?

Lo standard Intel per le ventole a 4 pin definisce per il segnale di controllo un intervallo di 21–28 kHz, con 25 kHz come valore target. Essendo sopra il limite dell'udito umano (circa 20 kHz), dalle bobine non esce alcun ronzio. Molte ventole non reagiscono bene al PWM predefinito di Arduino a 490 Hz o producono rumore.

Come si calcolano gli RPM di una ventola?

L'uscita del tachimetro delle ventole PC genera 2 impulsi per giro. Dividi per 2 il numero di impulsi contati in un dato tempo e converti in minuti: RPM = impulsi ÷ 2 × 60 ÷ tempo (secondi). Per esempio, se in 1 secondo conti 50 impulsi la ventola gira a 1500 RPM.

Si può controllare con il PWM una ventola a 3 fili?

Sì, puoi rallentare anche una ventola a 3 fili applicando il PWM all'alimentazione con un MOSFET, come per una a 2 fili. Ma nei momenti di PWM spento l'elettronica della ventola resta senza energia, il segnale del tachimetro si disturba e la lettura dei giri non è affidabile. Se vuoi misurare bene i giri usa una ventola a 4 pin, oppure riduci la tensione della ventola a 3 fili con un convertitore DC-DC.

Perché la ventola si ferma o non parte a bassa velocità?

Ogni ventola ha un livello minimo di potenza con cui può continuare a girare e con cui riesce a partire da ferma; la maggior parte delle ventole da 12 V non parte sotto i 5–7 V circa. La soluzione è mettere il limite inferiore della curva un po' sopra questo valore e avviare la ventola ferma con un impulso di mezzo secondo a piena potenza. Molte ventole a 4 pin invece non si fermano con duty basso e continuano a girare al minimo.

Quale MOSFET usare per il controllo di una ventola?

Su schede a 5 V come Arduino Uno vanno bene MOSFET logic-level come IRLZ44N, IRL540N o IRLB8721. Per l'uscita a 3,3 V di ESP32 e Pico scegli componenti come AO3400 o IRLML2502, che conducono completamente con 2,5 V sul gate. IRFZ44N e IRF540N richiedono 10 V sul gate; usati con un microcontrollore restano semiaperti e si scaldano.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
Dissolvenza LED ESP32 con PWM
ES-8Principiante

Dissolvenza LED ESP32 con PWM

Modificare la luminosità del LED in modo fluido da 0 a max, da max a 0. Controlliamo il PWM con analogWrite() come in Arduino - la stessa sintassi con ESP32 Arduino Core 3.0+ funziona senza problemi. La definizione del pin + pinMode + analogWrite è sufficiente.

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Effetto Respiro)
PI-14Principiante

Raspberry Pi Pico PWM LED Fade (Effetto Respiro)

Il LED non lampeggia più — respira! Con il PWM (modulazione di larghezza d'impulso) del Raspberry Pi Pico, la luminosità sale e scende lentamente. Impara la classe machine.PWM, duty_u16() (luminosità a 16 bit 0–65535), la frequenza PWM, i cicli range() e l'uscita quasi analogica. Base per miscelazione colori RGB, controllo motori, servo e buzzer.

4
Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
ES-13Intermedio
Premium

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)

In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.

4.5(19)
32
Misura di temperatura con NTC e display Lcd 2x16
AR-44Principiante
Premium

Misura di temperatura con NTC e display Lcd 2x16

Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

4.5(33)
44
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura e umidità (con display LCD)

Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

4.8(38)
57
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

4.7(7)
12
Stazione di irrigazione intelligente
AR-83Avanzato
Premium

Stazione di irrigazione intelligente

Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.

5.0(42)
57