Controle de velocidade de ventoinha com Arduino: PWM conforme a temperatura
Controle de ventoinha com Arduino: acione uma ventoinha de 2 fios com MOSFET, use PWM de 25 kHz numa ventoinha de PC de 4 pinos e leia o RPM pelo tach. Código para Uno, ESP32 e Pico, com curva de velocidade.
O controle de velocidade de ventoinha com Arduino é o jeito mais prático de ajustar uma ventoinha automaticamente conforme a temperatura: um sensor mede o ambiente, o Arduino transforma essa leitura em uma velocidade e aciona a ventoinha com um sinal PWM. A ventoinha gira devagar e em silêncio quando está fresco, acelera à medida que o calor aumenta e não faz barulho à toa em velocidade máxima. Gabinetes de impressora 3D, caixas de fonte de alimentação, tampas de aquário, estufas e gabinetes de computador são os lugares onde esse método é mais usado.
Este guia mostra duas abordagens diferentes: acionar uma ventoinha simples de 2 fios com PWM por meio de um MOSFET de nível lógico e controlar uma ventoinha de PC de 4 pinos pela própria linha de controle com PWM de 25 kHz, lendo a velocidade pela saída tach (tacômetro). Você vai ver, passo a passo, código funcionando para Arduino Uno, ESP32 e Raspberry Pi Pico, como montar uma curva de temperatura-velocidade com map, a histerese e os truques para deixar a ventoinha realmente silenciosa.

O que é controle de ventoinha com Arduino e como funciona?
Ventoinhas de computador são motores CC sem escovas; um pequeno circuito driver interno energiza as bobinas em sequência. Há duas formas de mudar a velocidade de uma ventoinha: reduzir a tensão aplicada ou ligar e desligar a tensão muito rapidamente. O segundo método é o PWM, a língua nativa dos microcontroladores. Com um ciclo de trabalho (duty cycle) de 50%, a ventoinha recebe energia metade do tempo; a inércia da hélice suaviza esses pulsos e ela gira a mais ou menos metade da velocidade. Os fundamentos do PWM estão explicados em detalhes em O que é PWM?. O que mais importa é quantos fios a sua ventoinha tem, porque isso define o circuito que você vai montar.
| Característica | Ventoinha de 2 fios | Ventoinha de 3 fios | Ventoinha PWM de 4 pinos |
|---|---|---|---|
| Fios | Vermelho (+), preto (GND) | +, GND, tach amarelo ou verde | GND, +12 V, tach, PWM |
| Controle de velocidade | PWM na alimentação com MOSFET | PWM na alimentação ou redução da tensão | Linha PWM separada, 25 kHz |
| Leitura de velocidade | Não tem | Sim (fica corrompida durante o PWM) | Sim, independente do PWM |
| Peças extras necessárias | MOSFET, diodo, resistores | MOSFET, diodo, resistores | Só um pull-up de 10 kΩ |
| Velocidade mínima | Para abaixo de 30–40% de duty | Para abaixo de 30–40% de duty | Normalmente continua girando a 20–30% da velocidade |
| Uso típico | Ventoinhas de gabinete e de aparelhos | Ventoinhas de PC antigas | Ventoinhas modernas de PC e de CPU |
Acionando uma ventoinha de 2 fios com PWM por um MOSFET
Um pino do Arduino fornece 5 V e só consegue entregar com segurança cerca de 20 mA; ele não aciona diretamente uma ventoinha de 12 V que consome 0,1–0,3 A. Por isso colocamos um MOSFET de canal N no meio e o usamos como chave do lado baixo (low-side): o fio vermelho da ventoinha vai para os 12 V externos, o preto vai para o terminal dreno (D) do MOSFET e o terminal fonte (S) vai para o GND. O pino do Arduino aciona o gate (G) por um resistor de 220 Ω. Um resistor de 10 kΩ entre gate e fonte impede que a ventoinha ligue sozinha enquanto o Arduino inicializa ou reinicia. Um diodo entre os dois terminais da ventoinha, em polarização reversa (cátodo do lado dos +12 V), absorve o pico de tensão que a bobina do motor gera ao desligar. Explicamos com mais detalhes como um MOSFET funciona em MOSFET com Arduino.
| Componente | Valor recomendado | Função |
|---|---|---|
| MOSFET de canal N (Uno, 5 V) | IRLZ44N, IRL540N, IRLB8721 | Liga e desliga a linha GND da ventoinha com PWM |
| MOSFET de canal N (ESP32/Pico, 3,3 V) | AO3400, IRLML2502 | Conduz totalmente com tensão de gate de 3,3 V |
| Resistor de gate | 100–220 Ω | Limita a corrente do pino e reduz a oscilação (ringing) do sinal |
| Pull-down do gate | 10 kΩ (entre gate e fonte) | Mantém o MOSFET desligado ao ligar a placa |
| Diodo de roda livre (flyback) | 1N5819 (Schottky) ou 1N4007 | Absorve o pico de tensão gerado pela bobina |
| Alimentação | Fonte de 12 V, com pelo menos 2× a corrente da ventoinha | Alimenta a ventoinha independentemente do Arduino |
Tabela de ligações: Arduino Uno, ESP32 e Pico
A tabela abaixo cobre tanto a ligação direta de uma ventoinha de 4 pinos quanto o gate do MOSFET para uma ventoinha de 2 fios; nos dois circuitos o PWM sai do mesmo pino. Como sensor de temperatura usamos o DS18B20, que funciona em todas as placas e também existe em versão à prova d'água; os detalhes estão em Sensor de temperatura DS18B20.
| Ligação | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| PWM da ventoinha (azul) ou gate do MOSFET | D9 | GPIO 25 | GP16 |
| Tach da ventoinha (verde) + pull-up de 10 kΩ | D2 (pull-up para 5V) | GPIO 26 (pull-up para 3V3) | GP17 (pull-up para 3V3) |
| Dados do DS18B20 + pull-up de 4,7 kΩ | D4 | GPIO 4 | GP15 |
| DS18B20 VDD | 5V | 3V3 | 3V3 |
| Ventoinha +12 V (amarelo) | Fonte externa de 12 V | Fonte externa de 12 V | Fonte externa de 12 V |
| GND da ventoinha (preto) | GND (comum com a fonte) | GND (comum com a fonte) | GND (comum com a fonte) |
Passo a passo: acionando uma ventoinha de 2 fios conforme a temperatura (Arduino Uno)
- No Arduino IDE, instale as bibliotecas OneWire e DallasTemperature pelo Gerenciador de Bibliotecas.
- Ligue o DS18B20: VDD no 5V, GND no GND e o pino de dados no D4; coloque um resistor de 4,7 kΩ entre o pino de dados e o 5V.
- Monte o circuito do MOSFET: fio vermelho da ventoinha nos +12 V, preto no dreno, fonte no GND, gate no D9 por um resistor de 220 Ω e 10 kΩ entre gate e fonte.
- Coloque o diodo nos terminais da ventoinha em polarização reversa: o lado do cátodo, com a faixa, nos +12 V e o outro lado no fio preto da ventoinha.
- Ligue o GND da fonte ao GND do Arduino, carregue o código e abra o Monitor Serial a 9600 baud.
- Aqueça o sensor com os dedos; quando passar de 30 °C, observe a ventoinha partir com um pulso curto de potência máxima e depois acelerar junto com a 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}| Linha / ajuste | Para que serve? |
|---|---|
| TCCR1B = (TCCR1B & 0b11111000) | 0x01 (prescaler do Timer1) | Coloca o prescaler do Timer1 em 1; o PWM nos pinos D9 e D10 sobe de 490 Hz para cerca de 31,4 kHz e o chiado da ventoinha deixa de ser audível |
| T_ON / T_OFF (limites de liga/desliga) | Histerese: a ventoinha liga a 30 °C, mas só desliga quando a temperatura cai para 27 °C; nada de liga-desliga na temperatura limite |
| map(...) (conversão de faixa) | Mapeia linearmente a faixa de 27–45 °C para a faixa de PWM 80–255; os valores são multiplicados por 10 para não perder a parte decimal |
| PWM_MIN = 80 (PWM mínimo) | O menor valor com que a ventoinha continua girando (cerca de 31%); descubra por teste para a sua ventoinha |
| Pulso de partida | Com a ventoinha parada, primeiro aplica-se potência máxima por 0,5 segundo; assim, ventoinhas que não partem com duty baixo começam com segurança |
| DEVICE_DISCONNECTED_C (sensor desconectado) | Se o sensor se soltar ou não puder ser lido, a ventoinha vai para a velocidade máxima; em caso de falha, o aparelho não superaquece |
Curva de temperatura-velocidade com map e histerese
Uma curva de temperatura-velocidade define qual velocidade aplicar em cada temperatura. A forma mais simples é uma curva linear de dois pontos: velocidade mínima na temperatura inferior, velocidade máxima na temperatura superior e uma linha reta entre elas. A função map() do Arduino faz exatamente isso; mas, como trabalha com inteiros, converter um valor como 31,6 °C em 316 antes de passá-lo preserva a precisão. Como o map também estende linearmente valores fora da faixa, é preciso limitar a entrada antes com constrain(); senão, a 60 °C você teria um valor sem sentido acima de 255. Os detalhes da função estão em Função map do Arduino. A tabela abaixo mostra os valores da curva para uma faixa de 25–45 °C e velocidade mínima de 20%; a inclinação é de 4% por grau.
| Temperatura | Velocidade da ventoinha (%) | PWM de 8 bits (0–255) | Uno Timer1 OCR1A (0–320) |
|---|---|---|---|
| 25 °C ou menos | 20 | 51 | 64 |
| 30 °C | 40 | 102 | 128 |
| 35 °C | 60 | 153 | 192 |
| 40 °C | 80 | 204 | 256 |
| 45 °C ou mais | 100 | 255 | 320 |
Ventoinha de PC de 4 pinos: PWM de 25 kHz e leitura do tach
Ventoinhas de 4 pinos seguem o padrão de ventoinhas da Intel: o pino 1 é GND (preto), o pino 2 é +12 V (amarelo), o pino 3 é tach (verde) e o pino 4 é o controle PWM (azul). A ventoinha é sempre alimentada com os 12 V completos; quem define a velocidade é o sinal PWM na linha azul, e o padrão pede uma frequência de 25 kHz para esse sinal (de 21–28 kHz é aceito). Dentro da ventoinha há um resistor que puxa a linha PWM para cima, por isso, se a linha ficar solta, a ventoinha gira na velocidade máxima. A saída tach gera 2 pulsos por volta. Você conta os pulsos com uma interrupção e calcula a velocidade com esta fórmula: RPM = (número de pulsos ÷ 2) × (60 ÷ tempo de medição em segundos). Se contar 40 pulsos em 1 segundo, a ventoinha está girando 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}A função analogWrite do Arduino não consegue gerar 25 kHz, por isso configuramos o Timer1 diretamente. Com o modo 10 (PWM com correção de fase, valor de topo ICR1), a frequência é 16 MHz ÷ (2 × 1 × ICR1); ICR1 = 320 dá exatamente 25 kHz. O valor de duty é escrito no registrador OCR1A entre 0 e 320, então cada passo equivale a cerca de 0,3%. A linha tach está ligada à interrupção INT0 no D2; o contador aumenta em um a cada borda de descida. No loop, as interrupções são desativadas por um instante bem curto para que o contador possa ser lido e zerado com segurança. A lógica das interrupções está em Interrupções no Arduino.
Controle de ventoinha com ESP32 (25 kHz com LEDC)
No ESP32, o PWM é feito pela unidade LEDC, e dá para configurar 25 kHz em uma única linha; graças ao clock de 80 MHz, a resolução de 8 bits é obtida com folga nessa frequência. No core do Arduino 3.x as funções LEDC trabalham com o número do pino, enquanto na 2.x trabalham com o número do canal; o código abaixo compila nas duas versões graças a uma verificação de ESP_ARDUINO_VERSION_MAJOR. No ESP32 qualquer GPIO aceita interrupção; usamos o GPIO 26 para o tach e protegemos o contador com uma seção crítica (portMUX) para que ele não seja acessado ao mesmo tempo de dentro e de fora da interrupção. Se você usar uma ventoinha de 2 fios, pode ligar o GPIO 25 ao gate de um MOSFET que conduza totalmente com 3,3 V e usar o mesmo código; nesse caso, ignore as linhas do tach.
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}Controle de ventoinha com Raspberry Pi Pico e MicroPython
O hardware de PWM do Pico gera 25 kHz com facilidade, e no MicroPython o valor de duty é dado em 16 bits, entre 0 e 65535. Os módulos onewire e ds18x20 necessários para o DS18B20 já vêm na versão do MicroPython para o Pico, então você não precisa copiar nenhum arquivo extra. Contamos os pulsos do tach com Pin.irq; desativar as interrupções por um instante bem curto durante a leitura do contador evita que o valor seja lido pela metade da atualização. Se você é novo no MicroPython, Fundamentos de MicroPython é um bom ponto 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)Dicas para deixar a ventoinha silenciosa
- Leve a frequência do PWM para acima do limite da audição: o PWM padrão de 490 Hz cria um chiado nítido nas bobinas da ventoinha. 31 kHz numa ventoinha de 2 fios e 25 kHz numa de 4 pinos eliminam esse ruído por completo.
- Mude a velocidade aos poucos: em vez de saltar o duty de 30% para 90% de uma vez, aumente só alguns por cento por segundo; o ouvido humano percebe mudanças bruscas de rotação muito mais do que um zumbido constante.
- Use histerese: se a ventoinha fica ligando e desligando na temperatura limite, você ouve um clique a cada partida e um ruído oscilante; deixe 2–3 °C entre os limites de ligar e desligar.
- Tire a média da medição: pequenas oscilações no valor do sensor fazem a velocidade da ventoinha variar. Tirar a média das últimas 5–10 leituras acalma a curva; para métodos, veja o post sobre filtragem de dados de sensores.
- Use uma ventoinha grande girando devagar: uma ventoinha de 120 mm a 800 RPM move mais ou menos tanto ar quanto uma de 80 mm a 2500 RPM, e com muito menos barulho.
- Corte a vibração: monte a ventoinha com coxins de borracha ou uma junta de silicone e não coloque a grade e o filtro muito perto da hélice; a vibração mecânica costuma ser mais alta que o ruído elétrico.
- Escolha bem a velocidade mínima: descubra por teste o menor valor de duty com que a ventoinha continua girando e coloque o limite inferior da curva um pouco acima dele; uma ventoinha se arrastando no limite faz um som irregular.
Ideias de projetos com controle de ventoinha
- Termostato inteligente: um controlador que comanda o aquecedor com um relé e a ventoinha com PWM; os detalhes estão no post termostato com Arduino.
- Refrigeração do gabinete da impressora 3D: uma ventoinha de exaustão silenciosa que mantém o interior do gabinete abaixo de 35 °C e mostra a rotação em uma tela; para a tela, veja o guia do display OLED de 0,96 polegada.
- Ventilação de estufa: ventoinhas que trabalham junto com temperatura e umidade; o projeto de estufa inteligente é uma boa base para isso.
- Refrigerador Peltier: resfrie o dissipador do lado quente de um módulo Peltier com uma ventoinha que acelera conforme a temperatura desse lado; veja o módulo Peltier.
- Automação residencial: acompanhe a rotação da ventoinha e a temperatura pelo celular com um ESP32, via MQTT e Home Assistant.
- Temperatura constante com PID: em vez de uma curva linear, use controle PID para montar um sistema de ventoinha que mantém uma caixa a exatamente 30 °C.
Erros comuns e como corrigir
| Sintoma | Causa provável | Solução |
|---|---|---|
| A ventoinha não gira de jeito nenhum | O GND não é comum ou o MOSFET não é de nível lógico | Ligue juntos os GNDs da fonte e do Arduino e use um MOSFET da série L, como o IRLZ44N |
| A ventoinha de 4 pinos fica sempre na velocidade máxima | A linha PWM está no pino errado ou solta | Confira se o fio azul vai para D9, GPIO 25 ou GP16 e se o GND é comum |
| Sai um chiado fino da ventoinha | PWM padrão de 490 Hz | Suba a frequência para 25–31 kHz |
| A ventoinha para em baixa velocidade | O duty está abaixo do limite de partida da ventoinha | Aumente o PWM_MIN e use um pulso de partida |
| O RPM mostra sempre 0 | Falta o resistor de pull-up do tach ou o pino está errado | Ligue os 10 kΩ à tensão lógica e use um pino que aceite interrupção |
| Os valores de RPM são muito altos e instáveis | Fio longo, ruído ou PWM do lado baixo numa ventoinha de 3 fios | Encurte o fio e separe a linha tach do fio de PWM; numa ventoinha de 3 fios, leia a rotação só na velocidade máxima |
| O Arduino reinicia quando a ventoinha parte | Ventoinha e placa estão alimentadas pela mesma fonte fraca | Use uma fonte de 12 V separada para a ventoinha e acrescente um diodo e um capacitor de 100 µF |
| O MOSFET esquenta muito | MOSFET de 5 V numa placa de 3,3 V, ou falta o diodo | Escolha um MOSFET de limiar baixo, como o AO3400, e coloque o diodo de roda livre |
O controle de ventoinha por temperatura é um dos temas mais proveitosos para aprender, porque reúne leitura de sensor, PWM, interrupções e eletrônica de potência em um único projeto. Comece com uma ventoinha simples de 2 fios e, quando passar para uma ventoinha de PC de 4 pinos, terá montado um sistema de refrigeração de verdade, que mede a própria rotação e funciona em silêncio. No app BlueGrays você pode seguir passo a passo, com esquemas do circuito e códigos, os projetos que servem de base para este post, como medir temperatura com o DHT11 e aplicações de PWM com ESP32 e Pico.
Perguntas frequentes
Como controlar uma ventoinha de 12 V com Arduino?
Não dá para ligar uma ventoinha de 12 V diretamente num pino do Arduino; o pino fornece 5 V e entrega no máximo cerca de 20 mA. Numa ventoinha de 2 fios, você faz o chaveamento do lado baixo com um MOSFET de canal N de nível lógico, como o IRLZ44N, e aplica PWM. Numa ventoinha de 4 pinos, ela é alimentada direto com 12 V e o Arduino só aciona a linha PWM azul; nos dois casos, os GNDs precisam ser comuns.
Por que a frequência do PWM de uma ventoinha de 4 pinos deve ser 25 kHz?
O padrão de ventoinhas de 4 pinos da Intel define a faixa de 21–28 kHz para o sinal de controle, com 25 kHz como alvo. Como essa frequência fica acima do limite da audição humana (cerca de 20 kHz), não sai chiado das bobinas. Muitas ventoinhas não respondem direito ao PWM padrão de 490 Hz do Arduino, ou fazem barulho.
Como calcular o RPM da ventoinha?
A saída tach das ventoinhas de PC gera 2 pulsos por volta. Você divide por 2 o número de pulsos contados em um certo tempo e converte para minutos: RPM = pulsos ÷ 2 × 60 ÷ tempo (segundos). Por exemplo, se forem contados 50 pulsos em 1 segundo, a ventoinha está girando a 1500 RPM.
Dá para controlar uma ventoinha de 3 fios com PWM?
Sim, você pode reduzir a velocidade de uma ventoinha de 3 fios aplicando PWM na alimentação com um MOSFET, igual a uma de 2 fios. Porém, como a eletrônica da ventoinha fica sem energia nos intervalos desligados do PWM, o sinal tach fica corrompido e a leitura de rotação deixa de ser confiável. Se quiser medir a rotação com precisão, use uma ventoinha de 4 pinos ou reduza a tensão da ventoinha de 3 fios com um conversor CC-CC.
Por que a ventoinha para ou não parte em baixa velocidade?
Toda ventoinha tem um nível mínimo de potência com que consegue continuar girando e partir do repouso; a maioria das ventoinhas de 12 V não parte abaixo de cerca de 5–7 V. A solução é colocar o limite inferior da curva um pouco acima desse valor e, com a ventoinha parada, dar a partida com um pulso de potência máxima de meio segundo. A maioria das ventoinhas de 4 pinos não para com duty baixo; elas continuam girando na velocidade mínima.
Qual MOSFET usar para controle de ventoinha?
Em placas de 5 V como o Arduino Uno, servem MOSFETs de nível lógico como o IRLZ44N, o IRL540N ou o IRLB8721. Para a saída de 3,3 V do ESP32 e do Pico, escolha peças que conduzam totalmente com tensão de gate de 2,5 V, como o AO3400 ou o IRLML2502. O IRFZ44N e o IRF540N precisam de 10 V no gate; usados com um microcontrolador, ficam meio abertos e esquentam.
Projetos para montar depois desta leitura
Ver todos os projetos
Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Variação gradual do brilho do LED com PWM no ESP32
Varie suavemente o brilho do LED de 0 ao máximo e do máximo a 0. Controlamos o PWM com analogWrite(), como no Arduino. A mesma sintaxe funciona sem problemas com ESP32 Arduino Core 3.0+. Basta definir o pino e usar pinMode e analogWrite.

Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
O LED não só pisca — ele respira! Com o PWM (modulação por largura de pulso) do Raspberry Pi Pico, o brilho do LED aumenta e diminui lentamente, como a luz de um MacBook em repouso. Aprenda a usar a classe machine.PWM, duty_u16() (brilho de 16 bits, de 0–65535), frequência PWM (freq(1000) — 1.000 ciclos de ligar/desligar por segundo, sem cintilação visível), laços com passos usando range() (crescentes e decrescentes) e saída semelhante à analógica em um pino digital.

Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
Neste projeto, controlamos o brilho de um LED de forma analógica com um potenciômetro. O pino ADC do ESP32 lê a tensão de 0-3,3V do potenciômetro e converte esse valor em um sinal PWM (modulação por largura de pulso), enviado ao LED. Assim, ao girar o potenciômetro, o brilho do LED aumenta e diminui gradualmente. Com Arduino Core 3.0+, você pode usar analogWrite() diretamente; no ESP32-S2/S3, a resolução do ADC é fixada em 12 bits.

Medição de temperatura com NTC e display LCD 2x16
Meça a temperatura ao seu redor com um sensor que parece uma pequena conta. Esse componente, chamado NTC, deixa a eletricidade passar com mais facilidade à medida que aquece; o Arduino lê essa…

Temperatura e umidade com ESP32 e DHT22 (com display LCD)
Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

Estação de irrigação inteligente
Um jardineiro que rega suas plantas sozinho para que elas não sequem enquanto você está de férias.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

