Panduan · 9 mnt baca

Kontrol Kecepatan Kipas Arduino: Mengatur Kipas dengan PWM Berdasarkan Suhu

Kontrol kecepatan kipas Arduino: kendalikan kipas 2 kabel dengan MOSFET, jalankan kipas PC 4 pin dengan PWM 25 kHz, dan baca RPM dari tacho. Lengkap dengan kode Uno, ESP32, Pico, dan kurva suhu-kecepatan.

Kontrol kecepatan kipas Arduino adalah cara paling praktis untuk mengatur kecepatan kipas secara otomatis berdasarkan suhu: sebuah sensor mengukur lingkungan, Arduino mengubah nilai itu menjadi kecepatan, lalu mengendalikan kipas dengan sinyal PWM. Hasilnya, kipas berputar pelan dan senyap ketika udara sejuk, makin cepat ketika panas naik, dan tidak berisik tanpa perlu di kecepatan penuh. Enclosure printer 3D, kotak catu daya, tutup akuarium, rumah kaca, dan casing komputer adalah tempat metode ini paling sering dipakai.

Panduan ini membahas dua pendekatan berbeda: mengendalikan kipas 2 kabel sederhana dengan PWM lewat MOSFET logic-level, dan mengatur kipas PC 4 pin lewat jalur kontrolnya sendiri dengan PWM 25 kHz sambil membaca kecepatannya dari output tacho (takometer). Kamu akan mempelajari langkah demi langkah kode yang berfungsi untuk Arduino Uno, ESP32, dan Raspberry Pi Pico, cara membuat kurva suhu-kecepatan dengan map, histeresis, dan trik agar kipas benar-benar senyap.

Sensor suhu digital DS18B20
DS18B20: sensor suhu digital dengan satu kabel data dan akurasi ±0,5 °C. Di artikel ini, kita memakainya untuk mengukur suhu pada kontrol kipas.

Apa itu kontrol kipas dengan Arduino, dan bagaimana cara kerjanya?

Kipas komputer adalah motor DC brushless; rangkaian driver kecil di dalamnya memberi energi ke kumparan secara bergantian. Ada dua cara untuk mengubah kecepatan kipas: menurunkan tegangan yang diberikan, atau menyalakan dan mematikan tegangan dengan sangat cepat. Cara kedua adalah PWM, dan ini bahasa asli mikrokontroler. Pada duty cycle 50%, kipas mendapat daya separuh waktu; inersia baling-baling menghaluskan pulsa ini sehingga kipas berputar kira-kira setengah kecepatan. Dasar-dasar PWM bisa kamu baca lebih lengkap di Apa Itu PWM?. Yang paling penting adalah berapa jumlah kabel kipasmu, karena itulah yang menentukan rangkaian yang akan kamu buat.

FiturKipas 2 kabelKipas 3 kabelKipas PWM 4 pin
KabelMerah (+), hitam (GND)+, GND, tacho kuning atau hijauGND, +12 V, tacho, PWM
Kontrol kecepatanPWM pada catu daya lewat MOSFETPWM pada catu daya atau turunkan teganganJalur PWM terpisah, 25 kHz
Pembacaan kecepatanTidak adaAda (rusak selama PWM)Ada, tidak terpengaruh PWM
Komponen tambahanMOSFET, dioda, resistorMOSFET, dioda, resistorHanya pull-up 10 kΩ
Kecepatan terendahBerhenti di bawah duty 30–40%Berhenti di bawah duty 30–40%Biasanya tetap berputar di kecepatan 20–30%
Penggunaan umumKipas casing dan perangkatKipas PC lamaKipas PC dan CPU modern

Mengendalikan kipas 2 kabel dengan PWM lewat MOSFET

Pin Arduino memberikan 5 V dan hanya bisa menyuplai sekitar 20 mA dengan aman; pin itu tidak bisa langsung mengendalikan kipas 12 V yang menarik 0,1–0,3 A. Karena itu, kita memasang MOSFET kanal-N di antaranya dan memakainya sebagai sakelar low-side: kabel merah kipas ke 12 V eksternal, kabel hitamnya ke pin drain (D) MOSFET, dan pin source (S) ke GND. Pin Arduino mengendalikan gate (G) lewat resistor 220 Ω. Resistor 10 kΩ di antara gate dan source mencegah kipas berputar sendiri ketika Arduino menyala atau reset. Dioda yang dipasang terbalik di antara dua terminal kipas (katoda di sisi +12 V) meredam lonjakan tegangan yang dihasilkan kumparan motor ketika dimatikan. Cara kerja MOSFET kami jelaskan lebih rinci di Memakai MOSFET dengan Arduino.

KomponenNilai yang disarankanFungsi
MOSFET kanal-N (Uno, 5 V)IRLZ44N, IRL540N, IRLB8721Menyambung dan memutus jalur GND kipas dengan PWM
MOSFET kanal-N (ESP32/Pico, 3,3 V)AO3400, IRLML2502Menyala penuh pada tegangan gate 3,3 V
Resistor gate100–220 ΩMembatasi arus pin, mengurangi ringing pada sinyal
Pull-down gate10 kΩ (di antara gate dan source)Menjaga MOSFET tetap mati ketika baru dinyalakan
Dioda flyback1N5819 (Schottky) atau 1N4007Meredam lonjakan tegangan dari kumparan
Catu dayaAdaptor 12 V, minimal 2× arus kipasMemberi daya ke kipas secara terpisah dari Arduino
Kesalahan paling umum adalah memakai MOSFET yang bukan logic-level seperti IRFZ44N atau IRF540N. Komponen ini dirancang untuk tegangan gate 10 V; pada 5 V MOSFET hanya setengah terbuka, kipas berputar pelan, dan MOSFET jadi panas. Pilih yang namanya mengandung huruf L (IRLZ44N, IRL540N). Selain itu, GND Arduino dan GND adaptor 12 V wajib disambungkan; tanpa ground bersama, sinyal PWM tidak punya referensi, dan kipas tidak berputar sama sekali atau bertingkah acak.

Tabel pengkabelan: Arduino Uno, ESP32, dan Pico

Tabel di bawah mencakup sambungan langsung kipas 4 pin sekaligus gate MOSFET untuk kipas 2 kabel; di kedua rangkaian, PWM keluar dari pin yang sama. Sebagai sensor suhu, kita memakai DS18B20 yang bisa dipakai di semua board dan juga tersedia versi tahan air; detailnya ada di Sensor Suhu DS18B20.

SambunganArduino UnoESP32Raspberry Pi Pico
PWM kipas (biru) atau gate MOSFETD9GPIO 25GP16
Tacho kipas (hijau) + pull-up 10 kΩD2 (pull-up ke 5V)GPIO 26 (pull-up ke 3V3)GP17 (pull-up ke 3V3)
Data DS18B20 + pull-up 4,7 kΩD4GPIO 4GP15
DS18B20 VDD5V3V33V3
Kipas +12 V (kuning)Adaptor 12 V eksternalAdaptor 12 V eksternalAdaptor 12 V eksternal
GND kipas (hitam)GND (bersama dengan adaptor)GND (bersama dengan adaptor)GND (bersama dengan adaptor)
Jangan pernah menyambungkan resistor pull-up jalur tacho ke 12 V. Output tacho bersifat open collector; kipas hanya menarik jalur ini ke GND, dan level HIGH-nya ditentukan oleh resistor pull-up-mu. Kalau ditarik ke 12 V, input Arduino jadi terbebani, dan pin 3,3 V milik ESP32 dan Pico bisa langsung terbakar. Selalu sambungkan resistor pull-up ke tegangan logika board itu sendiri (5 V untuk Uno, 3,3 V untuk ESP32 dan Pico).

Langkah demi langkah: mengendalikan kipas 2 kabel berdasarkan suhu (Arduino Uno)

  1. Di Arduino IDE, instal library OneWire dan DallasTemperature dari Library Manager.
  2. Sambungkan DS18B20: VDD ke 5V, GND ke GND, pin data ke D4; pasang resistor 4,7 kΩ di antara pin data dan 5V.
  3. Rakit rangkaian MOSFET: kabel merah kipas ke +12 V, hitam ke drain, source ke GND, gate ke D9 lewat 220 Ω, dan 10 kΩ di antara gate dan source.
  4. Pasang dioda terbalik di antara terminal kipas: ujung katoda yang bergaris ke +12 V, ujung lainnya ke kabel hitam kipas.
  5. Sambungkan GND adaptor ke GND Arduino, upload kodenya, lalu buka Serial Monitor di 9600 baud.
  6. Hangatkan sensor dengan jarimu; begitu melewati 30 °C, perhatikan kipas mulai berputar dengan pulsa daya penuh singkat, lalu makin cepat seiring naiknya suhu.
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}
Baris / pengaturanFungsinya
TCCR1B = (TCCR1B & 0b11111000) | 0x01Mengatur prescaler Timer1 menjadi 1; PWM di D9 dan D10 naik dari 490 Hz ke sekitar 31,4 kHz sehingga dengung kipas tidak terdengar lagi
T_ON / T_OFFHisteresis: kipas menyala di 30 °C tetapi baru mati ketika suhu turun ke 27 °C; tidak ada nyala-mati bergantian di suhu ambang
map(...)Memetakan rentang 27–45 °C secara linear ke rentang PWM 80–255; nilainya dikali 10 agar bagian desimalnya tidak hilang
PWM_MIN = 80Nilai terendah di mana kipas tetap berputar (sekitar 31%); cari dengan mencoba langsung di kipasmu sendiri
Kick start (dorongan awal)Ketika kipas berhenti, daya penuh diberikan dulu selama 0,5 detik; kipas yang tidak bisa mulai berputar di duty rendah jadi bisa start dengan aman
DEVICE_DISCONNECTED_CKalau sensor terlepas atau tidak bisa dibaca, kipas pindah ke kecepatan penuh; perangkat tidak kepanasan ketika terjadi kerusakan

Kurva suhu-kecepatan dengan map dan histeresis

Kurva suhu-kecepatan menentukan kecepatan mana yang dipakai pada suhu tertentu. Bentuk paling sederhana adalah kurva linear dua titik: kecepatan terendah di suhu bawah, kecepatan penuh di suhu atas, dan garis lurus di antaranya. Fungsi map() di Arduino melakukan persis hal ini; tetapi karena bekerja dengan bilangan bulat, mengubah nilai seperti 31,6 °C menjadi 316 dulu sebelum dimasukkan akan menjaga ketelitian. Karena map juga memperpanjang nilai di luar rentang secara linear, input perlu dibatasi dulu dengan constrain(); kalau tidak, di 60 °C kamu akan mendapat nilai di atas 255 yang tidak bermakna. Detail fungsinya ada di Fungsi map Arduino. Tabel di bawah menunjukkan nilai kurva untuk rentang 25–45 °C dan kecepatan minimum 20%; kemiringannya 4% per derajat.

SuhuKecepatan kipas (%)PWM 8-bit (0–255)Uno Timer1 OCR1A (0–320)
25 °C ke bawah205164
30 °C40102128
35 °C60153192
40 °C80204256
45 °C ke atas100255320

Kipas PC 4 pin: PWM 25 kHz dan membaca tacho

Kipas 4 pin mengikuti standar kipas Intel: pin 1 adalah GND (hitam), pin 2 +12 V (kuning), pin 3 tacho (hijau), pin 4 kontrol PWM (biru). Kipas selalu diberi daya 12 V penuh; sinyal PWM di jalur biru yang mengatur kecepatan, dan standar meminta frekuensi 25 kHz untuk sinyal ini (21–28 kHz masih diterima). Di dalam kipas ada resistor yang menarik jalur PWM ke atas, jadi kalau jalurnya dibiarkan mengambang, kipas berputar di kecepatan penuh. Output tacho menghasilkan 2 pulsa per putaran. Kamu menghitung pulsa dengan interrupt dan menghitung kecepatannya dengan rumus ini: RPM = (jumlah pulsa ÷ 2) × (60 ÷ waktu pengukuran dalam detik). Kalau kamu menghitung 40 pulsa dalam 1 detik, kipas berputar di 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}

Fungsi analogWrite di Arduino tidak bisa menghasilkan 25 kHz, jadi kita mengatur Timer1 secara langsung. Ketika mode 10 (PWM phase-correct, nilai puncak ICR1) dipilih, frekuensinya 16 MHz ÷ (2 × 1 × ICR1); ICR1 = 320 menghasilkan tepat 25 kHz. Nilai duty ditulis ke register OCR1A antara 0 dan 320, jadi setiap langkah sekitar 0,3%. Jalur tacho disambungkan ke interrupt INT0 di D2; penghitung bertambah satu di setiap tepi turun. Di dalam loop, interrupt dinonaktifkan sebentar sekali agar penghitung bisa dibaca dan di-reset dengan aman. Logika interrupt bisa kamu baca di interrupt Arduino.

Mengatur Timer1 dengan cara ini menonaktifkan analogWrite di D9 dan D10 serta library Servo yang memakai Timer1. Kalau proyekmu juga punya servo, biarkan kipas di Timer1 dan pindahkan servo ke library yang memakai Timer2, seperti ServoTimer2, atau pindahkan proyeknya ke ESP32. Selain itu, sebagian besar kipas 4 pin tetap berputar di kecepatan terendahnya bahkan pada duty 0%; kalau ingin menghentikan kipas sepenuhnya, kamu perlu memutus catu 12 V-nya dengan MOSFET kanal-P terpisah atau relay.

Kontrol kipas dengan ESP32 (25 kHz dengan LEDC)

Di ESP32, unit LEDC dipakai untuk PWM, dan kamu bisa mengatur 25 kHz dalam satu baris; berkat clock 80 MHz, resolusi 8-bit mudah dicapai di frekuensi ini. Di Arduino core 3.x, fungsi LEDC bekerja dengan nomor pin, sedangkan di 2.x dengan nomor channel; kode di bawah bisa dikompilasi di kedua versi berkat pengecekan ESP_ARDUINO_VERSION_MAJOR. Di ESP32, setiap GPIO bisa menerima interrupt; kita memakai GPIO 26 untuk tacho dan melindungi penghitung dengan critical section (portMUX) agar tidak diakses dari dalam dan luar interrupt bersamaan. Kalau kamu memakai kipas 2 kabel, sambungkan GPIO 25 ke gate MOSFET yang menyala penuh di 3,3 V dan pakai kode yang sama; dalam hal ini, abaikan baris-baris tacho.

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}

Kontrol kipas dengan Raspberry Pi Pico dan MicroPython

Hardware PWM di Pico dengan mudah menghasilkan 25 kHz, dan di MicroPython nilai duty diberikan dalam 16 bit antara 0 dan 65535. Modul onewire dan ds18x20 yang dibutuhkan DS18B20 sudah tersedia di build MicroPython untuk Pico, jadi kamu tidak perlu menyalin file tambahan. Kita menghitung pulsa tacho dengan Pin.irq; menonaktifkan interrupt sebentar sekali ketika membaca penghitung mencegah nilainya ter-update setengah jalan. Kalau kamu baru mengenal MicroPython, dasar-dasar MicroPython adalah titik awal yang bagus.

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 agar kipas berjalan senyap

  • Naikkan frekuensi PWM di atas batas pendengaran: PWM bawaan 490 Hz menimbulkan dengung yang jelas di kumparan kipas. 31 kHz pada kipas 2 kabel dan 25 kHz pada kipas 4 pin menghilangkan suara ini sepenuhnya.
  • Ubah kecepatan secara bertahap: Daripada melompatkan duty dari 30% ke 90% sekaligus, naikkan hanya beberapa persen per detik; telinga manusia jauh lebih peka terhadap perubahan kecepatan mendadak dibanding dengung yang stabil.
  • Pakai histeresis: Kalau kipas terus menyala dan mati di suhu ambang, kamu akan mendengar bunyi klik di setiap start dan suara yang naik-turun; beri jarak 2–3 °C di antara ambang nyala dan ambang mati.
  • Rata-ratakan pengukuran: Fluktuasi kecil pada nilai sensor membuat kecepatan kipas naik-turun. Merata-ratakan 5–10 pembacaan terakhir membuat kurvanya lebih tenang; untuk metodenya, lihat artikel menyaring data sensor.
  • Putar kipas besar dengan pelan: Kipas 120 mm di 800 RPM mengalirkan udara kira-kira sebanyak kipas 80 mm di 2500 RPM, dan jauh lebih senyap.
  • Redam getaran: Pasang kipas dengan karet peredam atau gasket silikon, dan jangan letakkan grill dan filter terlalu dekat dengan baling-baling; getaran mekanis sering kali lebih berisik daripada derau listrik.
  • Pilih kecepatan minimum dengan cermat: Cari nilai duty terendah di mana kipas tetap berputar dengan mencoba langsung, lalu pasang batas bawah kurva sedikit di atasnya; kipas yang berputar tersendat-sendat di batasnya menghasilkan suara yang tidak rata.

Ide proyek dengan kontrol kipas

  • Termostat pintar: Pengendali yang menjalankan pemanas dengan relay dan kipas dengan PWM; detailnya ada di artikel termostat Arduino.
  • Pendingin enclosure printer 3D: Kipas exhaust senyap yang menjaga bagian dalam enclosure di bawah 35 °C dan menampilkan kecepatannya di layar; untuk layarnya, lihat panduan layar OLED.
  • Ventilasi rumah kaca: Kipas yang bekerja berdasarkan suhu dan kelembapan; proyek rumah kaca pintar bisa jadi fondasi yang bagus.
  • Pendingin Peltier: Dinginkan heatsink di sisi panas modul Peltier dengan kipas yang makin cepat sesuai suhu sisi itu; lihat modul Peltier.
  • Otomasi rumah: Pantau kecepatan kipas dan suhu dari ponselmu dengan ESP32 lewat MQTT dan Home Assistant.
  • Suhu konstan dengan PID: Daripada kurva linear, pakai kontrol PID untuk membuat sistem kipas yang menjaga sebuah kotak tepat di 30 °C.

Kesalahan umum dan cara mengatasinya

GejalaKemungkinan penyebabSolusi
Kipas tidak berputar sama sekaliGND tidak bersama atau MOSFET bukan logic-levelSambungkan GND adaptor dan Arduino, pakai MOSFET seri L seperti IRLZ44N
Kipas 4 pin selalu di kecepatan penuhJalur PWM tersambung ke pin yang salah atau dibiarkan mengambangCek bahwa kabel biru masuk ke D9, GPIO 25, atau GP16 dan GND-nya bersama
Ada dengung tipis dari kipasPWM bawaan 490 HzNaikkan frekuensi ke 25–31 kHz
Kipas berhenti di kecepatan rendahDuty di bawah ambang start kipasNaikkan PWM_MIN dan pakai kick start
RPM selalu menunjukkan 0Tidak ada resistor pull-up tacho atau pin salahSambungkan 10 kΩ ke tegangan logika, pakai pin yang mendukung interrupt
Nilai RPM sangat tinggi dan melompat-lompatKabel panjang, derau, atau PWM low-side pada kipas 3 kabelPendekkan kabel, pisahkan jalur tacho dari kabel PWM; pada kipas 3 kabel, baca kecepatan hanya di kecepatan penuh
Arduino reset ketika kipas mulai berputarKipas dan board diberi daya dari sumber lemah yang samaPakai adaptor 12 V terpisah untuk kipas, tambahkan dioda dan kapasitor 100 µF
MOSFET sangat panasMOSFET 5 V di board 3,3 V, atau dioda tidak dipasangPilih MOSFET ambang rendah seperti AO3400, pasang dioda flyback
Untuk menemukan nilai putar terendah kipasmu, lakukan tes singkat: mulai dari duty 100%, turunkan 5% setiap 3 detik, dan pantau RPM di Serial Monitor. Nilai 5–10% di atas titik di mana kecepatan jatuh ke nol adalah pilihan aman untuk batas bawah kurva. Pada kipas 2 kabel tanpa output tacho, kamu bisa melakukan tes yang sama dengan mata dan telinga.

Kontrol kipas berdasarkan suhu adalah salah satu topik paling efisien untuk dipelajari karena menggabungkan pembacaan sensor, PWM, interrupt, dan elektronika daya dalam satu proyek. Mulailah dengan kipas 2 kabel sederhana, dan begitu kamu beralih ke kipas PC 4 pin, kamu sudah membangun sistem pendingin sungguhan yang mengukur kecepatannya sendiri dan berjalan senyap. Di aplikasi BlueGrays, kamu bisa mempelajari langkah demi langkah proyek-proyek yang menjadi dasar artikel ini, seperti mengukur suhu dengan DHT11 dan aplikasi PWM dengan ESP32 dan Pico, lengkap dengan skema rangkaian dan kodenya.

Pertanyaan umum

Bagaimana cara mengendalikan kipas 12 V dengan Arduino?

Kamu tidak bisa menyambungkan kipas 12 V langsung ke pin Arduino; pin memberikan 5 V dan hanya menyuplai sekitar 20 mA paling banyak. Untuk kipas 2 kabel, kamu menyambung-putusnya di sisi low-side dengan MOSFET kanal-N logic-level seperti IRLZ44N lalu memberikan PWM. Kipas 4 pin diberi daya langsung dari 12 V dan Arduino hanya mengendalikan jalur PWM biru; di kedua kasus, GND-nya harus bersama.

Kenapa frekuensi PWM kipas 4 pin harus 25 kHz?

Standar kipas 4 pin Intel menetapkan 21–28 kHz untuk sinyal kontrol, dengan target 25 kHz. Karena frekuensi ini di atas batas pendengaran manusia (sekitar 20 kHz), tidak ada dengung dari kumparan. Banyak kipas tidak merespons dengan benar terhadap PWM bawaan Arduino 490 Hz, atau malah berisik.

Bagaimana cara menghitung RPM kipas?

Output tacho kipas PC menghasilkan 2 pulsa per putaran. Kamu membagi jumlah pulsa yang dihitung dalam waktu tertentu dengan 2 lalu mengonversinya ke menit: RPM = pulsa ÷ 2 × 60 ÷ waktu (detik). Misalnya, kalau 50 pulsa terhitung dalam 1 detik, kipas berputar di 1500 RPM.

Apakah kipas 3 kabel bisa dikendalikan dengan PWM?

Bisa, kamu bisa memperlambat kipas 3 kabel dengan memberi PWM pada catu dayanya lewat MOSFET, sama seperti kipas 2 kabel. Namun, karena elektronika kipas kehilangan daya selama periode mati PWM, sinyal tacho jadi rusak dan pembacaan kecepatan tidak bisa diandalkan. Kalau ingin mengukur kecepatan dengan akurat, pakai kipas 4 pin atau turunkan tegangan kipas 3 kabel dengan konverter DC-DC.

Kenapa kipas berhenti atau tidak mau mulai berputar di kecepatan rendah?

Setiap kipas punya level daya minimum agar bisa tetap berputar dan mulai berputar dari diam; sebagian besar kipas 12 V tidak bisa start di bawah sekitar 5–7 V. Solusinya, pasang batas bawah kurva sedikit di atas nilai ini dan mulai kipas dari diam dengan pulsa daya penuh selama setengah detik. Sebagian besar kipas 4 pin tidak berhenti di duty rendah; kipas tetap berputar di kecepatan terendahnya.

MOSFET apa yang sebaiknya dipakai untuk kontrol kipas?

Pada board 5 V seperti Arduino Uno, MOSFET logic-level seperti IRLZ44N, IRL540N, atau IRLB8721 cocok dipakai. Untuk output 3,3 V milik ESP32 dan Pico, pilih komponen yang menyala penuh pada tegangan gate 2,5 V, seperti AO3400 atau IRLML2502. IRFZ44N dan IRF540N butuh tegangan gate 10 V; jika dipakai dengan mikrokontroler, keduanya hanya setengah terbuka dan jadi panas.

Lihat semua proyek
Suhu dan Kelembapan dengan DHT11
AR-55Menengah

Suhu dan Kelembapan dengan DHT11

Seberapa hangat kamarmu, dan apakah udaranya lembap atau kering? Sensor DHT11 mengukur suhu dan kelembapan, dan Arduino menulis nilainya di layar LCD dua baris, diperbarui setiap beberapa detik.

4.7(47)
83
LED Fade dengan PWM ESP32
ES-8Pemula

LED Fade dengan PWM ESP32

Mengubah kecerahan LED secara halus dari 0 ke maksimum, dan dari maksimum ke 0. Kita mengendalikan PWM dengan analogWrite() seperti di Arduino; sintaks yang sama bekerja tanpa masalah di ESP32 Arduino Core 3.0+. Definisi pin + pinMode + analogWrite sudah cukup.

4.8(36)
55
LED Fade PWM Raspberry Pi Pico (Efek Bernapas)
PI-14Pemula

LED Fade PWM Raspberry Pi Pico (Efek Bernapas)

LED tidak lagi sekadar berkedip, ia bernapas! Dengan PWM (Pulse Width Modulation) Pico, kecerahan LED naik lalu turun perlahan, seperti lampu MacBook yang tidur. Pelajari kelas machine.PWM, duty_u16() (kecerahan 16-bit 0–65535), frekuensi PWM (freq(1000): 1000 siklus per detik, tanpa kedipan terlihat), loop range() bertahap, dan output mirip analog dari pin digital. PWM juga dipakai untuk warna RGB, motor, servo, dan buzzer.

4
Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)
ES-13Menengah
Premium

Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)

Di proyek ini, kita mengendalikan kecerahan LED secara analog memakai potensiometer. Pin ADC ESP32 membaca tegangan 0-3,3V dari potensiometer, lalu nilai ini diubah menjadi sinyal PWM (Pulse Width Modulation) dan dikirim ke LED. Hasilnya, ketika kamu memutar potensiometer, LED perlahan menerang dan meredup. Dengan Arduino Core 3.0+, analogWrite() bisa langsung dipakai; di ESP32-S2/S3, resolusi ADC tetap 12-bit.

4.5(19)
32
Mengukur Suhu dengan NTC dan Layar LCD 2x16
AR-44Pemula
Premium

Mengukur Suhu dengan NTC dan Layar LCD 2x16

Ukur suhu di sekitarmu dengan sensor yang mirip manik-manik kecil. Komponen bernama NTC ini makin mudah dilewati listrik ketika makin hangat; Arduino membaca perubahan itu, mengubahnya menjadi…

4.5(33)
44
Suhu dan Kelembapan DHT22 ESP32 (dengan Layar LCD)
ES-15Menengah

Suhu dan Kelembapan DHT22 ESP32 (dengan Layar LCD)

Proyek ini mengukur suhu dan kelembapan sekitar dengan sensor DHT22 dan menampilkan datanya secara real-time di LCD I2C 16x2. Data dibaca dari sensor dengan protokol satu kabel lewat library Adafruit DHT. Proyek ini menjadi dasar untuk stasiun cuaca IoT, otomasi rumah pintar, atau sistem pemantauan lingkungan di rumah kaca. Komunikasi dengan DHT22 dilakukan lewat pin GPIO 4 ESP32.

4.8(38)
57
Pencatat Data Suhu ESP32 (DHT22 + RTC DS1307 + microSD + OLED)
ES-40Mahir
Premium

Pencatat Data Suhu ESP32 (DHT22 + RTC DS1307 + microSD + OLED)

Buat pencatat suhu bercap waktu dengan ESP32! Baca suhu/kelembapan DHT22 setiap menit, ambil waktu sebenarnya dari RTC DS1307, dan catat ke kartu microSD sebagai CSV. OLED menampilkan suhu langsung (font besar), kelembapan, cap waktu, dan penghitung catatan. File /temp_log.csv bisa dibuka di Excel, Google Sheets, atau Python pandas; cocok untuk rumah kaca, suhu kamar, data laboratorium, penyimpanan makanan, atau sarang lebah.

4.7(7)
12
Stasiun Penyiraman Pintar
AR-83Mahir
Premium

Stasiun Penyiraman Pintar

Tukang kebun yang menyiram tanamanmu sendiri, supaya tanaman tidak kering ketika kamu berlibur.

5.0(42)
57