Control de ventilador Arduino: velocidad según temperatura
Control de ventilador con Arduino: ventilador de 2 hilos con MOSFET y PWM, PC de 4 pines a 25 kHz y lectura de RPM. Código para Uno, ESP32 y Pico.
El control de ventilador con Arduino es la forma más práctica de ajustar automáticamente la velocidad de un ventilador según la temperatura: un sensor mide el ambiente, Arduino convierte ese valor en una velocidad y mueve el ventilador con una señal PWM. Así, el ventilador gira despacio y en silencio cuando hace fresco, acelera cuando sube el calor y no hace ruido innecesario a máxima velocidad. Las cajas de impresoras 3D, las fuentes de alimentación, las tapas de acuarios, los invernaderos y las torres de PC son los lugares donde más se usa este método.
En esta guía vemos dos caminos: mover un ventilador sencillo de 2 hilos con PWM mediante un MOSFET de nivel lógico, y manejar un ventilador de PC de 4 pines desde su propia línea de control con PWM a 25 kHz, leyendo sus revoluciones por la salida del tacómetro. Verás paso a paso el código para Arduino Uno, ESP32 y Raspberry Pi Pico, cómo crear una curva temperatura-velocidad con map, la histéresis y los trucos para que el ventilador funcione de verdad en silencio.

¿Qué es el control de ventilador con Arduino y cómo funciona?
Los ventiladores de PC son motores de corriente continua sin escobillas; un pequeño circuito interno activa las bobinas por turnos. Hay dos formas de cambiar su velocidad: bajar la tensión aplicada o conectar y desconectar la tensión muy rápido. La segunda es el PWM, el lenguaje natural de los microcontroladores. Con un ciclo de trabajo del 50 %, el ventilador recibe energía la mitad del tiempo; la inercia de las aspas suaviza los pulsos y gira a casi la mitad de velocidad. Encontrarás los fundamentos en ¿Qué es el PWM?. Lo más importante es cuántos cables tiene el ventilador, porque eso determina el circuito que montarás.
| Característica | Ventilador de 2 hilos | Ventilador de 3 hilos | Ventilador PWM de 4 pines |
|---|---|---|---|
| Cables | Rojo (+), negro (GND) | +, GND, tacómetro amarillo o verde | GND, +12 V, tacómetro, PWM |
| Control de velocidad | PWM de la alimentación con MOSFET | PWM de la alimentación o bajar la tensión | Línea PWM independiente, 25 kHz |
| Lectura de RPM | No | Sí (se distorsiona durante el PWM) | Sí, independiente del PWM |
| Componentes extra | MOSFET, diodo, resistencias | MOSFET, diodo, resistencias | Solo pull-up de 10 kΩ |
| Velocidad mínima | Se detiene por debajo de un ciclo del 30–40 % | Se detiene por debajo de un ciclo del 30–40 % | Suele girar al 20–30 % sin pararse |
| Uso típico | Ventiladores de cajas y aparatos | Ventiladores de PC antiguos | Ventiladores modernos de PC y de CPU |
Mover un ventilador de 2 hilos con PWM mediante un MOSFET
Un pin de Arduino da 5 V y puede suministrar con seguridad unos 20 mA como máximo; no puede mover directamente un ventilador de 12 V que consume 0,1–0,3 A. Por eso intercalamos un MOSFET de canal N y lo usamos como interruptor del lado bajo (low-side): el cable rojo del ventilador va a los 12 V externos, el negro al drenador (D) del MOSFET y la fuente (S) a GND. El pin de Arduino maneja la puerta (G) a través de una resistencia de 220 Ω. La resistencia de 10 kΩ entre puerta y fuente evita que el ventilador arranque solo cuando Arduino se enciende o se reinicia. Un diodo en inversa entre los dos extremos del ventilador (cátodo hacia +12 V) absorbe el pico de tensión que genera la bobina del motor al cortarse. Explicamos el funcionamiento del MOSFET con más detalle en Cómo usar un MOSFET con Arduino.
| Componente | Valor recomendado | Función |
|---|---|---|
| MOSFET de canal N (Uno, 5 V) | IRLZ44N, IRL540N, IRLB8721 | Abre y cierra con PWM la línea GND del ventilador |
| MOSFET de canal N (ESP32/Pico, 3,3 V) | AO3400, IRLML2502 | Conduce por completo con 3,3 V en la puerta |
| Resistencia de puerta | 100–220 Ω | Limita la corriente del pin y reduce el rizado de la señal |
| Pull-down de puerta | 10 kΩ (entre puerta y fuente) | Mantiene el MOSFET apagado al arrancar |
| Diodo de rueda libre | 1N5819 (Schottky) o 1N4007 | Absorbe el pico de tensión de la bobina |
| Alimentación | Adaptador de 12 V, al menos el doble de la corriente del ventilador | Alimenta el ventilador de forma independiente de Arduino |
Tabla de conexiones: Arduino Uno, ESP32 y Pico
La tabla siguiente cubre tanto la conexión directa del ventilador de 4 pines como la puerta del MOSFET para el ventilador de 2 hilos; en ambos circuitos el PWM sale por el mismo pin. Como sensor de temperatura usamos el DS18B20, que funciona en todas las placas y existe también en versión sumergible; tienes los detalles en Sensor de temperatura DS18B20.
| Conexión | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| PWM del ventilador (azul) o puerta del MOSFET | D9 | GPIO 25 | GP16 |
| Tacómetro del ventilador (verde) + pull-up de 10 kΩ | D2 (pull-up a 5V) | GPIO 26 (pull-up a 3V3) | GP17 (pull-up a 3V3) |
| Datos del DS18B20 + pull-up de 4,7 kΩ | D4 | GPIO 4 | GP15 |
| VDD del DS18B20 | 5V | 3V3 | 3V3 |
| Ventilador +12 V (amarillo) | Adaptador externo de 12 V | Adaptador externo de 12 V | Adaptador externo de 12 V |
| GND del ventilador (negro) | GND (común con el adaptador) | GND (común con el adaptador) | GND (común con el adaptador) |
Paso a paso: mover un ventilador de 2 hilos según la temperatura (Arduino Uno)
- En el IDE de Arduino, instala desde el Gestor de bibliotecas las bibliotecas OneWire y DallasTemperature.
- Conecta el DS18B20: VDD a 5V, GND a GND y el pin de datos a D4; pon una resistencia de 4,7 kΩ entre el pin de datos y 5V.
- Monta el circuito del MOSFET: rojo del ventilador a +12 V, negro al drenador, fuente a GND, puerta a D9 a través de 220 Ω y 10 kΩ entre puerta y fuente.
- Coloca el diodo en inversa en los extremos del ventilador: el extremo con la franja (cátodo) a +12 V y el otro al cable negro del ventilador.
- Une el GND del adaptador con el GND de Arduino, sube el código y abre el Monitor serie a 9600 baudios.
- Calienta el sensor con los dedos; al pasar de 30 °C verás que el ventilador arranca con un breve pulso a plena potencia y luego acelera 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}| Línea / ajuste | Para qué sirve |
|---|---|
| TCCR1B = (TCCR1B & 0b11111000) | 0x01 | Pone el prescaler del Timer1 en 1; el PWM de D9 y D10 sube de 490 Hz a unos 31,4 kHz y el zumbido del ventilador deja de oírse |
| T_ON / T_OFF | Histéresis: el ventilador se enciende a 30 °C, pero solo se apaga al bajar a 27 °C; no hay parpadeo de encendido y apagado en la temperatura límite |
| map(...) | Asigna linealmente el rango 27–45 °C al rango PWM 80–255; los valores se multiplican por 10 para no perder la parte decimal |
| PWM_MIN = 80 | El valor más bajo con el que el ventilador gira sin pararse (aprox. 31 %); encuéntralo probando con tu propio ventilador |
| Pulso de arranque | Con el ventilador parado se da primero plena potencia durante 0,5 s; así arrancan sin problema los ventiladores que no lo hacen con un ciclo bajo |
| DEVICE_DISCONNECTED_C | Si el sensor se desconecta o no se puede leer, el ventilador pasa a velocidad máxima; en caso de avería el equipo no se sobrecalienta |
Curva temperatura-velocidad con map e histéresis
La curva temperatura-velocidad define qué velocidad se aplica a cada temperatura. La forma más simple es una curva lineal de dos puntos: velocidad mínima a la temperatura baja, velocidad máxima a la alta y una recta entre ambas. La función map() de Arduino hace justo eso; pero como trabaja con enteros, conviene convertir un valor como 31,6 °C en 316 para conservar la precisión. Como map también prolonga linealmente los valores fuera del rango, hay que limitar antes la entrada con constrain(); si no, a 60 °C obtendrías un valor absurdo por encima de 255. Los detalles de la función están en La función map de Arduino. La tabla siguiente muestra los valores de la curva para el rango 25–45 °C y una velocidad mínima del 20 %; la pendiente es del 4 % por grado.
| Temperatura | Velocidad del ventilador (%) | PWM de 8 bits (0–255) | OCR1A del Timer1 en Uno (0–320) |
|---|---|---|---|
| 25 °C o menos | 20 | 51 | 64 |
| 30 °C | 40 | 102 | 128 |
| 35 °C | 60 | 153 | 192 |
| 40 °C | 80 | 204 | 256 |
| 45 °C o más | 100 | 255 | 320 |
Ventilador de PC de 4 pines: PWM a 25 kHz y lectura del tacómetro
Los ventiladores de 4 pines siguen el estándar de Intel: pin 1 GND (negro), pin 2 +12 V (amarillo), pin 3 tacómetro (verde), pin 4 control PWM (azul). El ventilador siempre se alimenta con 12 V completos; la velocidad la fija la señal PWM de la línea azul, y el estándar pide para esa señal una frecuencia de 25 kHz (se aceptan 21–28 kHz). Dentro del ventilador hay una resistencia que sube la línea PWM, por lo que si la línea queda al aire, el ventilador gira a toda velocidad. La salida del tacómetro genera 2 pulsos por vuelta. Cuentas los pulsos con una interrupción y calculas las revoluciones con esta fórmula: RPM = (número de pulsos ÷ 2) × (60 ÷ tiempo de medición en segundos). Si contaste 40 pulsos en 1 segundo, el ventilador 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 función analogWrite de Arduino no puede generar 25 kHz, por eso configuramos el Timer1 directamente. Al elegir el modo 10 (PWM de fase correcta, valor máximo ICR1), la frecuencia es 16 MHz ÷ (2 × 1 × ICR1); con ICR1 = 320 se obtienen exactamente 25 kHz. El ciclo de trabajo se escribe en el registro OCR1A entre 0 y 320, así que cada paso equivale a un 0,3 % aproximadamente. La línea del tacómetro va a la interrupción INT0 en D2; en cada flanco descendente el contador sube uno. En loop se desactivan las interrupciones un instante para leer y poner a cero el contador con seguridad. Puedes encontrar la lógica de las interrupciones en Interrupciones en Arduino.
Control de ventilador con ESP32 (25 kHz con LEDC)
En el ESP32 el PWM se hace con la unidad LEDC y puedes fijar 25 kHz en una sola línea; gracias al reloj de 80 MHz, a esa frecuencia se obtiene sin problema una resolución de 8 bits. En el core de Arduino 3.x las funciones LEDC trabajan con el número de pin y en el 2.x con el número de canal; el código siguiente compila en ambas versiones gracias a la comprobación de ESP_ARDUINO_VERSION_MAJOR. En el ESP32 cualquier GPIO admite interrupciones; para el tacómetro usamos el GPIO 26 y protegemos el contador con una sección crítica (portMUX) para que no se acceda a él a la vez desde dentro y fuera de la interrupción. Si usas un ventilador de 2 hilos, conecta el GPIO 25 a la puerta de un MOSFET que conduzca por completo a 3,3 V y usa el mismo código; en ese caso ignora las líneas del tacómetro.
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}Control de ventilador con Raspberry Pi Pico y MicroPython
El hardware PWM de la Pico genera 25 kHz con facilidad y en MicroPython el ciclo de trabajo se da con 16 bits, entre 0 y 65535. Los módulos onewire y ds18x20 que necesita el DS18B20 vienen incluidos en la versión de MicroPython de la Pico, así que no tienes que copiar archivos extra. Contamos los pulsos del tacómetro con Pin.irq; desactivar las interrupciones un instante al leer el contador evita que el valor se actualice a medias. Si eres nuevo en MicroPython, Fundamentos de MicroPython es un buen punto de partida.
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)Consejos para que el ventilador funcione en silencio
- Sube la frecuencia PWM por encima del límite auditivo: el PWM predeterminado de 490 Hz produce un zumbido claro en las bobinas del ventilador. 31 kHz en un ventilador de 2 hilos y 25 kHz en uno de 4 pines eliminan por completo ese ruido.
- Cambia la velocidad con suavidad: en lugar de subir el ciclo del 30 % al 90 % de golpe, auméntalo solo unos pocos puntos por segundo; el oído nota mucho más los cambios bruscos de régimen que un rumor constante.
- Usa histéresis: si el ventilador se enciende y se apaga continuamente en la temperatura límite, oirás un clic en cada arranque y un ruido irregular; deja 2–3 °C entre los umbrales de encendido y apagado.
- Promedia la medición: las pequeñas oscilaciones del sensor hacen variar la velocidad. Promediar las últimas 5–10 mediciones tranquiliza la curva; para los métodos, consulta el artículo de filtrado de datos de sensores.
- Haz girar despacio un ventilador grande: uno de 120 mm a 800 RPM mueve un caudal de aire parecido al de uno de 80 mm a 2500 RPM, pero mucho más silencioso.
- Corta las vibraciones: monta el ventilador con tacos de goma o juntas de silicona y no pongas la rejilla ni el filtro demasiado cerca de las aspas; la vibración mecánica suele sonar más que el ruido eléctrico.
- Elige bien la velocidad mínima: encuentra probando el ciclo más bajo con el que el ventilador sigue girando y pon el límite inferior de la curva un poco por encima; un ventilador que gira arrastrándose en el límite hace un ruido irregular.
Ideas de proyectos con control de ventilador
- Termostato inteligente: un controlador que gestiona el calefactor con un relé y el ventilador con PWM; los detalles están en el artículo del termostato con Arduino.
- Refrigeración de cabina de impresora 3D: un extractor silencioso que mantiene el interior por debajo de 35 °C y muestra las RPM en pantalla; para la pantalla, mira la guía de la pantalla OLED.
- Ventilación de invernadero: ventiladores que trabajan junto con la temperatura y la humedad; el proyecto de invernadero inteligente es una buena base.
- Refrigeración de un Peltier: enfría el disipador de la cara caliente del módulo Peltier con un ventilador que acelera según la temperatura de esa cara; consulta el módulo Peltier.
- Domótica: con el ESP32, controla desde el móvil las RPM y la temperatura mediante MQTT y Home Assistant.
- Temperatura constante con PID: en lugar de una curva lineal, usa el control PID para montar un sistema de ventilación que mantenga una caja justo a 30 °C.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| El ventilador no gira | El GND no es común o el MOSFET no es de nivel lógico | Une los GND del adaptador y de Arduino y usa un MOSFET de la serie L como el IRLZ44N |
| El ventilador de 4 pines siempre va a máxima velocidad | La línea PWM está en el pin equivocado o al aire | Comprueba que el cable azul va a D9, GPIO 25 o GP16 y que el GND es común |
| El ventilador emite un zumbido agudo | PWM predeterminado de 490 Hz | Sube la frecuencia a 25–31 kHz |
| El ventilador se para a baja velocidad | El ciclo está por debajo del umbral de arranque del ventilador | Sube PWM_MIN y usa un pulso de arranque |
| Las RPM siempre marcan 0 | Falta la pull-up del tacómetro o el pin es incorrecto | Conecta los 10 kΩ a la tensión lógica y usa un pin con soporte de interrupciones |
| Las RPM son muy altas e inestables | Cable largo, ruido o PWM del lado bajo en un ventilador de 3 hilos | Acorta el cable, separa la línea del tacómetro del cable PWM; en un ventilador de 3 hilos lee las RPM solo a máxima velocidad |
| Arduino se reinicia al arrancar el ventilador | El ventilador y la placa comparten una fuente débil | Usa un adaptador de 12 V aparte para el ventilador y añade el diodo y un condensador de 100 µF |
| El MOSFET se calienta mucho | MOSFET de 5 V en una placa de 3,3 V o falta el diodo | Elige un MOSFET de umbral bajo como el AO3400 y pon el diodo de rueda libre |
El control de ventilador según la temperatura es uno de los temas más provechosos para aprender, porque reúne en un solo proyecto la lectura de sensores, el PWM, las interrupciones y la electrónica de potencia. Si empiezas con un ventilador sencillo de 2 hilos y pasas a uno de PC de 4 pines, habrás montado un sistema de refrigeración real que mide sus revoluciones y funciona en silencio. En la aplicación de BlueGrays puedes ver paso a paso, con esquemas y código, proyectos que sirven de base a este artículo, como la medición de temperatura con DHT11 y las aplicaciones de PWM con ESP32 y Pico.
Preguntas frecuentes
¿Cómo se controla un ventilador de 12 V con Arduino?
No puedes conectar un ventilador de 12 V directamente a un pin de Arduino; el pin da 5 V y como máximo unos 20 mA. Un ventilador de 2 hilos se conmuta por el lado bajo con un MOSFET de canal N de nivel lógico como el IRLZ44N y se le aplica PWM. En los de 4 pines, el ventilador se alimenta directamente con 12 V y Arduino solo maneja la línea PWM azul; en ambos casos los GND deben ser comunes.
¿Por qué el PWM de un ventilador de 4 pines debe ser de 25 kHz?
El estándar de ventiladores de 4 pines de Intel define para la señal de control un rango de 21–28 kHz y un objetivo de 25 kHz. Esa frecuencia queda por encima del límite del oído humano (unos 20 kHz), así que las bobinas no zumban. Muchos ventiladores no responden bien al PWM de 490 Hz de Arduino o hacen ruido con él.
¿Cómo se calculan las RPM de un ventilador?
La salida del tacómetro de los ventiladores de PC genera 2 pulsos por vuelta. Divides entre 2 los pulsos contados en un tiempo dado y lo pasas a minutos: RPM = pulsos ÷ 2 × 60 ÷ tiempo (segundos). Por ejemplo, si cuentas 50 pulsos en 1 segundo, el ventilador gira a 1500 RPM.
¿Se puede controlar un ventilador de 3 hilos con PWM?
Sí, puedes frenar un ventilador de 3 hilos aplicando PWM a su alimentación con un MOSFET, igual que uno de 2 hilos. Pero durante los instantes en que el PWM está apagado la electrónica del ventilador se queda sin energía, la señal del tacómetro se distorsiona y la lectura de RPM deja de ser fiable. Si quieres medir bien las revoluciones, usa un ventilador de 4 pines o baja la tensión del de 3 hilos con un convertidor DC-DC.
¿Por qué el ventilador se para o no arranca a baja velocidad?
Cada ventilador tiene un nivel mínimo de potencia con el que puede seguir girando y otro con el que puede arrancar desde parado; la mayoría de los de 12 V no arrancan por debajo de unos 5–7 V. La solución es poner el límite inferior de la curva un poco por encima de ese valor y arrancar el ventilador parado con un pulso de plena potencia de medio segundo. La mayoría de los ventiladores de 4 pines, en cambio, no se paran con ciclos bajos y siguen girando a su velocidad mínima.
¿Qué MOSFET se debe usar para controlar un ventilador?
En placas de 5 V como Arduino Uno van bien los MOSFET de nivel lógico como IRLZ44N, IRL540N o IRLB8721. Para la salida de 3,3 V del ESP32 y la Pico, elige piezas que conduzcan por completo con 2,5 V en la puerta, como el AO3400 o el IRLML2502. El IRFZ44N y el IRF540N necesitan 10 V en la puerta; con un microcontrolador quedan medio abiertos y se calientan.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Temperatura y humedad con DHT11
¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

ESP32 LED Fade con PWM
Cambiar el brillo del LED suavemente de 0 a max, de max a 0. Controlamos PWM con analogWrite() como en Arduino - la misma sintaxis con ESP32 Arduino Core 3.0+ funciona sin problemas. Pin definición + pinMode + analogWrite es suficiente.

Raspberry Pi Pico PWM LED Fade (Efecto Respiración)
¡El LED ya no solo parpadea — respira! Con el PWM (modulación por ancho de pulso) del Raspberry Pi Pico, el brillo sube y baja lentamente. Aprende la clase machine.PWM, duty_u16() (brillo de 16 bits 0–65535), la frecuencia PWM, bucles range() y salida tipo analógica. Base para mezcla de color RGB, control de motores, servos y buzzer.

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

Medición de temperatura con NTC y pantalla LCD 2x16
Mide la temperatura del ambiente con un sensor que parece una pequeña cuenta. Esta pieza, llamada NTC, deja pasar la electricidad con más facilidad cuanto más se calienta; el Arduino lee ese cambio…

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

Estación de riego inteligente
Un jardinero que riega solo tus plantas para que no se sequen mientras estás de vacaciones.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

