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.

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.
| Caratteristica | Ventola a 2 fili | Ventola a 3 fili | Ventola PWM a 4 pin |
|---|---|---|---|
| Fili | Rosso (+), nero (GND) | +, GND, giallo o verde tachimetro | GND, +12 V, tachimetro, PWM |
| Controllo velocità | PWM sull'alimentazione con MOSFET | PWM sull'alimentazione o riduzione della tensione | Linea PWM separata, 25 kHz |
| Lettura giri | No | Sì (si disturba durante il PWM) | Sì, indipendente dal PWM |
| Componenti extra | MOSFET, diodo, resistenze | MOSFET, diodo, resistenze | Solo pull-up da 10 kΩ |
| Velocità minima | Si ferma sotto il 30–40% di duty | Si ferma sotto il 30–40% di duty | Di solito gira al 20–30% e non si ferma |
| Uso tipico | Ventole per case e dispositivi | Vecchie ventole PC | Ventole 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.
| Componente | Valore consigliato | Funzione |
|---|---|---|
| MOSFET a canale N (Uno, 5 V) | IRLZ44N, IRL540N, IRLB8721 | Apre e chiude con PWM la linea GND della ventola |
| MOSFET a canale N (ESP32/Pico, 3,3 V) | AO3400, IRLML2502 | Conduce completamente con 3,3 V sul gate |
| Resistenza di gate | 100–220 Ω | Limita la corrente del pin e riduce le oscillazioni del segnale |
| Pull-down del gate | 10 kΩ (tra gate e source) | Tiene il MOSFET spento all'avvio |
| Diodo flyback | 1N5819 (Schottky) o 1N4007 | Assorbe il picco di tensione della bobina |
| Alimentazione | Alimentatore 12 V, almeno il doppio della corrente della ventola | Alimenta la ventola indipendentemente da Arduino |
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.
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| PWM ventola (blu) o gate del MOSFET | D9 | GPIO 25 | GP16 |
| 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Ω | D4 | GPIO 4 | GP15 |
| VDD DS18B20 | 5V | 3V3 | 3V3 |
| Ventola +12 V (giallo) | Alimentatore esterno 12 V | Alimentatore esterno 12 V | Alimentatore esterno 12 V |
| GND ventola (nero) | GND (in comune con l'alimentatore) | GND (in comune con l'alimentatore) | GND (in comune con l'alimentatore) |
Passo dopo passo: ventola a 2 fili in base alla temperatura (Arduino Uno)
- Nell'IDE di Arduino installa dal Gestore librerie le librerie OneWire e DallasTemperature.
- 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.
- 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.
- Monta il diodo in antiparallelo alla ventola: catodo (lato con la striscia) a +12 V, l'altro capo al filo nero della ventola.
- Collega il GND dell'alimentatore al GND di Arduino, carica il codice e apri il Monitor Seriale a 9600 baud.
- 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.
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 / impostazione | A cosa serve |
|---|---|
| TCCR1B = (TCCR1B & 0b11111000) | 0x01 | Imposta 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_OFF | Isteresi: 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 = 80 | Il valore minimo con cui la ventola gira senza fermarsi (circa 31%); trovalo sperimentando con la tua ventola |
| Impulso di avvio | A 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_C | Se 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.
| Temperatura | Velocità ventola (%) | PWM a 8 bit (0–255) | OCR1A Timer1 Uno (0–320) |
|---|---|---|---|
| 25 °C e meno | 20 | 51 | 64 |
| 30 °C | 40 | 102 | 128 |
| 35 °C | 60 | 153 | 192 |
| 40 °C | 80 | 204 | 256 |
| 45 °C e più | 100 | 255 | 320 |
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.
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.
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.
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.
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
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| La ventola non gira | GND non in comune o MOSFET non logic-level | Collega 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 scollegata | Controlla che il filo blu vada a D9, GPIO 25 o GP16 e che il GND sia in comune |
| La ventola emette un ronzio sottile | PWM predefinito a 490 Hz | Porta la frequenza a 25–31 kHz |
| La ventola si ferma a bassa velocità | Duty sotto la soglia di avvio della ventola | Aumenta PWM_MIN e usa l'impulso di avvio |
| Gli RPM risultano sempre 0 | Manca il pull-up del tachimetro o pin sbagliato | Collega 10 kΩ alla tensione logica, usa un pin con supporto interrupt |
| RPM molto alti e instabili | Cavo lungo, rumore o PWM low-side su ventola a 3 fili | Accorcia 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 parte | Ventola e scheda alimentate dalla stessa sorgente debole | Usa un alimentatore a 12 V separato per la ventola, aggiungi diodo e condensatore da 100 µF |
| Il MOSFET si scalda molto | MOSFET da 5 V su scheda a 3,3 V o diodo mancante | Scegli un MOSFET a bassa soglia come AO3400, monta il diodo flyback |
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.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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…

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.

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.

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.

Misura di temperatura con NTC e display Lcd 2x16
Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

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.

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.

Stazione di irrigazione intelligente
Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

