Rehberler · 8 dk okuma

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.

DS18B20 dijital sıcaklık sensörü
DS18B20: tek veri hattıyla çalışan, ±0,5 °C hassasiyetli dijital sıcaklık sensörü. Bu yazıdaki fan kontrolünde sıcaklığı bu sensörle ölçüyoruz.

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.

Özellik2 uçlu fan3 uçlu fan4 pinli PWM fan
KablolarKırmızı (+), siyah (GND)+, GND, sarı ya da yeşil takoGND, +12 V, tako, PWM
Hız kontrolüBeslemeyi MOSFET ile PWM'lemekBeslemeyi PWM'lemek ya da gerilimi düşürmekAyrı PWM hattı, 25 kHz
Devir okumaYokVar (PWM sırasında bozulur)Var, PWM'den bağımsız
Gereken ek parçaMOSFET, diyot, dirençlerMOSFET, diyot, dirençlerYalnızca 10 kΩ pull-up
En düşük hızDuty %30–40'ın altında dururDuty %30–40'ın altında dururGenelde %20–30 devirde döner, durmaz
Tipik kullanımKasa 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ğerGörevi
N-kanal MOSFET (Uno, 5 V)IRLZ44N, IRL540N, IRLB8721Fanın GND hattını PWM ile açıp kapatır
N-kanal MOSFET (ESP32/Pico, 3,3 V)AO3400, IRLML25023,3 V gate geriliminde tam iletime geçer
Gate direnci100–220 ΩPin akımını sınırlar, sinyaldeki çınlamayı azaltır
Gate pull-down10 kΩ (gate–source arası)Açılışta MOSFET'i kapalı tutar
Flyback diyot1N5819 (Schottky) ya da 1N4007Bobinin ürettiği gerilim sıçramasını söndürür
Besleme12 V adaptör, fan akımının en az 2 katıFanı Arduino'dan bağımsız besler
En sık yapılan hata, IRFZ44N ya da IRF540N gibi logic-level olmayan MOSFET'leri kullanmaktır. Bu parçalar 10 V gate gerilimi için tasarlanmıştır; 5 V'ta yarı açık kalır, fan yavaş döner ve MOSFET ısınır. Adında L harfi olanları (IRLZ44N, IRL540N) seç. Ayrıca Arduino GND'si ile 12 V adaptörün GND'si mutlaka birleştirilmeli; ortak toprak yoksa PWM sinyalinin bir referansı olmaz ve fan ya hiç dönmez ya da rastgele davranır.

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 UnoESP32Raspberry Pi Pico
Fan PWM (mavi) ya da MOSFET gateD9GPIO 25GP16
Fan tako (yeşil) + 10 kΩ pull-upD2 (pull-up 5V'a)GPIO 26 (pull-up 3V3'e)GP17 (pull-up 3V3'e)
DS18B20 veri + 4,7 kΩ pull-upD4GPIO 4GP15
DS18B20 VDD5V3V33V3
Fan +12 V (sarı)Harici 12 V adaptörHarici 12 V adaptörHarici 12 V adaptör
Fan GND (siyah)GND (adaptörle ortak)GND (adaptörle ortak)GND (adaptörle ortak)
Tako hattının pull-up direncini asla 12 V'a bağlama. Tako çıkışı açık kolektördür; fan bu hattı yalnızca GND'ye çeker, yüksek seviyeyi senin pull-up direncin belirler. 12 V'a çekersen Arduino'nun girişi zorlanır, ESP32 ve Pico'nun 3,3 V'luk pini ise anında yanabilir. Pull-up direncini her zaman kartın kendi lojik gerilimine (Uno için 5 V, ESP32 ve Pico için 3,3 V) bağla.

Adım adım: 2 uçlu fanı sıcaklığa göre sürmek (Arduino Uno)

  1. Arduino IDE'de Kütüphane Yöneticisi'nden OneWire ve DallasTemperature kütüphanelerini kur.
  2. 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.
  3. 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Ω.
  4. Diyotu fanın uçlarına ters yönde yerleştir: çizgili katot ucu +12 V'a, diğer ucu fanın siyah kablosuna.
  5. Adaptörün GND'sini Arduino GND'sine bağla, kodu yükle ve Seri Monitör'ü 9600 baud ile aç.
  6. 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.
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}
Satır / ayarNe işe yarar?
TCCR1B = (TCCR1B & 0b11111000) | 0x01Timer1 ö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_OFFHisterezis: 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 = 80Fanın durmadan dönebildiği en düşük değer (yaklaşık %31); kendi fanına göre deneyerek bul
Kalkış darbesiFan dururken önce 0,5 saniye tam güç verilir; düşük duty ile kalkamayan fanlar böylece güvenle başlar
DEVICE_DISCONNECTED_CSensö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ıkFan hızı (%)8 bit PWM (0–255)Uno Timer1 OCR1A (0–320)
25 °C ve altı205164
30 °C40102128
35 °C60153192
40 °C80204256
45 °C ve üstü100255320

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.

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}

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.

Timer1'i bu şekilde ayarlamak, D9 ve D10'daki analogWrite'ı ve Timer1 kullanan Servo kütüphanesini devre dışı bırakır. Projende servo da varsa fanı Timer1'de bırak, servo için Timer2 kullanan ServoTimer2 gibi bir kütüphaneye geç ya da projeyi ESP32'ye taşı. Ayrıca 4 pinli fanların çoğu %0 duty'de bile en düşük devrinde dönmeye devam eder; fanı tamamen durdurmak istiyorsan 12 V beslemesini ayrı bir P-kanal MOSFET ya da röleyle kesmelisin.

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.

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}

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.

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)

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

BelirtiOlası sebepÇözüm
Fan hiç dönmüyorGND ortak değil ya da MOSFET logic-level değilAdaptör ve Arduino GND'lerini birleştir, IRLZ44N gibi L serisi bir MOSFET kullan
4 pinli fan hep tam hızdaPWM hattı yanlış pine bağlı ya da hat boştaMavi kablonun D9, GPIO 25 ya da GP16'ya gittiğini ve GND'nin ortak olduğunu kontrol et
Fandan ince bir vızıltı geliyorVarsayılan 490 Hz PWMFrekansı 25–31 kHz'e çıkar
Fan düşük hızda duruyorDuty, fanın kalkış eşiğinin altındaPWM_MIN değerini yükselt ve kalkış darbesi kullan
RPM hep 0 görünüyorTako pull-up direnci yok ya da yanlış pin10 kΩ'u lojik gerilime bağla, kesme destekli bir pin kullan
RPM değerleri çok yüksek ve oynakUzun kablo, gürültü ya da 3 uçlu fanı düşük taraftan PWM'lemekKabloyu kısalt, tako hattını PWM kablosundan ayır; 3 uçlu fanda devri yalnızca tam hızda oku
Fan kalkarken Arduino resetleniyorFan ve kart aynı zayıf kaynaktan besleniyorFana ayrı 12 V adaptör kullan, diyot ve 100 µF kondansatör ekle
MOSFET çok ısınıyor3,3 V kartta 5 V'luk MOSFET ya da diyot eksikAO3400 gibi düşük eşikli bir MOSFET seç, flyback diyotu tak
Fanının en düşük dönme değerini bulmak için kısa bir test yap: duty'yi %100'den başlatıp her 3 saniyede %5 düşür ve Seri Monitör'de RPM'yi izle. Devrin sıfıra düştüğü değerin %5–10 üstü, eğrinin alt sınırı için güvenli bir seçimdir. Tako çıkışı olmayan 2 uçlu fanda aynı testi gözle ve kulakla yapabilirsin.

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.

Tüm projeleri gör
DHT11 İle Sıcaklık Ve Nem
AR-55Orta

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.

4.7(47)
83
ESP32 PWM ile LED Soldurma (Fade)
ES-8Başlangıç

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.

4.8(36)
55
Raspberry Pi Pico PWM ile LED Fade (Nefes Efekti)
PI-14Başlangıç

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.

4
ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)
ES-13Orta
Premium

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.

4.5(19)
32
NTC ve 2x16 Lcd Ekran İle Sıcaklık Ölçümü
AR-44Başlangıç
Premium

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…

4.5(33)
44
ESP32 DHT22 Sıcaklık ve Nem (LCD Ekranlı)
ES-15Orta

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.

4.8(38)
57
ESP32 Sıcaklık Loglayıcı (DHT22 + DS1307 RTC + microSD + OLED)
ES-40İleri
Premium

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.

4.7(7)
12
Akıllı Sulama İstasyonu
AR-83İleri
Premium

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…

5.0(42)
57