Arduino Fan Kontrolü: Sıcaklığa Göre PWM ile Fan Hızı Ayarı
Arduino fan kontrolü: 2 uçlu fanı MOSFET ile PWM sürme, 4 pinli PC fanında 25 kHz PWM ve tako ile RPM okuma. Uno, ESP32 ve Pico kodu, sıcaklık-hız eğrisi.
Arduino fan kontrolü, bir fanın hızını sıcaklığa göre otomatik olarak ayarlamanın en pratik yoludur: bir sensör ortamı ölçer, Arduino bu değeri bir hıza çevirir ve fanı PWM sinyaliyle sürer. Böylece fan ortam serinken sessizce yavaş döner, ısı arttıkça hızlanır ve gereksiz yere tam devirde gürültü yapmaz. 3D yazıcı kabinleri, güç kaynağı kutuları, akvaryum kapakları, seralar ve bilgisayar kasaları bu yöntemin en sık kullanıldığı yerlerdir.
Bu rehberde iki farklı yolu ele alıyoruz: 2 uçlu basit bir fanı logic-level MOSFET ile PWM'le sürmek ve 4 pinli bir PC fanını kendi kontrol hattından 25 kHz PWM ile yönetip tako (takometre) çıkışından devrini okumak. Arduino Uno, ESP32 ve Raspberry Pi Pico için çalışan kodları, map ile sıcaklık-hız eğrisi kurmayı, histerezisi ve fanı gerçekten sessiz çalıştırmanın püf noktalarını adım adım göreceksin.

Arduino ile fan kontrolü nedir, nasıl çalışır?
Bilgisayar fanları fırçasız DC motorlardır; içlerindeki küçük sürücü devre bobinleri sırayla enerjilendirir. Fanın hızını değiştirmenin iki yolu vardır: uygulanan gerilimi düşürmek ya da gerilimi çok hızlı açıp kapatmak. İkinci yöntem PWM'dir ve mikrodenetleyicilerin doğal dilidir. Duty cycle %50 ise fan zamanın yarısında enerji alır; pervanenin ataleti bu darbeleri yumuşatır ve fan yaklaşık yarı hızda döner. PWM'in temellerini PWM Nedir? yazısında ayrıntılı bulabilirsin. Asıl önemli olan fanın kaç kablolu olduğudur, çünkü kuracağın devreyi bu belirler.
| Özellik | 2 uçlu fan | 3 uçlu fan | 4 pinli PWM fan |
|---|---|---|---|
| Kablolar | Kırmızı (+), siyah (GND) | +, GND, sarı ya da yeşil tako | GND, +12 V, tako, PWM |
| Hız kontrolü | Beslemeyi MOSFET ile PWM'lemek | Beslemeyi PWM'lemek ya da gerilimi düşürmek | Ayrı PWM hattı, 25 kHz |
| Devir okuma | Yok | Var (PWM sırasında bozulur) | Var, PWM'den bağımsız |
| Gereken ek parça | MOSFET, diyot, dirençler | MOSFET, diyot, dirençler | Yalnızca 10 kΩ pull-up |
| En düşük hız | Duty %30–40'ın altında durur | Duty %30–40'ın altında durur | Genelde %20–30 devirde döner, durmaz |
| Tipik kullanım | Kasa ve cihaz fanları | Eski PC fanları | Modern PC ve işlemci fanları |
2 uçlu fanı MOSFET ile PWM sürmek
Arduino'nun bir pini 5 V verir ve güvenle en fazla yaklaşık 20 mA akım sağlar; 12 V'luk, 0,1–0,3 A çeken bir fanı doğrudan süremez. Bu yüzden araya bir N-kanal MOSFET koyar ve onu düşük taraf (low-side) anahtar olarak kullanırız: fanın kırmızı kablosu harici 12 V'a, siyah kablosu MOSFET'in drain (D) ucuna gider; source (S) ucu GND'ye bağlanır. Arduino pini 220 Ω'luk bir dirençle gate (G) ucunu sürer. Gate ile source arasına konan 10 kΩ'luk direnç ise Arduino açılırken ya da resetlenirken fanın kendi kendine çalışmasını engeller. Fanın iki ucu arasına ters yönde bir diyot (katot +12 V tarafında) koymak, motor bobininin kapanırken ürettiği gerilim sıçramasını söndürür. MOSFET'in çalışma mantığını Arduino MOSFET Kullanımı yazısında daha ayrıntılı anlattık.
| Parça | Önerilen değer | Görevi |
|---|---|---|
| N-kanal MOSFET (Uno, 5 V) | IRLZ44N, IRL540N, IRLB8721 | Fanın GND hattını PWM ile açıp kapatır |
| N-kanal MOSFET (ESP32/Pico, 3,3 V) | AO3400, IRLML2502 | 3,3 V gate geriliminde tam iletime geçer |
| Gate direnci | 100–220 Ω | Pin akımını sınırlar, sinyaldeki çınlamayı azaltır |
| Gate pull-down | 10 kΩ (gate–source arası) | Açılışta MOSFET'i kapalı tutar |
| Flyback diyot | 1N5819 (Schottky) ya da 1N4007 | Bobinin ürettiği gerilim sıçramasını söndürür |
| Besleme | 12 V adaptör, fan akımının en az 2 katı | Fanı Arduino'dan bağımsız besler |
Bağlantı tablosu: Arduino Uno, ESP32 ve Pico
Aşağıdaki tablo hem 4 pinli fanın doğrudan bağlantısını hem de 2 uçlu fan için MOSFET gate'ini kapsar; iki devrede de PWM aynı pinden çıkar. Sıcaklık sensörü olarak tüm kartlarda çalışan ve su geçirmez kılıflı sürümü de bulunan DS18B20'yi kullanıyoruz; ayrıntılar DS18B20 Sıcaklık Sensörü yazısında.
| Bağlantı | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Fan PWM (mavi) ya da MOSFET gate | D9 | GPIO 25 | GP16 |
| Fan tako (yeşil) + 10 kΩ pull-up | D2 (pull-up 5V'a) | GPIO 26 (pull-up 3V3'e) | GP17 (pull-up 3V3'e) |
| DS18B20 veri + 4,7 kΩ pull-up | D4 | GPIO 4 | GP15 |
| DS18B20 VDD | 5V | 3V3 | 3V3 |
| Fan +12 V (sarı) | Harici 12 V adaptör | Harici 12 V adaptör | Harici 12 V adaptör |
| Fan GND (siyah) | GND (adaptörle ortak) | GND (adaptörle ortak) | GND (adaptörle ortak) |
Adım adım: 2 uçlu fanı sıcaklığa göre sürmek (Arduino Uno)
- Arduino IDE'de Kütüphane Yöneticisi'nden OneWire ve DallasTemperature kütüphanelerini kur.
- DS18B20'yi bağla: VDD 5V'a, GND GND'ye, veri ucu D4'e; veri ucu ile 5V arasına 4,7 kΩ direnç koy.
- MOSFET devresini kur: fanın kırmızısı +12 V'a, siyahı drain'e, source GND'ye, gate 220 Ω üzerinden D9'a, gate ile source arasına da 10 kΩ.
- Diyotu fanın uçlarına ters yönde yerleştir: çizgili katot ucu +12 V'a, diğer ucu fanın siyah kablosuna.
- Adaptörün GND'sini Arduino GND'sine bağla, kodu yükle ve Seri Monitör'ü 9600 baud ile aç.
- Sensörü parmaklarınla ısıt; 30 °C'yi geçince fanın kısa bir tam güç darbesiyle kalkıp ardından sıcaklıkla birlikte hızlandığını gözlemle.
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}| Satır / ayar | Ne işe yarar? |
|---|---|
| TCCR1B = (TCCR1B & 0b11111000) | 0x01 | Timer1 ön bölücüsünü 1 yapar; D9 ve D10'daki PWM 490 Hz'ten yaklaşık 31,4 kHz'e çıkar ve fan vızıltısı duyulmaz hale gelir |
| T_ON / T_OFF | Histerezis: fan 30 °C'de açılır, ancak 27 °C'ye düşünce kapanır; sınır sıcaklıkta aç-kapa titremesi olmaz |
| map(...) | 27–45 °C aralığını 80–255 PWM aralığına doğrusal olarak eşler; ondalık kısım kaybolmasın diye değerler 10 ile çarpılır |
| PWM_MIN = 80 | Fanın durmadan dönebildiği en düşük değer (yaklaşık %31); kendi fanına göre deneyerek bul |
| Kalkış darbesi | Fan dururken önce 0,5 saniye tam güç verilir; düşük duty ile kalkamayan fanlar böylece güvenle başlar |
| DEVICE_DISCONNECTED_C | Sensör kopar ya da okunamazsa fan tam hıza geçer; arıza anında cihaz aşırı ısınmaz |
map ile sıcaklık-hız eğrisi ve histerezis
Sıcaklık-hız eğrisi, hangi sıcaklıkta hangi hızın uygulanacağını tanımlar. En basit hali iki noktalı doğrusal eğridir: alt sıcaklıkta en düşük hız, üst sıcaklıkta tam hız, arası düz bir çizgi. Arduino'nun map() fonksiyonu tam olarak bunu yapar; ancak tam sayılarla çalıştığı için 31,6 °C gibi bir değeri 316'ya çevirip öyle vermek hassasiyeti korur. map aralığın dışındaki değerleri de doğrusal olarak uzattığı için girişi önce constrain() ile sınırlamak gerekir; yoksa 60 °C'de 255'in üzerinde anlamsız bir değer elde edersin. Fonksiyonun ayrıntıları Arduino map Fonksiyonu yazısında. Aşağıdaki tablo 25–45 °C aralığı ve %20 en düşük hız için eğrinin aldığı değerleri gösteriyor; eğim derece başına %4'tür.
| Sıcaklık | Fan hızı (%) | 8 bit PWM (0–255) | Uno Timer1 OCR1A (0–320) |
|---|---|---|---|
| 25 °C ve altı | 20 | 51 | 64 |
| 30 °C | 40 | 102 | 128 |
| 35 °C | 60 | 153 | 192 |
| 40 °C | 80 | 204 | 256 |
| 45 °C ve üstü | 100 | 255 | 320 |
4 pinli PC fanı: 25 kHz PWM ve tako okuma
4 pinli fanlar Intel'in fan standardına uyar: 1. pin GND (siyah), 2. pin +12 V (sarı), 3. pin tako (yeşil), 4. pin PWM kontrol (mavi). Fan her zaman tam 12 V ile beslenir; hızı mavi hattaki PWM sinyali belirler ve standart bu sinyal için 25 kHz frekans ister (21–28 kHz arası kabul edilir). Fanın içinde PWM hattını yukarı çeken bir direnç vardır; bu yüzden hat boşta kalırsa fan tam hızda döner. Tako çıkışı ise her turda 2 darbe üretir. Darbeleri bir kesmeyle sayarsın ve devri şu formülle hesaplarsın: RPM = (darbe sayısı ÷ 2) × (60 ÷ ölçüm süresi saniye). 1 saniyede 40 darbe saydıysan fan 1200 RPM'de dönüyordur.
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}Arduino'nun analogWrite fonksiyonu 25 kHz üretemez, bu yüzden Timer1'i doğrudan ayarlıyoruz. Mod 10 (faz doğru PWM, tepe değeri ICR1) seçildiğinde frekans 16 MHz ÷ (2 × 1 × ICR1) olur; ICR1 = 320 tam olarak 25 kHz verir. Duty değeri OCR1A yazmacına 0–320 arasında yazılır, yani her adım yaklaşık %0,3'e denk gelir. Tako hattı D2'deki INT0 kesmesine bağlıdır; her düşen kenarda sayaç bir artar. loop içinde kesmeler çok kısa süre kapatılarak sayaç güvenle okunup sıfırlanır. Kesmelerin mantığını Arduino Interrupt yazısında bulabilirsin.
ESP32 ile fan kontrolü (LEDC ile 25 kHz)
ESP32'de PWM için LEDC birimi kullanılır ve 25 kHz'i tek satırda ayarlayabilirsin; 80 MHz'lik saat sayesinde bu frekansta 8 bit çözünürlük rahatça elde edilir. Arduino core 3.x'te LEDC fonksiyonları pin numarasıyla, 2.x'te ise kanal numarasıyla çalışır; aşağıdaki kod ESP_ARDUINO_VERSION_MAJOR kontrolüyle iki sürümde de derlenir. ESP32'de her GPIO kesme alabilir; tako için GPIO 26'yı kullanıyoruz ve sayaca kesme içinden ve dışından aynı anda erişilmesin diye bir kritik bölge (portMUX) ile koruyoruz. 2 uçlu fan kullanacaksan GPIO 25'i 3,3 V'ta tam açılan bir MOSFET'in gate'ine bağlayıp aynı kodu kullanabilirsin; bu durumda tako satırlarını yok say.
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}Raspberry Pi Pico ve MicroPython ile fan kontrolü
Pico'nun PWM donanımı 25 kHz'i kolayca üretir ve MicroPython'da duty değeri 0–65535 arasında 16 bit olarak verilir. DS18B20 için gereken onewire ve ds18x20 modülleri Pico'nun MicroPython sürümünde hazır gelir, ek dosya kopyalaman gerekmez. Tako darbelerini Pin.irq ile sayıyoruz; sayaç okunurken kesmeleri çok kısa süre kapatmak, değerin yarım güncellenmesini önler. MicroPython'a yeniysen MicroPython Temelleri yazısı iyi bir başlangıç olur.
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)Fanı sessiz çalıştırmanın ipuçları
- PWM frekansını duyma sınırının üstüne çıkar: 490 Hz'lik varsayılan PWM, fan bobinlerinde net bir vızıltı yaratır. 2 uçlu fanda 31 kHz, 4 pinli fanda 25 kHz bu sesi tamamen ortadan kaldırır.
- Hızı yumuşak değiştir: Duty değerini bir anda %30'dan %90'a çıkarmak yerine her saniye en fazla birkaç yüzde artır; insan kulağı ani devir değişimlerini sabit bir uğultudan çok daha fazla fark eder.
- Histerezis kullan: Fan sınır sıcaklıkta sürekli açılıp kapanırsa her kalkışta tık sesi ve dalgalı bir gürültü duyarsın; açma ve kapama eşikleri arasına 2–3 °C bırak.
- Ölçümü ortala: Sensör değerindeki küçük dalgalanmalar fan hızını oynatır. Son 5–10 ölçümün ortalamasını almak eğriyi sakinleştirir; yöntemler için sensör verisi filtreleme yazısına bakabilirsin.
- Büyük fanı yavaş döndür: 120 mm'lik bir fan 800 RPM'de, 2500 RPM'de dönen 80 mm'lik bir fana yakın hava akışını çok daha sessiz sağlar.
- Titreşimi kes: Fanı lastik takoz ya da silikon contayla monte et, ızgara ve filtreyi pervaneye çok yakın koyma; mekanik titreşim çoğu zaman elektriksel gürültüden daha yüksek sestir.
- En düşük hızı doğru seç: Fanın dönmeye devam ettiği en düşük duty değerini deneyerek bul ve eğrinin alt sınırını onun biraz üstüne koy; sınırda sürünerek dönen fan düzensiz ses çıkarır.
Fan kontrolü ile proje fikirleri
- Akıllı termostat: Isıtıcıyı röleyle, fanı PWM ile yöneten bir kontrolcü; ayrıntılar Arduino termostat yazısında.
- 3D yazıcı kabini soğutucusu: Kabin içini 35 °C'nin altında tutan ve devri ekranda gösteren sessiz bir egzoz fanı; ekran için OLED ekran rehberine bak.
- Sera havalandırması: Sıcaklık ve nemle birlikte çalışan fanlar; akıllı sera projesi buna iyi bir temel oluşturur.
- Peltier soğutucu: Peltier modülünün sıcak yüzündeki soğutucuyu, o yüzün sıcaklığına göre hızlanan bir fanla soğut; bkz. Peltier modülü.
- Ev otomasyonu: ESP32 ile fan devrini ve sıcaklığı MQTT ve Home Assistant üzerinden telefondan izle.
- PID ile sabit sıcaklık: Doğrusal eğri yerine PID kontrol kullanarak bir kutuyu tam 30 °C'de tutan fan sistemi kur.
Sık yapılan hatalar ve çözümleri
| Belirti | Olası sebep | Çözüm |
|---|---|---|
| Fan hiç dönmüyor | GND ortak değil ya da MOSFET logic-level değil | Adaptör ve Arduino GND'lerini birleştir, IRLZ44N gibi L serisi bir MOSFET kullan |
| 4 pinli fan hep tam hızda | PWM hattı yanlış pine bağlı ya da hat boşta | Mavi kablonun D9, GPIO 25 ya da GP16'ya gittiğini ve GND'nin ortak olduğunu kontrol et |
| Fandan ince bir vızıltı geliyor | Varsayılan 490 Hz PWM | Frekansı 25–31 kHz'e çıkar |
| Fan düşük hızda duruyor | Duty, fanın kalkış eşiğinin altında | PWM_MIN değerini yükselt ve kalkış darbesi kullan |
| RPM hep 0 görünüyor | Tako pull-up direnci yok ya da yanlış pin | 10 kΩ'u lojik gerilime bağla, kesme destekli bir pin kullan |
| RPM değerleri çok yüksek ve oynak | Uzun kablo, gürültü ya da 3 uçlu fanı düşük taraftan PWM'lemek | Kabloyu kısalt, tako hattını PWM kablosundan ayır; 3 uçlu fanda devri yalnızca tam hızda oku |
| Fan kalkarken Arduino resetleniyor | Fan ve kart aynı zayıf kaynaktan besleniyor | Fana ayrı 12 V adaptör kullan, diyot ve 100 µF kondansatör ekle |
| MOSFET çok ısınıyor | 3,3 V kartta 5 V'luk MOSFET ya da diyot eksik | AO3400 gibi düşük eşikli bir MOSFET seç, flyback diyotu tak |
Sıcaklığa göre fan kontrolü; sensör okuma, PWM, kesme ve güç elektroniğini tek projede buluşturduğu için öğrenmesi en verimli konulardan biridir. Basit bir 2 uçlu fanla başlayıp 4 pinli bir PC fanına geçtiğinde, devrini ölçen ve sessizce çalışan gerçek bir soğutma sistemi kurmuş olursun. BlueGrays uygulamasında DHT11 ile sıcaklık ölçme, ESP32 ve Pico ile PWM uygulamaları gibi bu yazıya temel olan projeleri devre şemaları ve kodlarıyla adım adım inceleyebilirsin.
Sıkça sorulan sorular
Arduino ile 12 V fan nasıl kontrol edilir?
12 V'luk fanı Arduino pinine doğrudan bağlayamazsın; pin hem 5 V verir hem de en fazla 20 mA civarında akım sağlar. 2 uçlu fanı IRLZ44N gibi logic-level bir N-kanal MOSFET ile düşük taraftan anahtarlayıp PWM uygularsın. 4 pinli fanlarda ise fan doğrudan 12 V ile beslenir ve Arduino yalnızca mavi PWM hattını sürer; her iki durumda da GND'ler ortak olmalıdır.
4 pinli fanın PWM frekansı neden 25 kHz olmalı?
Intel'in 4 pinli fan standardı kontrol sinyali için 21–28 kHz aralığını, hedef olarak da 25 kHz'i tanımlar. Bu frekans insan kulağının duyma sınırının (yaklaşık 20 kHz) üstünde olduğu için bobinlerden vızıltı gelmez. Arduino'nun varsayılan 490 Hz PWM'ine birçok fan düzgün tepki vermez ya da ses çıkarır.
Fan RPM değeri nasıl hesaplanır?
PC fanlarının tako çıkışı her turda 2 darbe üretir. Belirli bir sürede saydığın darbe sayısını 2'ye bölüp dakikaya çevirirsin: RPM = darbe ÷ 2 × 60 ÷ süre (saniye). Örneğin 1 saniyede 50 darbe sayıldıysa fan 1500 RPM'de dönüyordur.
3 pinli fan PWM ile kontrol edilebilir mi?
Evet, 3 pinli fanı da 2 uçlu fan gibi beslemesinden MOSFET ile PWM'leyerek yavaşlatabilirsin. Ancak PWM'in kapalı anlarında fanın elektroniği enerjisiz kaldığı için tako sinyali bozulur ve devir okuması güvenilmez olur. Devri doğru ölçmek istiyorsan 4 pinli fan kullan ya da 3 pinli fanın gerilimini bir DC-DC dönüştürücüyle düşür.
Fan düşük hızda neden duruyor ya da kalkmıyor?
Her fanın dönmeye devam edebildiği ve dururken kalkabildiği en düşük bir güç seviyesi vardır; 12 V'luk fanların çoğu 5–7 V civarının altında kalkamaz. Çözüm, eğrinin alt sınırını bu değerin biraz üstüne koymak ve fan dururken önce yarım saniyelik tam güç darbesiyle başlatmaktır. 4 pinli fanların çoğu ise düşük duty'de durmaz, en düşük devrinde dönmeye devam eder.
Fan kontrolü için hangi MOSFET kullanılmalı?
Arduino Uno gibi 5 V'luk kartlarda IRLZ44N, IRL540N ya da IRLB8721 gibi logic-level MOSFET'ler uygundur. ESP32 ve Pico'nun 3,3 V çıkışı için AO3400 ya da IRLML2502 gibi 2,5 V gate geriliminde tam açılan parçaları seç. IRFZ44N ve IRF540N 10 V gate gerilimi ister; mikrodenetleyiciyle kullanıldığında yarı açık kalıp ısınır.
Bu yazıdan sonra yapabileceğin projeler
Tüm projeleri gör
DHT11 İle Sıcaklık Ve Nem
Odan kaç derece, hava nemli mi, kuru mu? DHT11 sensörü sıcaklığı ve nemi ölçer, Arduino da bu değerleri iki satırlık LCD ekrana yazar ve birkaç saniyede bir yeniler.

ESP32 PWM ile LED Soldurma (Fade)
LED'in parlaklığını yumuşak şekilde 0'dan max'a, max'tan 0'a değiştirme. Arduino'daki gibi analogWrite() ile PWM kontrolü yapıyoruz — ESP32 Arduino Core 3.0+ ile aynı syntax sorunsuz çalışır. Pin tanımı + pinMode + analogWrite yeterli.

Raspberry Pi Pico PWM ile LED Fade (Nefes Efekti)
LED artık sadece yanıp sönmüyor, nefes alıyor! Raspberry Pi Pico'nun PWM (Pulse Width Modulation, darbe genişlik modülasyonu) özelliğiyle LED'in parlaklığı yavaş yavaş artar, sonra yavaş yavaş azalır; uyku modundaki bir dizüstü bilgisayarın ışığı gibi sakin bir "nefes" efekti. Bu projede machine.PWM sınıfını, duty_u16() ile 0–65535 arası 16 bit parlaklık değerini ve PWM frekansını öğrenirsin.

ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)
Bu projede bir potansiyometre ile LED parlaklığını analog olarak kontrol ediyoruz. ESP32'nin ADC pini potansiyometreden gelen 0-3.3V gerilimi okur, ardından bu değer PWM (Pulse Width Modulation) sinyaline çevrilerek LED'e gönderilir. Böylece potansiyometreyi çevirdikçe LED kademeli olarak parlar ve söner. Arduino Core 3.0+ ile analogWrite() doğrudan kullanılabilir; ESP32-S2/S3'te ADC çözünürlüğü 12-bit'e sabitlenir.

NTC ve 2x16 Lcd Ekran İle Sıcaklık Ölçümü
Ortamın sıcaklığını küçük bir boncuk gibi görünen sensörle ölç. NTC adlı bu parça ısındıkça elektriği daha kolay geçirir; Arduino bu değişimi okuyup bir formülle santigrat dereceye çevirir ve iki…

ESP32 DHT22 Sıcaklık ve Nem (LCD Ekranlı)
DHT22 sensörü ile ortam sıcaklığını ve nem oranını ölçüp 16x2 I2C LCD ekranda gerçek zamanlı olarak gösteren bir projedir. Adafruit DHT kütüphanesi kullanılarak tek kablo (one-wire) protokolü ile sensörden veri okunur. Bu proje, IoT hava istasyonu, akıllı ev otomasyonu veya seralarda ortam takip sistemlerinin temelini oluşturur. ESP32'nin GPIO 4 pini üzerinden DHT22 ile haberleşme sağlanır.

ESP32 Sıcaklık Loglayıcı (DHT22 + DS1307 RTC + microSD + OLED)
ESP32 ile zamanlı sıcaklık ve nem kayıt sistemi kur! Bu projede DHT22 sensörüyle dakikada bir sıcaklık ve nem okuyup DS1307 RTC modülünden aldığın gerçek zaman etiketiyle microSD karta CSV formatında kaydediyoruz. OLED ekranda büyük yazıyla son sıcaklık değeri, nem yüzdesi, zaman damgası ve toplam kayıt sayısı canlı gösterilir.

Akıllı Sulama İstasyonu
Tatile gidince çiçeklerin kurumasın diye kendi kendine sulayan bir bahçıvan. Toprak nem sensörü toprağın ne kadar ıslak olduğunu ölçer; toprak kuruyunca Arduino su pompasını birkaç saniye çalıştırır…
Diğer yazılar
BlueGrays uygulaması
Bu devreyi telefonunda adım adım kur
Devre şeması, kod ve parça listesi tek ekranda. 500'den fazla Arduino, ESP32 ve Pico projesi seni bekliyor.
Telefonunla tara
Kamerayı koda tut; telefonunun uygulama mağazası açılır.
ya da mağazada aç

