Guias · 12 min de leitura

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.

Sensor de temperatura digital DS18B20
DS18B20: um sensor de temperatura digital com um único fio de dados e precisão de ±0,5 °C. É ele que mede a temperatura para o controle da ventoinha neste post.

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ísticaVentoinha de 2 fiosVentoinha de 3 fiosVentoinha PWM de 4 pinos
FiosVermelho (+), preto (GND)+, GND, tach amarelo ou verdeGND, +12 V, tach, PWM
Controle de velocidadePWM na alimentação com MOSFETPWM na alimentação ou redução da tensãoLinha PWM separada, 25 kHz
Leitura de velocidadeNão temSim (fica corrompida durante o PWM)Sim, independente do PWM
Peças extras necessáriasMOSFET, diodo, resistoresMOSFET, diodo, resistoresSó um pull-up de 10 kΩ
Velocidade mínimaPara abaixo de 30–40% de dutyPara abaixo de 30–40% de dutyNormalmente continua girando a 20–30% da velocidade
Uso típicoVentoinhas de gabinete e de aparelhosVentoinhas de PC antigasVentoinhas 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.

ComponenteValor recomendadoFunção
MOSFET de canal N (Uno, 5 V)IRLZ44N, IRL540N, IRLB8721Liga e desliga a linha GND da ventoinha com PWM
MOSFET de canal N (ESP32/Pico, 3,3 V)AO3400, IRLML2502Conduz totalmente com tensão de gate de 3,3 V
Resistor de gate100–220 ΩLimita a corrente do pino e reduz a oscilação (ringing) do sinal
Pull-down do gate10 kΩ (entre gate e fonte)Mantém o MOSFET desligado ao ligar a placa
Diodo de roda livre (flyback)1N5819 (Schottky) ou 1N4007Absorve o pico de tensão gerado pela bobina
AlimentaçãoFonte de 12 V, com pelo menos 2× a corrente da ventoinhaAlimenta a ventoinha independentemente do Arduino
O erro mais comum é usar MOSFETs que não são de nível lógico, como o IRFZ44N ou o IRF540N. Essas peças são projetadas para tensão de gate de 10 V; com 5 V ficam meio abertas, a ventoinha gira devagar e o MOSFET esquenta. Escolha os que têm a letra L no nome (IRLZ44N, IRL540N). Além disso, o GND do Arduino e o GND da fonte de 12 V precisam estar ligados juntos; sem GND comum, o sinal PWM fica sem referência e a ventoinha ou não gira, ou se comporta de forma aleatória.

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çãoArduino UnoESP32Raspberry Pi Pico
PWM da ventoinha (azul) ou gate do MOSFETD9GPIO 25GP16
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ΩD4GPIO 4GP15
DS18B20 VDD5V3V33V3
Ventoinha +12 V (amarelo)Fonte externa de 12 VFonte externa de 12 VFonte externa de 12 V
GND da ventoinha (preto)GND (comum com a fonte)GND (comum com a fonte)GND (comum com a fonte)
Nunca ligue o resistor de pull-up da linha tach aos 12 V. A saída tach é de coletor aberto; a ventoinha só puxa essa linha para o GND, e quem define o nível alto é o seu resistor de pull-up. Puxar para 12 V força a entrada do Arduino, e os pinos de 3,3 V do ESP32 e do Pico podem queimar na hora. Sempre ligue o resistor de pull-up à tensão lógica da própria placa (5 V no Uno, 3,3 V no ESP32 e no Pico).

Passo a passo: acionando uma ventoinha de 2 fios conforme a temperatura (Arduino Uno)

  1. No Arduino IDE, instale as bibliotecas OneWire e DallasTemperature pelo Gerenciador de Bibliotecas.
  2. 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.
  3. 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.
  4. 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.
  5. Ligue o GND da fonte ao GND do Arduino, carregue o código e abra o Monitor Serial a 9600 baud.
  6. 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.
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}
Linha / ajustePara 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 partidaCom 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.

TemperaturaVelocidade da ventoinha (%)PWM de 8 bits (0–255)Uno Timer1 OCR1A (0–320)
25 °C ou menos205164
30 °C40102128
35 °C60153192
40 °C80204256
45 °C ou mais100255320

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.

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}

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.

Configurar o Timer1 dessa forma desativa o analogWrite nos pinos D9 e D10 e a biblioteca Servo, que usa o Timer1. Se o seu projeto também tem um servo, deixe a ventoinha no Timer1 e passe o servo para uma biblioteca que use o Timer2, como a ServoTimer2, ou leve o projeto para um ESP32. Além disso, a maioria das ventoinhas de 4 pinos continua girando na velocidade mínima mesmo com 0% de duty; se quiser parar a ventoinha por completo, é preciso cortar a alimentação de 12 V com um MOSFET de canal P separado ou um relé.

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.

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}

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.

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)

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

SintomaCausa provávelSolução
A ventoinha não gira de jeito nenhumO GND não é comum ou o MOSFET não é de nível lógicoLigue 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áximaA linha PWM está no pino errado ou soltaConfira se o fio azul vai para D9, GPIO 25 ou GP16 e se o GND é comum
Sai um chiado fino da ventoinhaPWM padrão de 490 HzSuba a frequência para 25–31 kHz
A ventoinha para em baixa velocidadeO duty está abaixo do limite de partida da ventoinhaAumente o PWM_MIN e use um pulso de partida
O RPM mostra sempre 0Falta o resistor de pull-up do tach ou o pino está erradoLigue 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áveisFio longo, ruído ou PWM do lado baixo numa ventoinha de 3 fiosEncurte 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 parteVentoinha e placa estão alimentadas pela mesma fonte fracaUse uma fonte de 12 V separada para a ventoinha e acrescente um diodo e um capacitor de 100 µF
O MOSFET esquenta muitoMOSFET de 5 V numa placa de 3,3 V, ou falta o diodoEscolha um MOSFET de limiar baixo, como o AO3400, e coloque o diodo de roda livre
Para descobrir o valor mínimo com que a sua ventoinha gira, faça um teste rápido: comece com 100% de duty, reduza 5% a cada 3 segundos e acompanhe o RPM no Monitor Serial. Um valor 5–10% acima do ponto em que a rotação cai a zero é uma escolha segura para o limite inferior da curva. Numa ventoinha de 2 fios sem saída tach, dá para fazer o mesmo teste olhando e ouvindo.

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.

Ver todos os projetos
Temperatura e umidade com DHT11
AR-55Intermediário

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…

4.7(47)
83
Variação gradual do brilho do LED com PWM no ESP32
ES-8Iniciante

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.

4.8(36)
55
Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
PI-14Iniciante

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.

4
Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
ES-13Intermediário
Premium

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.

4.5(19)
32
Medição de temperatura com NTC e display LCD 2x16
AR-44Iniciante
Premium

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…

4.5(33)
44
Temperatura e umidade com ESP32 e DHT22 (com display LCD)
ES-15Intermediário

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.

4.8(38)
57
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

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.

4.7(7)
12
Estação de irrigação inteligente
AR-83Avançado
Premium

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.

5.0(42)
57