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.

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.
| Eigenschap | Ventilator met 2 draden | Ventilator met 3 draden | PWM-ventilator met 4 pinnen |
|---|---|---|---|
| Draden | Rood (+), zwart (GND) | +, GND, gele of groene tach | GND, +12 V, tach, PWM |
| Snelheidsregeling | De voeding pulseren met een MOSFET | De voeding pulseren of de spanning verlagen | Aparte PWM-lijn, 25 kHz |
| Toerental aflezen | Niet mogelijk | Ja (wordt verstoord tijdens PWM) | Ja, onafhankelijk van PWM |
| Extra onderdelen nodig | MOSFET, diode, weerstanden | MOSFET, diode, weerstanden | Alleen een pull-upweerstand van 10 kΩ |
| Laagste snelheid | Stopt onder 30–40% duty | Stopt onder 30–40% duty | Blijft meestal draaien op 20–30% snelheid |
| Typisch gebruik | Behuizings- en apparaatventilatoren | Oude pc-ventilatoren | Moderne 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.
| Onderdeel | Aanbevolen waarde | Doel |
|---|---|---|
| N-kanaals MOSFET (Uno, 5 V) | IRLZ44N, IRL540N, IRLB8721 | Schakelt de GND-lijn van de ventilator met PWM aan en uit |
| N-kanaals MOSFET (ESP32/Pico, 3,3 V) | AO3400, IRLML2502 | Gaat volledig open bij een gatespanning van 3,3 V |
| Gateweerstand | 100–220 Ω | Beperkt de pinstroom en vermindert rinkelen in het signaal |
| Gate pull-down | 10 kΩ (tussen gate en source) | Houdt de MOSFET uit bij het opstarten |
| Vrijloopdiode | 1N5819 (Schottky) of 1N4007 | Vangt de spanningspiek van de spoel op |
| Voeding | 12 V-adapter, minstens 2× de stroom van de ventilator | Voedt de ventilator onafhankelijk van de Arduino |
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.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Ventilator-PWM (blauw) of MOSFET-gate | D9 | GPIO 25 | GP16 |
| 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Ω | D4 | GPIO 4 | GP15 |
| DS18B20 VDD | 5V | 3V3 | 3V3 |
| Ventilator +12 V (geel) | Externe 12 V-adapter | Externe 12 V-adapter | Externe 12 V-adapter |
| Ventilator-GND (zwart) | GND (gemeenschappelijk met adapter) | GND (gemeenschappelijk met adapter) | GND (gemeenschappelijk met adapter) |
Stap voor stap: een ventilator met 2 draden op temperatuur aansturen (Arduino Uno)
- Installeer in de Arduino IDE de bibliotheken OneWire en DallasTemperature via de Library Manager.
- 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.
- 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.
- 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.
- Verbind de GND van de adapter met de GND van de Arduino, upload de code en open de Serial Monitor op 9600 baud.
- 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.
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 / instelling | Wat het doet |
|---|---|
| TCCR1B = (TCCR1B & 0b11111000) | 0x01 | Zet 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_OFF | Hysterese: 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 = 80 | De laagste waarde waarbij de ventilator blijft draaien (ongeveer 31%); zoek die proefondervindelijk op voor je eigen ventilator |
| Kickstart | Als 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_C | Als 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.
| Temperatuur | Ventilatorsnelheid (%) | 8-bits PWM (0–255) | Uno Timer1 OCR1A (0–320) |
|---|---|---|---|
| 25 °C en lager | 20 | 51 | 64 |
| 30 °C | 40 | 102 | 128 |
| 35 °C | 60 | 153 | 192 |
| 40 °C | 80 | 204 | 256 |
| 45 °C en hoger | 100 | 255 | 320 |
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.
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.
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.
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.
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
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De ventilator draait helemaal niet | GND is niet gemeenschappelijk of de MOSFET is niet logic-level | Verbind 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 snelheid | De PWM-lijn zit op de verkeerde pin of zweeft | Controleer of de blauwe draad naar D9, GPIO 25 of GP16 gaat en of GND gemeenschappelijk is |
| De ventilator maakt een dun gejank | Standaard PWM van 490 Hz | Verhoog de frequentie naar 25–31 kHz |
| De ventilator stopt bij lage snelheid | De duty ligt onder de startdrempel van de ventilator | Verhoog PWM_MIN en gebruik een kickstart |
| RPM toont altijd 0 | Geen pull-upweerstand op de tach of verkeerde pin | Sluit 10 kΩ aan op de logicaspanning, gebruik een pin die interrupts ondersteunt |
| RPM-waarden zijn heel hoog en springerig | Lange draad, ruis, of PWM op de low side bij een ventilator met 3 draden | Kort 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 start | Ventilator en board worden gevoed uit dezelfde zwakke bron | Gebruik een aparte 12 V-adapter voor de ventilator, voeg een diode en een condensator van 100 µF toe |
| De MOSFET wordt erg heet | Een 5 V-MOSFET op een 3,3 V-board, of de diode ontbreekt | Kies een MOSFET met lage drempel zoals de AO3400, plaats de vrijloopdiode |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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…

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.

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.

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.

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…

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.

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.

Slim bewateringsstation
Een tuinier die je planten zelf water geeft, zodat ze niet uitdrogen terwijl jij op vakantie bent.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

