Gidsen · 11 min leestijd

Arduino-ventilatorsnelheid regelen: temperatuurgestuurde PWM-ventilatorbesturing

Ventilatorsnelheid regelen met Arduino: stuur een ventilator met 2 draden aan via een MOSFET, gebruik een pc-ventilator met 4 pinnen op 25 kHz PWM en lees het toerental af via de tach. Code voor Uno, ESP32 en Pico, plus een curve.

Ventilatorsnelheid regelen met Arduino is de handigste manier om een ventilator automatisch op temperatuur af te stemmen: een sensor meet de omgeving, de Arduino zet die waarde om in een snelheid en stuurt de ventilator aan met een PWM-signaal. De ventilator draait langzaam en stil als het koel is, versnelt naarmate de warmte stijgt en maakt op volle snelheid geen onnodig lawaai. Behuizingen van 3D-printers, voedingskasten, aquariumdeksels, kassen en computerbehuizingen zijn de plekken waar deze methode het vaakst wordt gebruikt.

Deze gids behandelt twee aanpakken: een eenvoudige ventilator met 2 draden aansturen met PWM via een logic-level MOSFET, en een pc-ventilator met 4 pinnen regelen via de eigen regellijn met 25 kHz PWM, terwijl je de snelheid afleest van de tach-uitgang (toerenteller). Je doorloopt stap voor stap werkende code voor de Arduino Uno, ESP32 en Raspberry Pi Pico, bouwt een temperatuur-snelheidscurve met map en hysterese, en leert de trucs om de ventilator echt stil te laten draaien.

DS18B20 digitale temperatuursensor
DS18B20: een digitale temperatuursensor met één datadraad en een nauwkeurigheid van ±0,5 °C. We gebruiken hem in dit artikel om de temperatuur te meten voor de ventilatorregeling.

Wat is ventilatorregeling met Arduino en hoe werkt het?

Computerventilatoren zijn borstelloze gelijkstroommotoren; een kleine driverschakeling binnenin bekrachtigt de spoelen om de beurt. Je kunt de snelheid van een ventilator op twee manieren veranderen: de aangelegde spanning verlagen, of de spanning heel snel aan- en uitschakelen. De tweede methode is PWM en dat is de moedertaal van microcontrollers. Bij een duty cycle van 50% krijgt de ventilator de helft van de tijd stroom; de traagheid van de schroef egaliseert deze pulsen en de ventilator draait op ongeveer de halve snelheid. De basis van PWM vind je uitgebreid in Wat is PWM?. Het belangrijkste is hoeveel draden je ventilator heeft, want dat bepaalt welke schakeling je bouwt.

EigenschapVentilator met 2 dradenVentilator met 3 dradenPWM-ventilator met 4 pinnen
DradenRood (+), zwart (GND)+, GND, gele of groene tachGND, +12 V, tach, PWM
SnelheidsregelingDe voeding pulseren met een MOSFETDe voeding pulseren of de spanning verlagenAparte PWM-lijn, 25 kHz
Toerental aflezenNiet mogelijkJa (wordt verstoord tijdens PWM)Ja, onafhankelijk van PWM
Extra onderdelen nodigMOSFET, diode, weerstandenMOSFET, diode, weerstandenAlleen een pull-upweerstand van 10 kΩ
Laagste snelheidStopt onder 30–40% dutyStopt onder 30–40% dutyBlijft meestal draaien op 20–30% snelheid
Typisch gebruikBehuizings- en apparaatventilatorenOude pc-ventilatorenModerne pc- en cpu-ventilatoren

Een ventilator met 2 draden aansturen met PWM via een MOSFET

Een Arduino-pin geeft 5 V en kan veilig maar ongeveer 20 mA leveren; hij kan een ventilator van 12 V die 0,1–0,3 A trekt niet direct aansturen. Daarom plaatsen we er een N-kanaals MOSFET tussen en gebruiken we die als low-side-schakelaar: de rode draad van de ventilator gaat naar de externe 12 V, de zwarte draad naar de drain (D) van de MOSFET en de source (S) gaat naar GND. De Arduino-pin stuurt de gate (G) aan via een weerstand van 220 Ω. Een weerstand van 10 kΩ tussen gate en source voorkomt dat de ventilator uit zichzelf gaat draaien terwijl de Arduino opstart of reset. Een diode over de twee aansluitingen van de ventilator, in sperrichting (kathode aan de +12 V-kant), vangt de spanningspiek op die de motorspoel maakt bij het uitschakelen. Hoe een MOSFET werkt leggen we uitgebreider uit in Een MOSFET gebruiken met Arduino.

OnderdeelAanbevolen waardeDoel
N-kanaals MOSFET (Uno, 5 V)IRLZ44N, IRL540N, IRLB8721Schakelt de GND-lijn van de ventilator met PWM aan en uit
N-kanaals MOSFET (ESP32/Pico, 3,3 V)AO3400, IRLML2502Gaat volledig open bij een gatespanning van 3,3 V
Gateweerstand100–220 ΩBeperkt de pinstroom en vermindert rinkelen in het signaal
Gate pull-down10 kΩ (tussen gate en source)Houdt de MOSFET uit bij het opstarten
Vrijloopdiode1N5819 (Schottky) of 1N4007Vangt de spanningspiek van de spoel op
Voeding12 V-adapter, minstens 2× de stroom van de ventilatorVoedt de ventilator onafhankelijk van de Arduino
De meest gemaakte fout is het gebruik van MOSFETs die geen logic-level zijn, zoals de IRFZ44N of IRF540N. Deze onderdelen zijn ontworpen voor een gatespanning van 10 V; bij 5 V blijven ze half open, de ventilator draait langzaam en de MOSFET wordt heet. Kies types met de letter L in de naam (IRLZ44N, IRL540N). Ook moeten de GND van de Arduino en de GND van de 12 V-adapter met elkaar verbonden zijn; zonder gemeenschappelijke massa heeft het PWM-signaal geen referentie en draait de ventilator helemaal niet of willekeurig.

Bedradingstabel: Arduino Uno, ESP32 en Pico

De onderstaande tabel behandelt zowel de directe aansluiting van een ventilator met 4 pinnen als de MOSFET-gate voor een ventilator met 2 draden; in beide schakelingen komt de PWM van dezelfde pin. Als temperatuursensor gebruiken we de DS18B20, die op alle boards werkt en ook in een waterdichte uitvoering bestaat; details staan in DS18B20-temperatuursensor.

AansluitingArduino UnoESP32Raspberry Pi Pico
Ventilator-PWM (blauw) of MOSFET-gateD9GPIO 25GP16
Ventilator-tach (groen) + pull-up van 10 kΩD2 (pull-up naar 5V)GPIO 26 (pull-up naar 3V3)GP17 (pull-up naar 3V3)
DS18B20-data + pull-up van 4,7 kΩD4GPIO 4GP15
DS18B20 VDD5V3V33V3
Ventilator +12 V (geel)Externe 12 V-adapterExterne 12 V-adapterExterne 12 V-adapter
Ventilator-GND (zwart)GND (gemeenschappelijk met adapter)GND (gemeenschappelijk met adapter)GND (gemeenschappelijk met adapter)
Sluit de pull-upweerstand van de tach-lijn nooit aan op 12 V. De tach-uitgang is open collector; de ventilator trekt deze lijn alleen naar GND en jouw pull-upweerstand bepaalt het hoge niveau. Optrekken naar 12 V belast de ingang van de Arduino en de 3,3 V-pins van de ESP32 en Pico kunnen direct doorbranden. Sluit de pull-upweerstand altijd aan op de eigen logicaspanning van het board (5 V voor de Uno, 3,3 V voor de ESP32 en Pico).

Stap voor stap: een ventilator met 2 draden op temperatuur aansturen (Arduino Uno)

  1. Installeer in de Arduino IDE de bibliotheken OneWire en DallasTemperature via de Library Manager.
  2. Sluit de DS18B20 aan: VDD op 5V, GND op GND, de datapin op D4; plaats een weerstand van 4,7 kΩ tussen de datapin en 5V.
  3. Bouw de MOSFET-schakeling: de rode draad van de ventilator naar +12 V, zwart naar de drain, source naar GND, gate via 220 Ω naar D9 en 10 kΩ tussen gate en source.
  4. Plaats de diode in sperrichting over de aansluitingen van de ventilator: het kathode-uiteinde met de streep naar +12 V, het andere uiteinde naar de zwarte draad van de ventilator.
  5. Verbind de GND van de adapter met de GND van de Arduino, upload de code en open de Serial Monitor op 9600 baud.
  6. Verwarm de sensor met je vingers; zodra hij boven 30 °C komt, zie je de ventilator starten met een korte puls op volle kracht en daarna versnellen met de temperatuur.
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}
Regel / instellingWat het doet
TCCR1B = (TCCR1B & 0b11111000) | 0x01Zet de prescaler van Timer1 op 1; PWM op D9 en D10 gaat van 490 Hz naar ongeveer 31,4 kHz en het gejank van de ventilator wordt onhoorbaar
T_ON / T_OFFHysterese: de ventilator gaat aan bij 30 °C maar pas uit als de temperatuur daalt tot 27 °C; geen aan-uitgefladder rond de drempeltemperatuur
map(...)Wijst het bereik 27–45 °C lineair toe aan het PWM-bereik 80–255; de waarden worden met 10 vermenigvuldigd zodat het decimale deel niet verloren gaat
PWM_MIN = 80De laagste waarde waarbij de ventilator blijft draaien (ongeveer 31%); zoek die proefondervindelijk op voor je eigen ventilator
KickstartAls de ventilator stilstaat, wordt eerst 0,5 seconde volle kracht gegeven; ventilatoren die niet starten bij lage duty beginnen zo veilig te draaien
DEVICE_DISCONNECTED_CAls de sensor losraakt of niet gelezen kan worden, gaat de ventilator op volle snelheid; het apparaat raakt niet oververhit bij een storing

Temperatuur-snelheidscurve met map en hysterese

Een temperatuur-snelheidscurve bepaalt welke snelheid bij welke temperatuur hoort. De eenvoudigste vorm is een lineaire curve met twee punten: de laagste snelheid bij de lage temperatuur, volle snelheid bij de hoge temperatuur en een rechte lijn ertussen. De functie map() van Arduino doet precies dit; maar omdat hij met gehele getallen werkt, behoud je de precisie door een waarde als 31,6 °C vooraf om te zetten naar 316. Omdat map ook waarden buiten het bereik lineair doortrekt, moet je de invoer eerst begrenzen met constrain(); anders krijg je bij 60 °C een betekenisloze waarde boven 255. De details van de functie staan in Arduino map-functie. De onderstaande tabel toont de waarden die de curve aanneemt voor een bereik van 25–45 °C en een minimumsnelheid van 20%; de helling is 4% per graad.

TemperatuurVentilatorsnelheid (%)8-bits PWM (0–255)Uno Timer1 OCR1A (0–320)
25 °C en lager205164
30 °C40102128
35 °C60153192
40 °C80204256
45 °C en hoger100255320

Pc-ventilator met 4 pinnen: 25 kHz PWM en de tach uitlezen

Ventilatoren met 4 pinnen volgen de ventilatorstandaard van Intel: pin 1 is GND (zwart), pin 2 is +12 V (geel), pin 3 is tach (groen), pin 4 is PWM-regeling (blauw). De ventilator wordt altijd met de volle 12 V gevoed; het PWM-signaal op de blauwe lijn bepaalt de snelheid en de standaard vraagt voor dit signaal een frequentie van 25 kHz (21–28 kHz wordt geaccepteerd). In de ventilator zit een weerstand die de PWM-lijn optrekt, dus als de lijn zweeft draait de ventilator op volle snelheid. De tach-uitgang geeft 2 pulsen per omwenteling. Je telt de pulsen met een interrupt en berekent de snelheid met deze formule: RPM = (aantal pulsen ÷ 2) × (60 ÷ meettijd in seconden). Als je 40 pulsen in 1 seconde telt, draait de ventilator op 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}

De functie analogWrite van Arduino kan geen 25 kHz maken, dus configureren we Timer1 rechtstreeks. Bij modus 10 (phase-correct PWM, topwaarde ICR1) is de frequentie 16 MHz ÷ (2 × 1 × ICR1); ICR1 = 320 geeft precies 25 kHz. De dutywaarde wordt tussen 0 en 320 in het register OCR1A geschreven, dus elke stap is ongeveer 0,3%. De tach-lijn is aangesloten op de INT0-interrupt op D2; de teller loopt bij elke dalende flank met één op. In loop worden de interrupts heel kort uitgeschakeld zodat de teller veilig gelezen en gereset kan worden. De logica van interrupts vind je in Arduino-interrupt.

Als je Timer1 zo configureert, werken analogWrite op D9 en D10 en de Servo-bibliotheek, die Timer1 gebruikt, niet meer. Als je project ook een servo heeft, laat de ventilator dan op Timer1 en schakel de servo over op een bibliotheek die Timer2 gebruikt, zoals ServoTimer2, of verhuis het project naar een ESP32. Ook blijven de meeste ventilatoren met 4 pinnen op hun laagste snelheid draaien, zelfs bij 0% duty; wil je de ventilator helemaal stoppen, dan moet je de 12 V-voeding afsluiten met een aparte P-kanaals MOSFET of een relais.

Ventilatorregeling met de ESP32 (25 kHz met LEDC)

Op de ESP32 wordt de LEDC-eenheid gebruikt voor PWM en kun je 25 kHz in één regel instellen; dankzij de klok van 80 MHz haal je bij deze frequentie makkelijk een resolutie van 8 bits. In Arduino core 3.x werken de LEDC-functies met het pinnummer, in 2.x met het kanaalnummer; de onderstaande code compileert op beide versies dankzij een controle op ESP_ARDUINO_VERSION_MAJOR. Op de ESP32 kan elke GPIO een interrupt aannemen; we gebruiken GPIO 26 voor de tach en beschermen de teller met een kritieke sectie (portMUX) zodat er niet tegelijk binnen en buiten de interrupt bij kan worden. Als je een ventilator met 2 draden gebruikt, kun je GPIO 25 aansluiten op de gate van een MOSFET die bij 3,3 V volledig open gaat en dezelfde code gebruiken; negeer in dat geval de tach-regels.

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}

Ventilatorregeling met de Raspberry Pi Pico en MicroPython

De PWM-hardware van de Pico maakt makkelijk 25 kHz en in MicroPython wordt de dutywaarde als 16 bits opgegeven, tussen 0 en 65535. De modules onderwire en ds18x20 die je nodig hebt voor de DS18B20 zitten standaard in de MicroPython-build van de Pico, dus je hoeft geen extra bestanden te kopiëren. We tellen de tach-pulsen met Pin.irq; door de interrupts heel kort uit te schakelen tijdens het lezen van de teller voorkom je dat de waarde half is bijgewerkt. Als MicroPython nieuw voor je is, is MicroPython-basis een goede plek om te beginnen.

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)

Tips om de ventilator stil te laten draaien

  • Verhoog de PWM-frequentie boven de gehoorgrens: De standaard PWM van 490 Hz geeft een duidelijk gejank in de spoelen van de ventilator. 31 kHz bij een ventilator met 2 draden en 25 kHz bij een ventilator met 4 pinnen halen dit geluid volledig weg.
  • Verander de snelheid geleidelijk: Laat de duty niet in één keer van 30% naar 90% springen, maar verhoog hem met slechts een paar procent per seconde; het menselijk oor merkt plotselinge snelheidsveranderingen veel sterker op dan een constant gezoem.
  • Gebruik hysterese: Als de ventilator bij de drempeltemperatuur steeds aan- en uitgaat, hoor je bij elke start een klik en een wisselend geluid; laat 2–3 °C tussen de aan- en uitdrempel.
  • Middel de meting: Kleine schommelingen in de sensorwaarde laten de ventilatorsnelheid rondzwalken. Het gemiddelde van de laatste 5–10 metingen maakt de curve rustiger; voor methoden zie het artikel over sensordata filteren.
  • Laat een grote ventilator langzaam draaien: Een ventilator van 120 mm op 800 RPM verplaatst ongeveer evenveel lucht als een ventilator van 80 mm op 2500 RPM, en doet dat veel stiller.
  • Beperk de trillingen: Monteer de ventilator met rubberen ringen of een siliconen pakking en plaats het rooster en het filter niet te dicht bij de schroef; mechanische trillingen zijn vaak luider dan elektrische ruis.
  • Kies de minimumsnelheid zorgvuldig: Zoek proefondervindelijk de laagste dutywaarde waarbij de ventilator blijft draaien en zet de ondergrens van de curve iets daarboven; een ventilator die op zijn limiet kruipt, maakt een ongelijkmatig geluid.

Projectideeën met ventilatorregeling

  • Slimme thermostaat: Een regelaar die de verwarming met een relais en de ventilator met PWM aanstuurt; details staan in het artikel Arduino-thermostaat.
  • Koeler voor een 3D-printerbehuizing: Een stille afzuigventilator die de binnenkant van de behuizing onder 35 °C houdt en de snelheid op een scherm toont; voor het scherm, zie de gids over het OLED-display.
  • Kasventilatie: Ventilatoren die samenwerken met temperatuur en luchtvochtigheid; het project slimme kas is een goede basis.
  • Peltierkoeler: Koel het koellichaam aan de hete kant van een peltiermodule met een ventilator die versnelt naargelang de temperatuur van die kant; zie de peltiermodule.
  • Domotica: Volg de ventilatorsnelheid en temperatuur op je telefoon met een ESP32 via MQTT en Home Assistant.
  • Constante temperatuur met PID: Gebruik in plaats van een lineaire curve PID-regeling om een ventilatorsysteem te bouwen dat een kast op precies 30 °C houdt.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
De ventilator draait helemaal nietGND is niet gemeenschappelijk of de MOSFET is niet logic-levelVerbind de GND van de adapter en de Arduino, gebruik een MOSFET uit de L-serie zoals de IRLZ44N
De ventilator met 4 pinnen draait altijd op volle snelheidDe PWM-lijn zit op de verkeerde pin of zweeftControleer of de blauwe draad naar D9, GPIO 25 of GP16 gaat en of GND gemeenschappelijk is
De ventilator maakt een dun gejankStandaard PWM van 490 HzVerhoog de frequentie naar 25–31 kHz
De ventilator stopt bij lage snelheidDe duty ligt onder de startdrempel van de ventilatorVerhoog PWM_MIN en gebruik een kickstart
RPM toont altijd 0Geen pull-upweerstand op de tach of verkeerde pinSluit 10 kΩ aan op de logicaspanning, gebruik een pin die interrupts ondersteunt
RPM-waarden zijn heel hoog en springerigLange draad, ruis, of PWM op de low side bij een ventilator met 3 dradenKort de draad in, houd de tach-lijn gescheiden van de PWM-draad; lees bij een ventilator met 3 draden de snelheid alleen op volle snelheid af
De Arduino reset als de ventilator startVentilator en board worden gevoed uit dezelfde zwakke bronGebruik een aparte 12 V-adapter voor de ventilator, voeg een diode en een condensator van 100 µF toe
De MOSFET wordt erg heetEen 5 V-MOSFET op een 3,3 V-board, of de diode ontbreektKies een MOSFET met lage drempel zoals de AO3400, plaats de vrijloopdiode
Om de laagste draaiwaarde van je ventilator te vinden, doe je een korte test: begin op 100% duty, verlaag die elke 3 seconden met 5% en bekijk het toerental in de Serial Monitor. Een waarde 5–10% boven het punt waarop de snelheid naar nul zakt, is een veilige keuze voor de ondergrens van de curve. Bij een ventilator met 2 draden zonder tach-uitgang kun je dezelfde test op het oog en het gehoor doen.

Temperatuurgestuurde ventilatorregeling is een van de nuttigste onderwerpen om te leren, omdat het sensoren uitlezen, PWM, interrupts en vermogenselektronica in één project samenbrengt. Begin met een eenvoudige ventilator met 2 draden en zodra je overstapt op een pc-ventilator met 4 pinnen, heb je een echt koelsysteem gebouwd dat zijn eigen snelheid meet en stil draait. In de BlueGrays-app kun je stap voor stap de projecten doorlopen waarop dit artikel voortbouwt, zoals temperatuur meten met de DHT11 en PWM-toepassingen met de ESP32 en Pico, met schakelschema's en code.

Veelgestelde vragen

Hoe stuur je een ventilator van 12 V aan met Arduino?

Je kunt een ventilator van 12 V niet direct op een Arduino-pin aansluiten; de pin geeft 5 V en levert hooguit ongeveer 20 mA. Een ventilator met 2 draden schakel je aan de low side met een logic-level N-kanaals MOSFET zoals de IRLZ44N en je past PWM toe. Een ventilator met 4 pinnen wordt rechtstreeks uit 12 V gevoed en de Arduino stuurt alleen de blauwe PWM-lijn aan; in beide gevallen moeten de GND's gemeenschappelijk zijn.

Waarom moet de PWM-frequentie van een ventilator met 4 pinnen 25 kHz zijn?

De ventilatorstandaard van Intel met 4 pinnen bepaalt 21–28 kHz voor het regelsignaal, met 25 kHz als doel. Omdat deze frequentie boven de gehoorgrens van de mens ligt (ongeveer 20 kHz), is er geen gejank van de spoelen. Veel ventilatoren reageren niet goed op de standaard PWM van 490 Hz van Arduino, of maken dan lawaai.

Hoe wordt het toerental van een ventilator berekend?

De tach-uitgang van pc-ventilatoren geeft 2 pulsen per omwenteling. Je deelt het aantal pulsen dat in een bepaalde tijd is geteld door 2 en rekent om naar minuten: RPM = pulsen ÷ 2 × 60 ÷ tijd (seconden). Als er bijvoorbeeld 50 pulsen in 1 seconde worden geteld, draait de ventilator op 1500 RPM.

Kan een ventilator met 3 draden met PWM worden geregeld?

Ja, je kunt een ventilator met 3 draden vertragen door zijn voeding met een MOSFET te pulseren, net als bij een ventilator met 2 draden. Omdat de elektronica van de ventilator tijdens de uitperiodes van de PWM zonder stroom zit, wordt het tach-signaal echter verstoord en wordt het aflezen van de snelheid onbetrouwbaar. Wil je de snelheid nauwkeurig meten, gebruik dan een ventilator met 4 pinnen of verlaag de spanning van de ventilator met 3 draden met een DC-DC-converter.

Waarom stopt een ventilator of start hij niet bij lage snelheid?

Elke ventilator heeft een minimaal vermogen waarmee hij kan blijven draaien en vanuit stilstand kan starten; de meeste 12 V-ventilatoren kunnen niet starten onder ongeveer 5–7 V. De oplossing is de ondergrens van de curve iets boven deze waarde te zetten en de ventilator vanuit stilstand te starten met een puls van een halve seconde op volle kracht. De meeste ventilatoren met 4 pinnen stoppen niet bij lage duty; ze blijven op hun laagste snelheid draaien.

Welke MOSFET gebruik je voor ventilatorregeling?

Op 5 V-boards zoals de Arduino Uno zijn logic-level MOSFETs zoals de IRLZ44N, IRL540N of IRLB8721 geschikt. Kies voor de 3,3 V-uitgang van de ESP32 en Pico onderdelen die volledig openen bij een gatespanning van 2,5 V, zoals de AO3400 of IRLML2502. De IRFZ44N en IRF540N hebben een gatespanning van 10 V nodig; met een microcontroller blijven ze half open en worden ze heet.

Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

Temperatuur en luchtvochtigheid met DHT11

Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

4.7(47)
83
ESP32-led dimmen met PWM
ES-8Beginner

ESP32-led dimmen met PWM

De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

4.8(36)
55
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

Raspberry Pi Pico PWM-led-fade (ademeffect)

De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

4
ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
ES-13Gemiddeld
Premium

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)

In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

4.5(19)
32
Temperatuur meten met NTC en 2x16 LCD-display
AR-44Beginner
Premium

Temperatuur meten met NTC en 2x16 LCD-display

Meet de temperatuur om je heen met een sensor die op een klein kraaltje lijkt. Dit onderdeel, een NTC, laat elektriciteit makkelijker door naarmate het warmer wordt; de Arduino leest die verandering…

4.5(33)
44
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)

Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

4.8(38)
57
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

4.7(7)
12
Slim bewateringsstation
AR-83Gevorderd
Premium

Slim bewateringsstation

Een tuinier die je planten zelf water geeft, zodat ze niet uitdrogen terwijl jij op vakantie bent.

5.0(42)
57