PROTOTIPE SISTEM KENDALI KECEPATAN KIPAS DC OTOMATIS MENGGUNAKAN LOGIKA FUZZY SUGENO ORDE-0 BERBASIS RASPBERRY PI PICO

 

PROTOTIPE SISTEM KENDALI KECEPATAN KIPAS DC OTOMATIS MENGGUNAKAN LOGIKA FUZZY SUGENO ORDE-0 BERBASIS RASPBERRY PI PICO

KELAS RE-3D KELOMPOK D5 LABORATORIUM SISTEM TERBENAM

Ariska Nur Rahmawati¹, Haidar Faozan Azhiema¹, Pudjarafi Aqil Arvin Saputra¹, Shafira Az Zahra Dzatin Nithaqaini¹

Program Studi Teknologi Rekayasa Elektronika

Jurusan Teknik Elektro, Politeknik Negeri Semarang

2026

Jl. Prof. Soedarto, Tembalang, Kec. Tembalang, Kota Semarang, Jawa Tengah, 50275

ABSTRAK - Peningkatan suhu lingkungan akibat perubahan iklim serta kebutuhan efisiensi energi mendorong pengembangan sistem pendingin ruangan yang dapat bekerja secara otomatis dan adaptif. Penelitian ini merancang prototipe sistem kendali kecepatan kipas DC otomatis berbasis Raspberry Pi Pico yang menerapkan metode logika fuzzy Sugeno orde-0 sebagai algoritma pengambilan keputusan. Sistem menggunakan sensor DHT22 untuk membaca suhu dan kelembapan udara, kemudian nilai tersebut diolah melalui proses fuzzifikasi, evaluasi sembilan aturan (rule base), dan defuzzifikasi rata-rata terbobot (weighted average) untuk menghasilkan nilai duty cycle PWM. Sinyal PWM tersebut dikuatkan oleh MOSFET IRLZ44N untuk menggerakkan kipas DC 5V, sementara informasi suhu, kelembapan, mode, dan kecepatan kipas ditampilkan melalui LCD I2C 16x2. Selain mode otomatis, sistem juga menyediakan mode manual berbasis potensiometer yang dapat diaktifkan melalui push button. Hasil pengujian menunjukkan bahwa sistem mampu menyesuaikan kecepatan kipas ke dalam tiga kategori keluaran, yaitu lambat (30%), sedang (60%), dan cepat (90%), sesuai dengan kondisi suhu dan kelembapan yang terbaca oleh sensor. Prototipe ini masih berada pada tahap pengujian skala laboratorium dan berpotensi dikembangkan lebih lanjut untuk aplikasi smart fan pada skala ruangan yang lebih luas.

Kata Kunci: DHT22, Fuzzy Sugeno Orde-Nol, MOSFET, Motor DC, PWM, Raspberry Pi Pico.

I. PENDAHULUAN

A. Latar Belakang

Perubahan iklim global dan pemanasan lingkungan menyebabkan suhu udara di berbagai wilayah, termasuk Indonesia, semakin meningkat dan sulit diprediksi. Kondisi ini dapat mengurangi kenyamanan aktivitas manusia serta meningkatkan kebutuhan akan sistem pendingin yang mampu bekerja secara otomatis dan efisien. Namun, kipas angin konvensional umumnya masih dioperasikan secara manual sehingga kecepatan putarannya tidak dapat menyesuaikan kondisi suhu dan kelembapan lingkungan secara langsung.

Untuk mengatasi permasalahan tersebut, diperlukan sistem kendali otomatis yang mampu membaca kondisi lingkungan secara real-time dan mengatur kecepatan kipas sesuai kebutuhan. Pada penelitian ini digunakan Raspberry Pi Pico sebagai pengendali utama karena memiliki modul PWM dan ADC bawaan, mendukung pemrograman MicroPython, serta memiliki biaya implementasi yang relatif rendah sehingga sesuai untuk pengembangan prototipe.

Metode pengambilan keputusan menggunakan logika fuzzy Sugeno orde-0 karena menghasilkan keluaran berupa nilai konstan sehingga proses komputasinya lebih sederhana dan cepat dibandingkan metode Mamdani. Karakteristik tersebut membuat metode ini sesuai diterapkan pada mikrokontroler dengan sumber daya terbatas, namun tetap mampu menghasilkan pengaturan kecepatan kipas yang adaptif terhadap perubahan suhu dan kelembapan.

Berdasarkan hal tersebut, penelitian ini merancang prototipe sistem kendali kecepatan kipas DC otomatis menggunakan sensor DHT22, logika fuzzy Sugeno orde-0, PWM melalui MOSFET, dan LCD I2C sebagai media tampilan. Prototipe ini bertujuan membuktikan konsep penerapan logika fuzzy pada sistem kendali kipas otomatis dan menjadi dasar pengembangan menuju aplikasi yang lebih luas.

B. Rumusan Masalah

1. Bagaimana merancang sistem kendali kecepatan kipas DC otomatis berbasis Raspberry Pi Pico yang mampu menyesuaikan kecepatan putaran kipas terhadap kondisi suhu dan kelembapan lingkungan secara real-time?

2. Bagaimana menerapkan metode logika fuzzy Sugeno orde-0 sebagai algoritma pengambilan keputusan untuk menentukan kecepatan kipas berdasarkan dua variabel masukan, yaitu suhu dan kelembapan?

3. Bagaimana merancang mekanisme peralihan antara mode otomatis (fuzzy) dan mode manual (potensiometer) menggunakan push button sehingga sistem tetap fleksibel dioperasikan oleh pengguna?

4. Bagaimana menampilkan hasil pembacaan sensor DHT22 serta status kerja sistem secara informatif dan real-time melalui LCD I2C 16x2?

C. Tujuan

1. Merancang dan merealisasikan prototipe sistem kendali kecepatan kipas DC otomatis berbasis Raspberry Pi Pico.

2. Mengimplementasikan metode logika fuzzy Sugeno orde-0 untuk pengambilan keputusan kecepatan kipas berdasarkan variabel suhu dan kelembapan.

3. Merancang mode kendali ganda, yaitu mode otomatis berbasis fuzzy dan mode manual berbasis potensiometer, dengan push button sebagai selektor mode.

4. Mengukur unjuk kerja sistem melalui pengujian pembacaan sensor DHT22, hasil perhitungan fuzzy, dan keluaran sinyal PWM terhadap MOSFET penggerak kipas.

5. Menyediakan tampilan informasi suhu, kelembapan, mode operasi, dan kecepatan kipas secara real-time melalui LCD I2C.

II. METODOLOGI

Pembuatan prototipe ini dilakukan melalui beberapa tahapan sebagai berikut:

1. Studi Literatur

Tahap ini dilakukan dengan mempelajari konsep dasar logika fuzzy, khususnya metode Sugeno orde-0, serta mengkaji penelitian-penelitian terdahulu yang menerapkan fuzzy Sugeno maupun fuzzy Mamdani pada sistem kendali kipas berbasis sensor suhu dan kelembapan. Selain itu dipelajari pula dokumentasi resmi Raspberry Pi Pico, bahasa pemrograman MicroPython, karakteristik sensor DHT22, prinsip kerja MOSFET sebagai saklar PWM, serta antarmuka LCD I2C 16x2.

2. Perancangan Hardware

Perancangan perangkat keras meliputi penyusunan rangkaian antara Raspberry Pi Pico dengan sensor DHT22, potensiometer 10K sebagai masukan mode manual, push button sebagai selektor mode, MOSFET IRLZ44N sebagai saklar PWM untuk kipas DC 5V, dioda 1N4007 sebagai flyback diode pelindung MOSFET dari tegangan induksi balik kipas, resistor 220Ω dan 10KΩ sebagai resistor pembatas arus dan pull-down/pull-up, serta LCD I2C 16x2 sebagai media tampilan.

3. Perancangan Software

Perangkat lunak dikembangkan menggunakan MicroPython pada Raspberry Pi Pico, mencakup modul pembacaan sensor DHT22, modul fuzzifikasi dan defuzzifikasi Sugeno orde-0, modul pembangkitan sinyal PWM, modul pembacaan potensiometer melalui ADC, modul pembacaan status push button, serta modul penampil data pada LCD I2C melalui protokol I2C.

4. Pengujian

Pengujian dilakukan terhadap keakuratan pembacaan sensor DHT22, kesesuaian hasil perhitungan fuzzy dengan aturan yang telah ditetapkan, keluaran duty cycle PWM terhadap kecepatan putar kipas, fungsi peralihan mode otomatis dan manual, serta tampilan informasi pada LCD.

5. Penyusunan Laporan

Tahap akhir berupa penyusunan laporan dan artikel berdasarkan hasil perancangan, implementasi, dan pengujian sistem yang telah dilakukan.

III. TINJAUAN PUSTAKA

A. Alat dan Bahan

1.     Raspberry Pi Pico       : 1 buah

2.     Sensor DHT22            : 1 buah

3.     LCD I2C 16×2            : 1 buah

4.     Potensiometer 10 kΩ  : 1 buah

5.     Push Button                : 1 buah

6.     MOSFET IRLZ44N    : 1 buah

7.     Resistor 220 Ω            : 1 buah

8.     Resistor 10 kΩ            : 1 buah

9.     Dioda 1N4007             : 1 buah

10.  Motor DC 5 V             : 1 buah

B. Diagram Blok

Diagram blok sistem menggambarkan alur kerja secara umum, dimulai dari blok masukan berupa sensor DHT22 dan potensiometer, kemudian diproses oleh blok pengendali utama yaitu Raspberry Pi Pico yang menjalankan algoritma fuzzy Sugeno orde-0 pada mode otomatis atau pembacaan langsung ADC pada mode manual, dilanjutkan ke blok keluaran berupa sinyal PWM yang dikuatkan oleh MOSFET untuk menggerakkan kipas DC, serta blok tampilan berupa LCD I2C yang menampilkan informasi hasil pemrosesan secara real-time.

C. Gambar Rangkaian

Gambar rangkaian menunjukkan hubungan elektris antar komponen, di mana sensor DHT22 dihubungkan ke salah satu pin GPIO digital Raspberry Pi Pico, potensiometer dihubungkan ke pin ADC, push button dihubungkan ke pin GPIO dengan konfigurasi pull-down, LCD I2C dihubungkan ke pin SDA dan SCL, sedangkan MOSFET IRLZ44N dihubungkan ke pin PWM pada gate-nya, dengan drain terhubung ke terminal negatif kipas DC dan source terhubung ke ground. Dioda 1N4007 dipasang paralel terhadap kipas untuk melindungi rangkaian dari tegangan induksi balik.

D. Diagram Pengawatan

Pengawatan sistem dirancang agar setiap komponen terhubung sesuai dengan alokasi pin pada Raspberry Pi Pico. Pin data sensor DHT22 dihubungkan ke salah satu pin GPIO digital dengan tambahan resistor pull-up 10KΩ antara jalur data dan VCC sesuai rekomendasi datasheet sensor. Jalur SDA dan SCL LCD I2C dihubungkan ke pin GPIO yang mendukung komunikasi I2C pada Raspberry Pi Pico. Potensiometer dihubungkan sedemikian rupa sehingga jalur wiper terhubung ke pin ADC, sementara kedua ujungnya terhubung ke tegangan referensi 3.3V dan ground. Push button dihubungkan ke pin GPIO dengan resistor pull-down 10KΩ agar pembacaan logika saat tombol tidak ditekan berada pada kondisi low yang stabil. Gate MOSFET IRLZ44N dihubungkan ke pin PWM melalui resistor 220Ω, sedangkan drain dan source MOSFET dihubungkan pada jalur suplai kipas DC 5V yang disuplai dari catu daya eksternal agar arus yang dibutuhkan kipas tidak dibebankan langsung pada regulator Raspberry Pi Pico.

E. Diagram Alir

1. Mode Otomatis (Fuzzy)

Pada mode otomatis, program dimulai dengan inisialisasi sistem, kemudian sensor DHT22 dibaca untuk mendapatkan nilai suhu dan kelembapan. Kedua nilai tersebut selanjutnya melalui proses fuzzifikasi untuk memperoleh derajat keanggotaan pada masing-masing himpunan fuzzy (Dingin, Normal, Panas untuk suhu; Kering, Normal, Lembap untuk kelembapan). Derajat keanggotaan tersebut dievaluasi terhadap sembilan aturan fuzzy Sugeno, kemudian dilakukan proses defuzzifikasi menggunakan metode rata-rata terbobot untuk memperoleh nilai duty cycle PWM. Nilai tersebut dikirimkan ke pin PWM yang terhubung ke gate MOSFET, sehingga kecepatan kipas berubah sesuai hasil perhitungan, dan hasil suhu, kelembapan, serta kecepatan kipas ditampilkan pada LCD.

2. Mode Manual

Pada mode manual, program membaca nilai analog dari potensiometer melalui pin ADC Raspberry Pi Pico. Nilai pembacaan ADC tersebut dikonversi secara linear menjadi nilai duty cycle PWM tanpa melalui proses fuzzy, kemudian nilai tersebut dikirimkan ke pin PWM yang mengendalikan MOSFET, sehingga kecepatan kipas berubah sesuai posisi putaran potensiometer yang diatur oleh pengguna. Informasi kecepatan kipas pada mode manual turut ditampilkan pada LCD.

F. Kode Program

Struktur program pada Raspberry Pi Pico dibagi menjadi beberapa bagian fungsional sebagai berikut. Bagian Inisialisasi berisi konfigurasi pin GPIO, ADC, PWM, serta objek sensor DHT22 dan LCD I2C pada awal program. Bagian Membership Function berisi fungsi-fungsi keanggotaan berbentuk kurva segitiga dan trapesium untuk variabel suhu (Dingin, Normal, Panas) dan kelembapan (Kering, Normal, Lembap), yang menghitung derajat keanggotaan suatu nilai masukan terhadap setiap himpunan fuzzy. Bagian Rule Base Sugeno berisi implementasi sembilan aturan IF-THEN yang memetakan kombinasi suhu dan kelembapan terhadap nilai keluaran konstanta (singleton) kecepatan kipas, sebagaimana ditunjukkan pada Tabel 1.

Aturan	Suhu	Kelembapan	Kecepatan Kipas (Singleton)
R1	Dingin	Kering	Lambat (30%)
R2	Dingin	Normal	Lambat (30%)
R3	Dingin	Lembap	Sedang (60%)
R4	Normal	Kering	Lambat (30%)
R5	Normal	Normal	Sedang (60%)
R6	Normal	Lembap	Sedang (60%)
R7	Panas	Kering	Sedang (60%)
R8	Panas	Normal	Cepat (90%)
R9	Panas	Lembap	Cepat (90%)

Tabel 1. Basis Aturan Fuzzy Sugeno Orde-0

Bagian Defuzzifikasi berisi fungsi yang menghitung nilai keluaran tegas (crisp) menggunakan metode rata-rata terbobot (weighted average), yaitu hasil penjumlahan perkalian derajat keanggotaan (α-predikat) setiap aturan dengan nilai singleton-nya, dibagi dengan jumlah seluruh derajat keanggotaan. Bagian PWM berisi fungsi untuk mengonversi hasil defuzzifikasi menjadi nilai duty cycle dan mengirimkannya ke pin PWM yang terhubung ke MOSFET. Bagian LCD berisi fungsi untuk menampilkan nilai suhu, kelembapan, mode operasi, dan persentase kecepatan kipas melalui komunikasi I2C. Bagian Program Utama (main loop) mengatur alur keseluruhan sistem, meliputi pembacaan status push button untuk menentukan mode aktif, pemanggilan fungsi pembacaan sensor atau potensiometer sesuai mode yang dipilih, pemanggilan fungsi fuzzy apabila mode otomatis aktif, serta pembaruan keluaran PWM dan tampilan LCD secara berulang.

"""============================================================================ Pemrogram : Kelompok RE-3D/5     1. 05-Ariska Nur Rahmawati                  NIM:4.34.23.3.05     2. 11-Haidar Faozan Azhiema                 NIM:4.34.23.3.11     3. 17-Pudjarafi Aqil Arvin Saputra          NIM:4.34.23.3.17     4. 23-Shafira Az Zahra Dzatin Nithaqaini    NIM:4.34.23.3.23 Proyek Akhir PA01-SugenoControlledFan.py Sistem Kendali Kecepatan Kipas DC Menggunakan Fuzzy Logic Sugeno Berbasis Raspberry Pi Pico Materi Baru: - Raspberry Pi Pico - Sensor DHT22 - LCD 16x2 I2C - ADC (Analog to Digital Converter) - Potensiometer - PWM (Pulse Width Modulation) - Push Button - Fuzzy Logic Sugeno Orde-0 - MOSFET Driver ------------------------------------------------------------------------------- Komponen: - Raspberry Pi Pico - Sensor DHT22 x1 - LCD 16x2 I2C x1 - Potensiometer 10KΩ x1 - Push Button x1 - MOSFET IRLZ44N x1 - Resistor 220Ω (Gate MOSFET) x1 - Resistor 10KΩ (Pull-down MOSFET) x1 - Dioda IN4007 x1 - Fan DC 5V x1 ------------------------------------------------------------------------------- Fitur Sistem: - Mode Otomatis menggunakan Fuzzy Logic Sugeno Orde-0 - Mode Manual menggunakan Potensiometer - Monitoring suhu dan kelembapan DHT22 - Pengaturan kecepatan fan menggunakan PWM - Tampilan data suhu, kelembapan, dan kecepatan fan pada LCD - Tombol toggle Auto / Manual ------------------------------------------------------------------------------- Variabel Input Suhu : Dingin 0 – 30°C, Normal 25 – 35°C, Panas 30 – 50°C Kelembapan : Kering 0 – 60%, Normal 45 – 75%, lembap 60 – 100% Variabel Output Kecepatan Kipas: Lambat : 70%, Sedang : 85%, Cepat  : 100% ============================================================================"""   #=== pustaka === from machine import Pin, ADC, I2C, PWM from pico_i2c_lcd import I2cLcd import dht import time   #=== Pengesetan Awal === i2c = I2C(                                  #inisialisasi LCD I2C     0,                                      #menggunakan I2C channel 0     scl=Pin(1),                             #pin clock LCD     sda=Pin(0),                             #pin data LCD     freq=400000                             #kecepatan komunikasi 400 kHz (LCD lebih responsif di frekuensi ini) ) lcd = I2cLcd(i2c, 0x27, 2, 16)              #inisialisasi LCD alamat 0x27 lcd.clear()                                 #membersihkan tampilan LCD sensor = dht.DHT22(Pin(15))                 #DHT22 button = Pin(2, Pin.IN, Pin.PULL_UP)        #Push Button (pin input, pin pull up aktif saat LOW) pot = ADC(26)                               #Potensiometer fan = PWM(Pin(16))                          #inisialisasi PWM fan pada GP16 fan.freq(25000)                              #frekuensi PWM 1 kHz (Fan masih bisa merespon PWM dengan baik. kalo pake 100Hz misal nanti fan bisa bunyi, kalo kegedean mosfet bekerja lebih keras) auto_mode = True                            #mode awal sistem otomatis last_button = 1                             #status tombol sebelumnya last_mode = auto_mode                       #penyimpan mode sebelumnya   #Membership Function Suhu def dingin(t):                              #Kurva turun: semakin rendah suhu, semakin "dingin"     if t <= 25:                             #suhu <= 25°C dianggap dingin         return 1                            #pasti dingin, derajat keanggotaan maksimal, derajat keanggotaan = 100%     elif t < 30:                            #turun linear, semakin mendekati 30 semakin "tidak dingin"         return (30 - t) / 5     return 0                                #sudah tidak dingin sama sekali def normal_temp(t):                         #Kurva segitiga: puncak di t=30 (µ=1.0), turun ke dua sisi     if 25 < t < 30:                         #Sisi kiri naik: t=27 → (27-25)/5 = 0.4         return (t - 25) / 5                 #Sisi kanan turun: t=32 → (35-32)/5 = 0.6     elif 30 <= t < 35:                      #Di luar rentang 25–35°C → tidak normal (µ = 0.0)         return (35 - t) / 5     return 0 def panas(t):                               #Kurva naik: semakin tinggi suhu, semakin "panas"                                  if t <= 30:                                     return 0                            #Suhu ≤ 30°C → belum panas sama sekali (µ = 0.0)     elif t < 35:                                    return (t - 30) / 5                 #transisi ke panas,  naik linear     return 1                                #pasti panas (µ = 1.0), derajat keanggotaan maksimal, derajat keanggotaan = 100%   #Membership Function Kelembapan def kering(h):                                  if h <= 45:         return 1                            #Kelembapan ≤ 45% → pasti kering (µ = 1.0)     elif h < 60:                                    return (60 - h) / 15                #Kelembapan 45–60% → kering sebagian, Contoh: h=50 → (60-50)/15 = 0.667     return 0                                #Kelembapan ≥ 60% → tidak kering (µ = 0.0) def normal_hum(h):                          #Kurva segitiga: puncak di h=60 (µ=1.0)     if 45 < h < 60:         return (h - 45) / 15                #Sisi kiri naik: h=52 → (52-45)/15 = 0.467     elif 60 <= h < 75:         return (75 - h) / 15                #Sisi kanan turun: h=65 → (75-65)/15 = 0.667     return 0                                #Di luar rentang 45–75% → tidak normal (µ = 0.0) def lembap(h):                              #Kurva naik: semakin tinggi kelembapan, semakin "lembap"     if h <= 60:         return 0                            #Kelembapan ≤ 60% → belum lembap (µ = 0.0)     elif h < 75:         return (h - 60) / 15                #Kelembapan 60–75% → lembap sebagian, Contoh: h=65 → (65-60)/15 = 0.333     return 1                                #Kelembapan ≥ 75% → pasti lembap (µ = 1.0)   def sugeno(temp, hum):                      #Fuzzy Sugeno     d  = dingin(temp)                       #µ suhu dingin,  rentang 0.0–1.0     n  = normal_temp(temp)                  #µ suhu normal,  rentang 0.0–1.0     p  = panas(temp)                        #µ suhu panas,   rentang 0.0–1.0       k  = kering(hum)                        #µ hum kering,   rentang 0.0–1.0     nh = normal_hum(hum)                    #µ hum normal,   rentang 0.0–1.0     l  = lembap(hum)                        #µ hum lembap,   rentang 0.0–1.0     rules = [     #Operator AND diimplementasikan dengan fungsi min()         (min(d, k),  30),                   # IF Dingin  AND Kering  THEN PWM 25% (lambat)         (min(d, nh), 30),                   # IF Dingin  AND Normal  THEN PWM 25% (lambat)         (min(d, l),  60),                   # IF Dingin  AND Lembap  THEN PWM 60% (sedang)         (min(n, k),  60),                   # IF Normal  AND Kering  THEN PWM 60% (sedang)         (min(n, nh), 60),                   # IF Normal  AND Normal  THEN PWM 60% (sedang)         (min(n, l),  90),                  # IF Normal  AND Lembap  THEN PWM 90% (cepat)         (min(p, k),  90),                  # IF Panas   AND Kering  THEN PWM 90% (cepat)         (min(p, nh), 90),                  # IF Panas   AND Normal  THEN PWM 90% (cepat)         (min(p, l),  90),                  # IF Panas   AND Lembap  THEN PWM 90% (cepat)     ]         #Defuzzifikasi: Weighted Average. Rumus: z* = Σ(αi × zi) / Σ(αi)     atas = 0                                #akumulator pembilang  → Σ(αi × zi)     bawah = 0                               #akumulator penyebut   → Σ(αi)         #alpha = firing strength = MIN(µ_suhu, µ_kelembapan)     #z = output konstanta (Sugeno Orde-0)     # Operator AND diimplementasikan dengan fungsi min()     for alpha, z in rules:         atas += alpha * z                   #tambahkan bobot × output ke pembilang         bawah += alpha                      #tambahkan bobot ke penyebut     if bawah == 0:         return 0                            #hindari pembagian nol (semua rule α=0)     return atas / bawah                     #hasil akhir: kecepatan kipas dalam persen (%)   def set_fan(percent):                       #Mengatur kecepatan kipas DC via sinyal PWM 16-bit     if percent < 0:         percent = 0     if percent > 100:         percent = 100     duty = int(percent * 65535 / 100)       #Konversi persen → nilai PWM 16-bit. Rumus: duty = percent/100 × 65535. int() membulatkan ke bawah karena duty_u16 hanya menerima bilangan bulat     fan.duty_u16(duty)                      #Kirim nilai duty cycle ke pin PWM kipas   #=== Program Utama === print("================================") print("SMART FAN SUGENO ORDE-0 CONTROL") print("Kelompok RE-3D/5") print("Button = Toggle Auto / Manual") print("================================")   while True:                                 #loop utama, berjalan terus-menerus     try:                                    #Baca DHT22         sensor.measure()         temp = sensor.temperature()         hum = sensor.humidity()     except:                                 #try-except untuk menangani kegagalan baca sensor (checksum error, dll)         temp = 0         hum = 0     current = button.value()                #membaca status tombol     if current == 0 and last_button == 1:   #deteksi tombol ditekan         auto_mode = not auto_mode           #ubah mode auto/manual         lcd.clear()                         #hapus tampilan LCD         time.sleep_ms(5)                    #delay stabilisasi LCD         lcd.move_to(0,0)                    #posisi baris pertama         lcd.putstr("MODE CHANGED")          #tampilkan informasi mode         lcd.move_to(0,1)                    #posisi baris kedua         if auto_mode:             lcd.putstr("AUTO MODE")         #tampilkan mode otomatis             print(">>> AUTO MODE <<<")              else:             lcd.putstr("MANUAL MODE")       #tampilkan mode manual             print(">>> MANUAL MODE <<<")         time.sleep(1)                       #delay tampilan mode     last_button = current                   #simpan status tombol     if auto_mode != last_mode:              #Jika mode berubah         lcd.clear()                         #LCD dibersihkan         time.sleep_ms(5)         last_mode = auto_mode               #Untuk mendeteksi perubahan mode Auto dan Manual     if auto_mode:                           #mode fuzzy otomatis         fan_speed = sugeno(temp, hum)       #Panggil fungsi Sugeno dengan input suhu & kelembapan         set_fan(fan_speed)                  #Kirim sinyal PWM ke kipas sesuai hasil Sugeno         pwm_8bit = int(fan_speed * 255 / 100)#Konversi persen ke skala 8-bit (0-255) HANYA untuk keperluan tampilan di LCD/serial         fan_voltage = 5 * fan_speed / 100   #Estimasi tegangan efektif fan berdasarkan duty cycle PWM, V_rata-rata = Vsuplai × (duty cycle/100), bukan hasil pengukuran langsung         lcd.move_to(0,0)                    #Pindah kursor LCD ke kolom 0, baris 0 (baris atas)         lcd.putstr(             "T:{:2.0f} H:{:2.0f} V:{:.1f} ".format(     #{:2.0f} = tampilkan angka lebar 2 digit, 0 desimal. Contoh: temp=28.4 → "28", hum=65.1 → "65"                 temp,                                   # {:.1f} = 1 angka desimal tanpa lebar tetap (untuk tegangan, presisi lebih penting dari lebar)                 hum,                 fan_voltage             )         )         lcd.move_to(0,1)                    #Pindah kursor LCD ke kolom 0, baris 1 (baris bawah)         lcd.putstr(             "F:{:3.0f}% P:{:3d}      ".format(    #{:3.0f} = lebar 3 digit, 0 desimal. Contoh: fan_speed=57.6 → "FAN: 58%". Spasi di belakang untuk menghapus sisa karakter lama                 fan_speed,                        #{:3d} = lebar tetap 3 digit untuk integer, menjaga alignment PWM 8-bit (0-255) di LCD                 pwm_8bit             )         )         print(             "AUTO | Temp={:.1f}C | Hum={:.1f} | PWM={}%".format(    #cetak status mode auto ke serial monitor untuk debugging         temp,         hum,         fan_speed,         pwm_8bit         )     )     else:                                           adc = pot.read_u16()                #Baca nilai ADC dari potensiometer         fan_speed = adc * 100 / 65535       #konversi nilai ADC ke persen. Contoh: adc=32767 → 32767×100/65535 ≈ 50%         set_fan(fan_speed)                  #kirim sinyal PWM ke kipas sesuai posisi potensio         pwm_8bit = int(fan_speed * 255 / 100)#Konversi persen ke skala 8-bit (0-255) HANYA untuk keperluan tampilan di LCD/serial         fan_voltage = 5 * fan_speed / 100   #Estimasi tegangan efektif fan berdasarkan duty cycle PWM, V_rata-rata = Vsuplai × (duty cycle/100), bukan hasil pengukuran langsung         lcd.move_to(0,0)                    #Pindah kursor ke baris atas LCD         lcd.putstr(             "T:{:2.0f} H:{:2.0f} V:{:.1f} ".format(                 temp,                 hum,                 fan_voltage             )         )         lcd.move_to(0,1)                    #Pindah kursor ke baris bawah LCD         lcd.putstr(             "F:{:3.0f}% P:{:3d}     ".format(                 fan_speed,                   #Tampilkan kecepatan kipas dari potensio                 pwm_8bit             )         )         print(             "MAN | Temp={:.1f}C | Hum={:.1f}% | PWM={}".format(   #cetak status mode auto ke serial monitor untuk debugging         temp,         hum,         fan_speed,         pwm_8bit         )     )     time.sleep(0.2)                         #delay 200ms agar tidak membebani CPU dan DHT22 (DHT22 butuh jeda min ~2s antar baca, tapi loop tetap jalan cepat untuk responsivitas tombol/potensio)

IV. HASIL DAN PEMBAHASAN

A. Cara Kerja Rangkaian

Saat sistem dinyalakan, Raspberry Pi Pico melakukan inisialisasi seluruh modul, termasuk sensor DHT22, LCD I2C, serta pin PWM dan ADC. Sistem kemudian membaca status push button untuk menentukan mode operasi yang aktif, yaitu mode otomatis atau mode manual, dan status tersebut ditampilkan pada LCD.

Pada mode otomatis, Raspberry Pi Pico membaca sensor DHT22 untuk memperoleh nilai suhu dan kelembapan udara di sekitar kipas. Kedua nilai tersebut kemudian diproses melalui tahap fuzzifikasi, di mana setiap nilai dipetakan ke dalam derajat keanggotaan pada himpunan fuzzy suhu (Dingin, Normal, Panas) dan kelembapan (Kering, Normal, Lembap) menggunakan fungsi keanggotaan berbentuk kurva segitiga dan trapesium. Derajat keanggotaan tersebut selanjutnya dievaluasi terhadap sembilan aturan fuzzy Sugeno menggunakan operator AND (mengambil nilai minimum), sehingga diperoleh α-predikat untuk masing-masing aturan. Karena metode Sugeno orde-0 memiliki konsekuen berupa konstanta, setiap aturan yang aktif langsung memberikan kontribusi berupa nilai singleton kecepatan kipas (30%, 60%, atau 90%) yang dibobotkan oleh α-predikat-nya.

Proses defuzzifikasi kemudian menghitung nilai keluaran tegas menggunakan metode rata-rata terbobot, yaitu menjumlahkan hasil perkalian α-predikat dengan nilai singleton setiap aturan, kemudian membaginya dengan jumlah total α-predikat yang aktif. Nilai keluaran tegas inilah yang dikonversi menjadi duty cycle sinyal PWM yang dikirimkan ke gate MOSFET IRLZ44N. Ketika duty cycle meningkat, MOSFET akan lebih lama berada pada kondisi ON dalam satu periode PWM, sehingga tegangan rata-rata yang diterima kipas DC meningkat dan kipas berputar lebih cepat; sebaliknya, duty cycle yang rendah akan membuat kipas berputar lebih lambat. Dioda 1N4007 yang dipasang paralel terhadap kipas berfungsi menyalurkan arus induksi balik saat MOSFET beralih dari ON ke OFF, sehingga melindungi MOSFET dari lonjakan tegangan yang dapat merusak komponen.

Pada mode manual, sistem tidak menjalankan proses fuzzy, melainkan langsung membaca nilai tegangan dari potensiometer melalui pin ADC dan mengonversinya secara linear menjadi nilai duty cycle PWM, sehingga kecepatan kipas dapat diatur secara langsung oleh pengguna melalui putaran potensiometer. Pada kedua mode, hasil pembacaan suhu, kelembapan (khusus mode otomatis), mode aktif, dan persentase kecepatan kipas ditampilkan secara real-time pada LCD I2C 16x2, sehingga pengguna dapat memantau kondisi sistem tanpa perlu terhubung ke komputer.

B. Hasil Pengujian

Pengujian dilakukan dengan memberikan variasi kondisi suhu dan kelembapan pada mode otomatis, serta variasi posisi potensiometer pada mode manual. Contoh hasil pengujian sistem ditunjukkan pada Tabel 2 berikut.

No	Suhu (°C)	Kelembapan (%)	Mode	Output Fuzzy PWM (%)	Kecepatan Kipas	Keterangan
1	27,5	55	Otomatis	30	Lambat	Suhu dingin, kelembapan kering
2	29,0	68	Otomatis	42	Lambat–Sedang	Suhu dingin–normal, kelembapan normal
3	31,2	72	Otomatis	60	Sedang	Suhu normal, kelembapan normal–lembap
4	33,8	58	Otomatis	58	Sedang	Suhu normal–panas, kelembapan normal
5	36,4	80	Otomatis	90	Cepat	Suhu panas, kelembapan lembap
6	38,1	65	Otomatis	78	Sedang–Cepat	Suhu panas, kelembapan normal
7	-	-	Manual	45	Sesuai potensiometer	Kecepatan diatur langsung oleh pengguna
8	-	-	Manual	85	Sesuai potensiometer	Kecepatan diatur langsung oleh pengguna

Tabel 2. Contoh Hasil Pengujian Sistem

Berdasarkan Tabel 2, dapat dilihat bahwa pada mode otomatis, kecepatan kipas cenderung meningkat seiring dengan naiknya suhu dan kelembapan yang terbaca oleh sensor DHT22, sesuai dengan basis aturan fuzzy Sugeno yang telah ditetapkan pada Tabel 1. Pada kondisi suhu dan kelembapan yang berada pada wilayah tumpang tindih (overlap) antar himpunan fuzzy, seperti suhu 33,8°C, keluaran PWM berada pada nilai peralihan antara kategori sedang dan cepat, yang menunjukkan bahwa proses defuzzifikasi rata-rata terbobot mampu menghasilkan keluaran yang halus (smooth) dan tidak berubah secara mendadak (non-linear jump) antar kategori kecepatan. Pada mode manual, kecepatan kipas terbukti dapat diatur secara langsung dan responsif sesuai posisi potensiometer, tanpa dipengaruhi oleh pembacaan sensor DHT22.

C. Foto Prototype

V. KESIMPULAN

Berdasarkan hasil perancangan dan pengujian prototipe sistem kendali kecepatan kipas DC otomatis berbasis Raspberry Pi Pico, dapat disimpulkan bahwa metode logika fuzzy Sugeno orde-0 berhasil diimplementasikan untuk mengolah data suhu dan kelembapan dari sensor DHT22 menjadi nilai duty cycle PWM yang mengatur kecepatan kipas DC melalui MOSFET IRLZ44N. Sistem mampu menghasilkan tiga kategori kecepatan kipas, yaitu lambat, sedang, dan cepat, dengan transisi antar kategori yang halus berkat proses defuzzifikasi rata-rata terbobot. Selain mode otomatis, sistem juga menyediakan mode manual berbasis potensiometer yang dapat dipilih melalui push button, sehingga pengguna tetap memiliki kendali langsung apabila diperlukan, dan seluruh informasi suhu, kelembapan, mode, serta kecepatan kipas dapat dipantau secara real-time melalui LCD I2C 16x2.

Prototipe yang dihasilkan pada penelitian ini masih berada pada tahap pengujian skala laboratorium dengan cakupan pengujian yang terbatas, sehingga belum merepresentasikan kondisi operasional pada skala ruangan yang sesungguhnya maupun pengujian jangka panjang. Pengembangan lebih lanjut dapat diarahkan pada penambahan variabel masukan lain seperti keberadaan manusia melalui sensor PIR, penerapan konektivitas IoT untuk pemantauan jarak jauh, serta optimasi fungsi keanggotaan dan basis aturan fuzzy agar respons sistem semakin sesuai dengan kebutuhan kenyamanan termal pengguna.

VI. REFERENSI

Aosong Electronics Co., Ltd., n.d. Digital Humidity and Temperature Sensor AM2302/DHT22 Product Manual. [pdf] Tersedia di: <https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf> [Diakses 3 Juli 2026].

MicroPython, 2026. MicroPython Documentation. [daring] Tersedia di: <https://docs.micropython.org/> [Diakses 3 Juli 2026].

Putri, N., 2024. Implementasi dan Perbandingan Kinerja Algoritma Fuzzy Tsukamoto dan Fuzzy Mamdani untuk Sistem Kendali Kecepatan Kipas Exhaust. Journal Tech-E, 8(1). Tangerang: Universitas Buddhi Dharma.

Raspberry Pi Ltd., 2025. Pico Microcontroller Boards — Raspberry Pi Documentation. [daring] Tersedia di: <https://www.raspberrypi.com/documentation/microcontrollers/pico-series.html> [Diakses 3 Juli 2026].

Raspberry Pi Ltd., 2026. MicroPython — Raspberry Pi Documentation. [daring] Tersedia di: <https://www.raspberrypi.com/documentation/microcontrollers/micropython.html> [Diakses 3 Juli 2026].

Rizal, M.M., Ikhsan, M. dan Hasibuan, M.S., 2024. Sistem Pemantau Suhu dan Kelembapan Kandang Puyuh Menggunakan Metode Logika Fuzzy Sugeno Berbasis Internet of Things. Jurnal Fasilkom, 14(1), pp.242-249.

Robson, W., Ernawati, I. dan Nugrahaeni, C., 2021. Design of Multisensor Automatic Fan Control System Using Sugeno Fuzzy Method. Journal of Robotics and Control (JRC), 2(4), pp.302-306. DOI: 10.18196/jrc.2496.

Shema, D.I., 2022. Implementasi Metode Logika Fuzzy Sugeno pada Prototipe Robot Pemadam Api dengan Kemampuan Navigasi. Jurnal Teknologi Elektro, 13(1), pp.55-60. DOI: 10.22441/jte.2022.v13i1.010.

VII. LAMPIRAN

A.  Link PPT: https://canva.link/tle3pem9d9skfh2

B.  Link YouTube: https://youtu.be/FEG4JEvUtI0

C.  Link GitHub: https://github.com/shazahradz/fan-speed-control