---
# System prepended metadata

title: Laporan Proyek Sistem Kendali PID pada Sistem Kendali Suhu Ruang dengan STM32F411

---

---
title: Laporan Proyek Sistem Kendali PID pada Sistem Kendali Suhu Ruang dengan STM32F411

---

# Sistem Kendali Suhu Ruang dengan STM32F411 (dengan PID)

**Mata Kuliah:** Sistem Kendali dan Mekanika (ACK3AB3)
**Dosen:**  FCB
**Semester/Tahun:** Ganjil 2025/2026
**Kelas:** TK-47-04

---

## Identitas Asesmen & Capaian Pembelajaran (OBE)

**Bentuk Asesmen:** Tugas Besar CLO2 dan Tugas Besar CLO3
**Metode:** *Project-Based Learning (PjBL)*
**Level 3 AI [*Editing*]**: AI hanya untuk perbaikan tulisan, tanpa konten baru. Lampirkan *prompt* dan hasil lengkap *generate* AI jika menggunakan AI, serta nama *tools* AI yang digunakan.

### Pemetaan *Program Learning Outcome* (CPL - Capaian Pembelajaran Lulusan) dan *Course Learning Outcome* (CPMK - Capaian Pembelajaran Mata Kuliah)
Laporan Tugas Besar ini mengukur ketercapaian dua PLO utama sesuai RPS untuk memvalidasi ketercapaian dua CLO:

* **[PLO-3]** Kemampuan menyusun rancangan komponen, sistem dan/atau proses pada bidang teknik komputer untuk memenuhi kebutuhan yang diharapkan di dalam batasan-batasan realistis.
    * *Fokus:* Perancangan parameter kendali (*tuning*) dan analisis kestabilan sistem.
      * **[CLO-2]:** Mampu menyusun rancangan dan menganalisis sistem kendali loop tertutup dari kondisi transien hingga steady state untuk mencapai kestabilan.
        * *(Dinilai dari Laporan Bab 1, 2, dan 4: Desain, Pemodelan, dan Analisis Grafik)*
* **[PLO-6]** Kemampuan menerapkan metode, keterampilan dan piranti teknik modern yang diperlukan untuk praktek keteknikan dalam bidang teknik komputer.
    * *Fokus:* Implementasi algoritma pada mikrokontroler dan penggunaan sensor/driver motor.
        * **[CLO-3]:** Mampu menentukan dan menerapkan penggunaan kendali proporsional, integral, atau derivatif pada motor listrik untuk mencapai kestabilan.
            * *(Dinilai dari Laporan Bab 3 dan Demonstrasi Alat: Implementasi Hardware & Tuning PID)*
---

**IDENTITAS KELOMPOK:**
* **Nama Kelompok:** Kelompok 7
* **Nama Mahasiswa 1 (NIM):** Azmi Aziz Syahputra (101032300216)
* **Nama Mahasiswa 2 (NIM):** Firdaus Arif Ramadhani (101032300131)
* **Nama Mahasiswa 3 (NIM):** Muhammad Arman Baihaqi (101032300190)
* **Nama Mahasiswa 4 (NIM):** Muhammad Haiqal (Tidak Aktif)

---

## Daftar Isi
1.  Pendahuluan
2.  Desain dan Pemodelan Sistem
3.  Implementasi dan Pengujian
4.  Evaluasi dan Analisis Kinerja
5.  Kesimpulan dan Saran
6.  Lampiran/Dokumentasi

---

## 1. Pendahuluan

### 1.1 Latar Belakang
Sistem kendali suhu otomatis krusial dalam berbagai aplikasi industri, seperti inkubator penetasan telur dan ruang pengering pertanian, yang menuntut kestabilan termal tinggi. Metode kendali konvensional (On/Off) seringkali tidak memadai karena menyebabkan fluktuasi suhu (overshoot) yang berisiko merusak objek. Oleh karena itu, diperlukan implementasi algoritma PID (Proportional-Integral-Derivative) untuk meminimalkan error dan menjaga suhu tetap stabil di titik setpoint dengan respons yang halus dan presisi.

Dalam proyek ini, mikrokontroler STM32 digunakan sebagai pengendali utama yang memproses algoritma PID. Pemanfaatan periferal Timer sangat vital, baik sebagai pemicu interrupt untuk sampling sensor secara periodik yang konsisten, maupun untuk membangkitkan sinyal PWM (Pulse Width Modulation) guna mengatur kecepatan aktuator secara linear. Selain itu, komunikasi serial UART diimplementasikan untuk kebutuhan debugging, monitoring respons sistem, dan tuning parameter PID secara real-time.

Tugas besar ini mengimplementasikan Sistem Kendali Suhu menggunakan mekanisme umpan balik. Sistem dirancang untuk membaca suhu aktual dari sensor, membandingkannya dengan setpoint, dan menyesuaikan output aktuator secara otomatis. Bertujuan untuk membuktikan efektivitas kendali PID dalam mengatasi gangguan eksternal dan mempertahankan stabilitas suhu dibandingkan metode kendali sederhana.

### 1.2 Tujuan (*sesuaikan isinya dengan proyek kelompok*)
1.  Merancang sistem Kendali Suhu Ruang dengan STM32F411 tertutup (*Closed Loop*) menggunakan metode PID.
2.  Menganalisis respon transien sistem (*Rise time, Settling time, Overshoot*).
3.  Menguji ketahanan (*robustness*) sistem terhadap gangguan eksternal.

### 1.3 Spesifikasi Desain (Target *Performance*)

|Parameter Kinerja|Simbol|Target Nilai|Alasan/Justifikasi (kuantitatif)|
| - | -: | -: | - |
| Settling Time|$T_s$ | **< 60 detik** (kriteria 2%) | Settling time umumnya diartikan sebagai waktu sampai output masuk dan tetap berada dalam ±2% dari nilai akhirnya [1](https://ocw.mit.edu/courses/2-004-dynamics-and-control-ii-spring-2008/8e6878353de8beaeacbab817cb8c314b_lecture_21.pdf). Sensor DS18B20 butuh waktu konversi sampai 750 ms (maks) pada resolusi 12-bit [2](https://www.analog.com/media/en/technical-documentation/data-sheets/ds18b20.pdf). Karena satu pembacaan suhu butuh hampir 1 detik, jadi target $T_s < 60$ detik berarti sistem punya ~60 kali kesempatan pembacaan/koreksi untuk masuk ke band stabil.|
| Max. Overshoot|$M_p$ |**< 5%** | Percent overshoot adalah besarnya puncak respon yang melewati nilai akhir dalam persen. Pada pengujian step di laporan ini, kondisi awal umumnya dipanaskan ke sekitar 40°C lalu menuju setpoint 30°C sehingga $\Delta T \approx 10^\circ C$; maka target $M_p < 5%$ berarti batas overshoot $\approx 0.5^\circ C$. Nilai 0.5°C masih masuk akal karena resolusi sensor DS18B20 12-bit adalah 0.0625°C sehingga 0.5°C ≈ 8 step sensor [2](https://www.analog.com/media/en/technical-documentation/data-sheets/ds18b20.pdf).|
| Steady State Error  | $e_{ss}$ |**≤ 1%** |Untuk setpoint 30°C: 1% = 0.3°C. Yang dimana ini masih jauh di atas resolusi sensor (0.0625°C), jadi spesifikasinya realistis dan menunjukkan presisi yang baik. |
| Kriteria Kestabilan |          |**2%** | Band 2% pada 30°C = **±0.6°C** (lebih ketat dari 5% = ±1.5°C), juga masih realistis terhadap noise & kuantisasi DS18B20.|


---

## 2. Desain dan Pemodelan Sistem

### 2.1 Diagram Blok Sistem
![new closed loop.drawio (1)](https://hackmd.io/_uploads/rkx1n5CNWg.png)


Diagram blok sistem ini menggambarkan sistem kendali suhu ruang berbasis umpan balik (feedback/closed loop) dirancang untuk menjaga kestabilan suhu secara otomatis dengan membandingkan nilai target atau setpoint dengan kondisi aktual dari feedback.

1.Input: pengguna memasukan setpoint yang ingin dicapai thermal chamber.

2.Comparator: Sinyal setpoint masuk ke comparator dan terjadi perbandingan antara setpoint dengan sinyal feedback. Hasil selisih keduanya menghasilkan error signal. Jika suhu aktual **lebih tinggi** dari setpoint maka error bernilai positif (butuh pendinginan) dan sebaliknya.

3.Controller: Error signal kemudian diproses oleh controller yang berupa STM32 mikrokontroler. Di sini PID bekerja menghitung respons yang tepat berdasarkan nilai error (P), akumulasi error (I), dan laju perubahan error (D). Controller lalu mengeluarkan actuating signal untuk mengontrol daya ke aktuator.

4.Thermal Chamber: Actuating signal menggerakan aktuator di dalam thermal chamber yaitu kipas. Ini akan mengubah kondisi fisik di dalam ruangan tersebut yang menghasilkan output berupa perubahan suhu ruangan.

5.Sensor DS18B20: Suhu aktual output dibaca oleh sensor suhu digital yaitu DS18B20 yang akan mengubah besaran fisik suhu menjadi data digital yang dikirimkan kembali sebagai feedback signal menuju Comparator.


### 2.2 Pemodelan Matematis (Theoretical Modeling)

**A. Model Algoritma Kontroler (PID)**
Secara umum, persamaan matematis kontroler PID dapat dituliskan:
$$u(t) = K_p e(t) + K_i \int e(t) dt + K_d \frac{de(t)}{dt}$$

dengan:
* $u(t)$ = sinyal kendali (output kontroler, duty PWM kipas)
* $e(t)$ = error (selisih output terukur terhadap setpoint)
* $K_p$ = gain proporsional
* $K_i$ = gain integral
* $K_d$ = gain derivatif

Pada implementasi mikrokontroler, algoritma kendali dijalankan secara diskrit dengan periode sampling $T_{samp}$. Pada proyek ini, *sampling* suhu dilakukan periodik oleh *timer interrupt* (TIM2) pada $1\,\mathrm{Hz}$ sehingga $T_{samp}\approx 1\,\mathrm{s}$.

**Bentuk diskrit yang digunakan pada kode (PID *cooling-only* dengan saturasi):**
Pada program, *error* didefinisikan sebagai:
$$e[k]=y_m[k]-r[k]$$
dengan:
* $k$ = indeks sampel ke-$k$
* $y_m[k]$ = output terukur pada sampel ke-$k$ (temperatur dari DS18B20, °C)
* $r[k]$ = referensi/setpoint pada sampel ke-$k$ (°C)
* $e[k]$ = error pada sampel ke-$k$ (°C)
* $T_{samp}$ = periode sampling (≈ 1 s)

Positif ketika suhu aktual lebih tinggi dari setpoint. Keluaran kendali adalah duty PWM kipas $u[k]$ yang dibatasi 0–100%:

$$P[k]=K_p\,e[k]$$
$$D[k]=K_d\,\frac{e[k]-e[k-1]}{T_{samp}}$$
dengan:
* $P[k]$ = komponen proporsional pada sampel ke-$k$
* $D[k]$ = komponen derivatif pada sampel ke-$k$
* $e[k-1]$ = error sampel sebelumnya

Bagian integral diimplementasikan sebagai integral term dalam satuan output (yang sudah dikalikan $K_i$), dengan pembatas atau *clamping* dan *anti-windup* sederhana:
$$I_u[k]=\mathrm{sat}\left(I_u[k-1]+K_i\,e[k]\,T_{samp},\,0,\,100\right)$$
dengan:
* $I_u[k]$ = komponen integral dalam satuan output (duty, %)
* $\mathrm{sat}(x,0,100)$ = fungsi saturasi yang membatasi $x$ pada rentang 0–100%

dengan aturan sbb:
* Jika $e[k]\le 0$ maka $I_u[k]=0$ (kipas tidak akan aktif saat suhu di bawah setpoint).
* Integrasi hanya dilakukan saat keluaran belum tersaturasi (agar tidak terjadi *windup*).

Sehingga sinyal kendali diskrit:
$$u[k]=\mathrm{sat}\left(P[k]+I_u[k]+D[k],\,0,\,100\right)$$
dengan:
* $u[k]$ = sinyal kendali/duty PWM kipas pada sampel ke-$k$ (%)

Saat setpoint berubah, keadaan integral di-*reset* ($I_u=0$) dan $e[k-1]$ disamakan dengan $e[k]$ untuk mencegah lonjakan derivatif.

---

#### B. Metode Tuning Ziegler–Nichols (Z-N)

Metode Z-N Tipe Osilasi Kontinu sebagai dasar penentuan parameter.

Langkahnya:

1. Nonaktifkan integral & derivatif alias gunakan P saja.
2. Naikkan $K_p$ hingga sistem berosilasi stabil untuk dapatkan **ultimate gain** ($K_u$).
3. Ukur periode osilasi stabil untuk mendapatkan nilai **ultimate period** ($P_u$).

Aturan Z-N (tipe klasik) untuk PID:
$$
K_p = 0.6K_u,\quad T_i = 0.5P_u,\quad T_d = 0.125P_u
$$
dengan:
* $K_u$ = *ultimate gain* (nilai $K_p$ saat sistem tepat berosilasi stabil)
* $P_u$ = *ultimate period* (periode osilasi stabil)
* $T_i$ = waktu integral (*integral time*)
* $T_d$ = waktu derivatif (*derivative time*)

Dengan konversi:
$$
K_i = \frac{K_p}{T_i},\quad K_d = K_p T_d
$$
Aturan berasal dari publikasi Ziegler–Nichols [3](https://garikoitz.info/blog/descargas/Z-N.pdf).

---

**C. Model Plant**

**Opsi 1: Motor DC (Speed Control)**
Secara praktis, respon kecepatan fan terhadap perubahan PWM bisa didekati sebagai sistem orde-1:

$$
G(s)=\frac{\omega(s)}{D(s)}=\frac{K_m}{\tau_m s + 1}
$$

**Keterangan (versi S1, simpel):**

* $\omega$ = kecepatan putar fan (rpm atau rad/s)
* $D$ = duty cycle PWM (0–100%)
* $K_m$ = “gain” motor (seberapa besar rpm berubah tiap perubahan duty)
* $\tau_m$ = konstanta waktu motor (seberapa cepat motor mencapai keadaan stabil)

### 2.3 Spesifikasi Perangkat Keras
1. Aktuator: Fan DC 12V 0.3A, 8 cm
2. Driver Motor: Darlington TIP122
3. Sensor: Sensor Suhu Digital DS18B20
4. Mikrokontroler: STM32F411CEU, 100 MHz max clock

---

## 3. Implementasi dan Pengujian

> **⚠️ Syarat data yang harus ada:**
> 1.  **Analisis Komparatif:** **Minimal** **3 Variasi *Tuning*** (Misal: Hanya Proporsional vs PI vs PID Optimal).
> 2.  **Uji Konsistensi (*Repeatability*):** Pada *tuning* terbaik, lakukan **minimal 5x percobaan** berulang untuk mendapatkan rata-rata dan standar deviasi.
> 3.  **Uji Gangguan (*Disturbance*):** Minimal satu grafik yang menunjukkan respons sistem saat diberi beban atau gangguan tiba-tiba.
> 
> *Catatan: Untuk poin 1 dan 2, lebih banyak lebih baik, karena akan semakin menghasilkan banyak data untuk dianalisis dan dibandingkan.*

### 3.1 Karakteristik Open-Loop (Linearitas Plant)

Pada pengujian open-loop, algoritma PID **dinonaktifkan**, kemudian fan diberi perintah PWM tetap (duty cycle tertentu) untuk melihat perilaku asli plant. Karena tujuan sistem ini adalah mengendalikan suhu (bukan mengendalikan RPM fan), maka output yang diamati pada uji open-loop adalah perubahan suhu yang diukur oleh sensor DS18B20. Dengan demikian, karakteristik plant yang diuji adalah hubungan Input: duty cycle PWM (%) terhadap Output: laju penurunan suhu (°C/menit) atau perubahan suhu (°C) dalam waktu tertentu.

**Prosedur pengujian:**
1. Menyiapkan kondisi awal yang sama untuk tiap percobaan (misal suhu awal sekitar **40°C** atau suhu ruangan stabil).
2. Matikan PID, dimana PWM akan dibuat konstan.
3. Uji beberapa nilai PWM bertahap: **0%, 20%, 40%, 60%, 80%, 100%**.
4. Untuk setiap PWM, catat suhu dari DS18B20 selama durasi tetap selama **1 menit**.
5. Hitung output sebagai **ΔT** = $T_{awal} - T_{akhir}$ selama 1 menit

**Grafik karakteristik (Input vs Output):**
![image](https://hackmd.io/_uploads/HJ5xV9RV-e.png)

| Duty (%) | $T_{awal}$ (°C) | $T_{akhir}$ (°C) | Durasi (s) | $\Delta T$ (°C) | Laju (°C/menit) |
| ---: | ---: | ---: | ---: | ---: | ---: |
| 0 | 39.60 | 34.20 | 59 | 5.40 | 5.49 |
| 20 | 39.70 | 33.10 | 59 | 6.60 | 6.71 |
| 40 | 39.60 | 30.50 | 59 | 9.10 | 9.25 |
| 60 | 39.60 | 29.80 | 59 | 9.80 | 9.97 |
| 80 | 39.80 | 31.10 | 59 | 8.70 | 8.85 |
| 100 | 39.50 | 30.50 | 59 | 9.00 | 9.15 |
* Sumbu X (Input): **Duty cycle PWM (%)**
* Sumbu Y (Output): **Laju pendinginan (°C/menit)** atau **ΔT dalam 1 menit (°C)**

**Analisis:**

1. Apakah grafik cenderung membentuk garis lurus (semakin linear semakin mudah dikendalikan)?
Tidak sepenuhnya linear. Laju pendinginan naik cukup konsisten dari 0% → 60% (5.49 ke 9.97 °C/menit), tapi setelah itu tidak bertambah signifikan dan bahkan turun di 80%. Jadi grafiknya lebih cocok disebut naik lalu mendatar (saturasi).
2. Pada PWM berapa fan mulai efektif memberi pendinginan (misal di bawah 15–20% perubahan suhu sangat kecil)?
Dari data, fan mulai terlihat efektif sejak 20%: laju naik dari 5.49 (0%) ke 6.71 (20%). Peningkatan jadi lebih jelas saat masuk 40% (9.25 °C/menit). Jadi ambang efektif praktisnya sekitar 20–40%.
3. Apakah ada titik saturasi, yaitu PWM dinaikkan tetapi efek pendinginan tidak bertambah signifikan (misalnya di atas 80%)?
Ada indikasi saturasi mulai sekitar 60% ke atas. Di 60% sudah ~9.97 °C/menit, sementara 80% 8.85 dan 100% 9.15 (beda kecil/tidak konsisten). Artinya menaikkan PWM di atas ~60% tidak memberi tambahan pendinginan yang berarti.

### 3.2 Analisis Perbandingan Respons (*Step Response*)

Pengujian step response dilakukan untuk membandingkan performa sistem pada minimal **3 variasi tuning**. Pada proyek ini, step response dilakukan dengan memberi kondisi awal suhu di atas setpoint (misal dipanaskan dulu sampai ±40°C) lalu sistem dibiarkan menuju setpoint **30°C**.

**Empat skenario tuning yang dibandingkan:**

* **Skenario #1 (Hanya P – konservatif):** $K_p$ kecil, $K_i=0$, $K_d=0$ → respon stabil tetapi cenderung lambat.
* **Skenario #2 (Hanya P – agresif):** $K_p$ lebih besar, $K_i=0$, $K_d=0$ → respon lebih cepat tetapi berpotensi muncul osilasi/undershoot.
* **Skenario #3 (PI terbaik):** $K_p$ sedang + $K_i$ kecil → target lebih cepat stabil dan error akhir lebih kecil.
* **Skenario #4 (PID lengkap):** $K_p$ + $K_i$ + $K_d$ → ditujukan untuk mempercepat respon sekaligus meredam undershoot (derivative sebagai “damping”).

**Parameter yang diambil dari grafik suhu vs waktu:**

* **Delay Time (Td):** waktu sampai suhu mulai turun terlihat setelah kontrol aktif.
* **Rise Time (Tr):** waktu perubahan suhu dari sekitar 10% sampai 90% menuju setpoint.
* **Peak Time (Tp):** waktu saat deviasi maksimum terjadi (misal suhu paling rendah jika terjadi undershoot).
* **Settling Time (Ts):** waktu sampai suhu masuk dan tetap dalam rentang toleransi (misal ±2% dari setpoint).
* **Overshoot (%):** pada sistem pendingin, overshoot dapat muncul sebagai **undershoot** (turun melewati setpoint). Besarnya dihitung dibanding besar step.
* **Steady State Error:** selisih suhu rata-rata akhir terhadap setpoint.

> Praktisnya: karena sistem “cooling-only”, overshoot yang relevan biasanya **turun melewati setpoint** (undershoot), bukan naik melebihi setpoint.

**Tabel 1. Perbandingan Parameter Respons Transien**

| Skenario | (Kp, Ki, Kd) | Td (s) | Tr (s) | Tp (s) | Ts (s) | Undershoot (%) | Steady State Error (°C) |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| P_CONS | (5.0f, 0.0f, 0.0f) | 2 | 112 | 255 | 190 | 4.0 | -0.34 |
| P_AGGR | (20.0f, 0.0f, 0.0f) | 3 | 54 | 210 | 94 | 7.1 | -0.61 |
| PI_BEST | (12.0f, 0.2f, 0.0f) | 2 | 50 | 273 | 70 | 10.2 | -0.99 |
| PID_FULL | (12.0f, 0.1f, 50.0f) | 2 | 53 | 230 | 79 | 9.6 | -0.77 |

![image](https://hackmd.io/_uploads/rkXJEcCNWx.png)


> Catatan perhitungan metrik: $T_s$ dihitung dengan kriteria band ±2% dari besar step (mis. 40°C → 30°C berarti step 10°C, band ±0.2°C) dan harus bertahan **5 sampel berturut-turut** (window 5 detik karena sampling 1 Hz). Steady-state error dihitung sebagai rata-rata error pada **20 detik terakhir**.



---

### 3.3 Uji Konsistensi (Repeatability Test)
*(Ambil skenario tuning terbaik (pada data ini: **PID_FULL**), jalankan 5 kali dari kondisi awal yang sama menuju setpoint).*

**Tabel 2. Statistik Konsistensi Kinerja (Misal N=5)**

| Percobaan Ke- | *Settling Time* ($T_s$) | *Undershoot* (%) |
| :---: | :---: | :---: |
| 1 | 79 s | 9.6% (undershoot) |
| 2 | 73 s | 6.9% (undershoot) |
| 3 | 80 s | 7.0% (undershoot) |
| 4 | 92 s | 4.2% (undershoot) |
| 5 | 87 s | 5.2% (undershoot) |
| **Rata-rata ($\mu$)** | **82.2 s** | **6.58%** |
| **Standar Deviasi ($\sigma$)** | **6.6 s** | **1.84%** |


*(Catatan: standar deviasi di atas menggunakan definisi **populasi** (pembagi N). Nilai standar deviasi yang kecil menunjukkan sistem kelompok Anda lebih konsisten/reliabel.)*

### 3.4 Uji Gangguan (Disturbance Rejection)
*(Tampilkan grafik respons saat motor sedang stabil di setpoint, lalu beri gangguan fisik sesaat).*
* **Gambar:** *Screenshot* Serial Plotter saat gangguan terjadi.
Dikarenakan PlatformIO tidak menyediakan fitur serial plotter bawaan seperti Arduino IDE, maka digunakan ekstensi tambahan pada VSCode serial-plotter untuk menampilkan grafik respons.

Suhu aktual &setpoint plot:
![Screenshot from 2026-01-09 21-09-26](https://hackmd.io/_uploads/SkG7VcREZx.png)
Fan speed plot:
![Screenshot from 2026-01-09 21-09-32](https://hackmd.io/_uploads/Bkg4N9CEZx.png)

* **Analisis:** Berapa detik waktu yang dibutuhkan sistem untuk kembali stabil (*Recovery Time*)?

Gangguan mulai dari t = 1102 s (temp 31.4°C, dan fan mulai naik). Kalau waktu sampai suhu kembali atau stabil di sekitar setpoint dengan kriteria dari Bab 3.2: dalam band 30.0 ± 0.2°C selama 5 detik berturut-turut, maka:
pertama kali memenuhi 5 detik berturut-turut mulai t = 1188 s (30.2, 30.2, 30.1, 30.1, 30.1)
jadi Recovery Time ≈ 1188 − 1102 = 86 detik

---

## 4. Evaluasi dan Analisis Kinerja

### 4.1 Validasi Spesifikasi
Setelah didapat hasil rata-rata dari bab 3.3 dan dibandingkan dengan target pada bab 1.3. Ditemukan bahwa skenario terbaik kami (paling optimal) membutuhkan waktu rata-rata 82.2 detik untuk mencapai kondisi stabil dibandingkan dengan target yang sudah ditentukan yaitu 60 detik dan dengan undershoot 6.58% sedangkan target kami yaitu 5%.

meskipun target tidak tercapai, standar deviasi yang dihasilkan cukup kecil yaitu 6.6 detik untuk Ts dan 1.84% untuk undershoot yang menunjukkan bahwa sistem meskipun lambat, ia bekerja dengan sangat konsisten dan reliabel.

### 4.2 Analisis Mendalam
*(Jawab dengan paragraf analisis kritis)*

1.  **Analisis Pengaruh *Gain*:** 
Berdasarkan tabel 1 pada bagian 3.2. Meningkatkan $K_p$ dari 5 menjadi 20 berhasil mempercepat Rise Time secara signifikan dari 112 detik menjadi 54 detik. Namun, hal ini menyebabkan undershoot meningkat dari 4% menjadi 4.1%, yang menunjukkan bahwa semakin agresif nilai P, semakin cepat sistem bereaksi namun semakin besar resiko melampaui target.

Penambahan $K_i$ pada skenario PI_BEST (12.0f, 0.2f) mempercepat Rise Time menjadi yang tercepat (50 detik). Namun, penggunaan Integral menyebabkan undershoot terbesar yaitu 10.2%, karena akumulasi error cenderung membuat aktuator bekerja maksimal lebih lama.

Pada skenario PID_FULL, penambahan $K_d$ sebesar 50.0 berfungsi sebagai peredam (damping). Dibandingkan dengan skenario PI, undershoot berhasil ditekan dari 10.2% menjadi 9.6%, meskipun Rise Time sedikit melambat menjadi 53 detik. Ini membuktikan peran $K_d$ dalam menstabilkan sistem saat mendekati setpoint.

2.  **Analisis Stabilitas:** 
    a. Berdasarkan grafik pada Bab 3.4, sistem menunjukkan kemampuan Self-Recovery yang baik. Saat terjadi gangguan fisik pada suhu aktual, kipas (fan speed) secara otomatis menyesuaikan kecepatannya untuk mengembalikan suhu ke setpoint tanpa osilasi berlebih (liat grafik fan speed plot).
    b.  Meskipun target spesifikasi waktu (60 detik) belum tercapai, metode tuning ini sudah optimal dalam hal kestabilan. Hal ini dibuktikan dengan nilai Standar Deviasi yang kecil ($\sigma = 6.6$ s untuk $T_s$ dan $1.84\%$ untuk undershoot), yang menandakan sistem sangat konsisten dalam mempertahankan kondisi stabil meskipun responnya lambat.
3.  **Trade-off Desain:** 
Kami mengorbankan kecepatan respons (Settling Time) demi mencapai konsistensi dan meminimalisir kesalahan akhir. Sistem membutuhkan rata-rata 82.2 detik untuk stabil, yang melampaui target 60 detik. Strategi ini diambil agar sistem tidak terlalu agresif yang dapat menyebabkan osilasi liar atau kerusakan pada aktuator kipas jika terus-menerus berubah kecepatan secara ekstrem.
4.  **Evaluasi Hardware:** 
    a. Apakah ada batasan fisik (seperti driver motor atau resolusi sensor rendah) yang menghambat pencapaian target sesuai desain?
Sensor DS18B20: Memiliki batasan waktu konversi maksimal 750 ms untuk resolusi 12-bit. Hal ini membatasi sampling rate sistem (hanya 1 Hz), sehingga mikrokontroler tidak bisa melakukan koreksi super cepat yang dibutuhkan untuk mencapai settling time di bawah 60 detik secara akurat.Berdasarkan uji Open-Loop (Bab 3.1), kipas mengalami saturasi di atas 60% PWM. Menambah daya di atas 60% tidak memberikan laju pendinginan yang signifikan ($9.97^\circ\text{C/menit}$ di 60% vs $9.15^\circ\text{C/menit}$ di 100%), sehingga kemampuan pendinginan fisik memang terbatas.
    b. Apakah ada faktor mekanik (*gears, backlash*, gesekan) yang mengganggu hasil kendali?
Efek pendinginan dipengaruhi oleh aliran udara di dalam thermal chamber (ruangan). Tidak adanya aktuator pemanas (sistem ini cooling-only) menyebabkan sistem sangat bergantung pada suhu lingkungan jika suhu aktual turun di bawah setpoint (tidak bisa menaikkan suhu secara aktif), yang mempersulit pengendalian presisi saat suhu sangat dekat dengan setpoint.

---

## 5. Kesimpulan dan Saran

### 5.1 Kesimpulan
1.  Sistem kendali PID **tidak berhasil** diimplementasikan dengan parameter final: $K_p=12f, K_i=0.1f, K_d=50f$.
2.  Kinerja sistem mencapai $T_s = 82.2$ detik dan Undershoot $6.58\%$.
3.  Tingkat konsistensi sistem ditunjukkan dengan standar deviasi sebesar 6.6 detik untuk settling time dan 1.84% untuk undershoot

### 5.2 Saran Pengembangan
Dari keterbatasan yang dimiliki oleh alat kami. Sistem dapat dikembangkan dengan pemilihan hardware yang lebih baik seperti kipas dengan spesifikasi rpm tinggi dan ruang uji coba berupa vacuum chamber dengan aktuator pemanas dan heatsink tidak hanya aktuator pendingin.

---

## Lampiran
* **Kode Program Utama (Arduino/C++):** 
  Deklarasi variabel + struktur PID (`src/main.c:75`, `src/main.c:84`, `src/main.c:95`)
  ```c
  /* Control Variables */
  static volatile float setpoint = SETPOINT_DEFAULT;

  /* System State */
  /* fan_speed_percent is extern in fan.h */
  static volatile uint32_t last_button_time = 0;
  static volatile uint8_t flag_read_temp = 0;
  static volatile uint8_t flag_setpoint_changed = 0;

  #if !OPEN_LOOP_TEST
  typedef struct {
    float kp;
    float ki;
    float kd;

    float integral_term; /* already multiplied by Ki (output unit: %) */
    float prev_error;
    float d_filtered;
  } PID_Controller_t;

  static PID_Controller_t pid = {
      .kp = PID_KP,
      .ki = PID_KI,
      .kd = PID_KD,
      .integral_term = 0.0f,
      .prev_error = 0.0f,
      .d_filtered = 0.0f,
  };
  #endif
  ```

  Fungsi PID (*cooling-only*) (`src/main.c:248`)
  ```c
  static float PID_ComputeCoolingOnly(PID_Controller_t *controller, float temp,
                                      float setpoint, uint8_t reset_state) {
    float error = temp - setpoint; /* >0 means too hot => need cooling */
    float dt = CONTROL_DT_SEC;

    if (reset_state) {
      controller->integral_term = 0.0f;
      controller->prev_error = error; /* avoid derivative kick on reset */
      controller->d_filtered = 0.0f;
    }

    float p = controller->kp * error;

    float d_raw = (error - controller->prev_error) / dt;
  #ifdef PID_D_FILTER_ALPHA
    controller->d_filtered =
        (PID_D_FILTER_ALPHA * controller->d_filtered) + ((1.0f - PID_D_FILTER_ALPHA) * d_raw);
  #else
    controller->d_filtered = d_raw;
  #endif
    float d = controller->kd * controller->d_filtered;

    if (error <= 0.0f) {
      controller->integral_term = 0.0f;
    } else {
      float output_unsat = p + controller->integral_term + d;
      uint8_t allow_integrate =
          (output_unsat > 0.0f) && (output_unsat < OUTPUT_MAX);
      if (allow_integrate) {
        controller->integral_term += (controller->ki * error * dt);
        controller->integral_term =
            ClampFloat(controller->integral_term, 0.0f, OUTPUT_MAX);
      }
    }

    float output = p + controller->integral_term + d;
    controller->prev_error = error;

    output = ClampFloat(output, 0.0f, OUTPUT_MAX);
    return output;
  }
  ```

  Loop kendali (*closed-loop*) (`src/main.c:360`, blok PID `src/main.c:447`)
  ```c
  /* ==================== MAIN LOOP ==================== */
  while (1) {
    /* Cek flag dari Timer Interrupt (setiap 1 detik) */
    if (flag_read_temp) {
      flag_read_temp = 0;

      /* ========== 1. Baca suhu dari DS18B20 ========== */
      current_temperature = DS18B20_ReadTemperature();

      /* ========== 2. Hitung Output (PID Control) ========== */
      float current_setpoint = setpoint;
      uint8_t reset_pid_state = 0;
      if (flag_setpoint_changed) {
        flag_setpoint_changed = 0;
        reset_pid_state = 1;
      }
      float output = PID_ComputeCoolingOnly(&pid, current_temperature,
                                           current_setpoint, reset_pid_state);

      /* ========== 3. Set Fan Speed ========== */
      Set_Fan_Speed_RegisterLevel((uint8_t)output);

      /* ========== 4. UART telemetry log ========== */
      UART_LogTelemetry(seconds_counter, current_temperature, current_setpoint,
                        fan_speed_percent);

      seconds_counter++;
    }

    /* Update LED */
    Update_LEDs_Temperature(current_temperature, setpoint);

    delay_ms(10);
  }
  ```

Link: https://github.com/Son0fGuilliman/Tubes_SKM_MIKRO/tree/skm
* **Tautan Video Demonstrasi:**
https://drive.google.com/drive/folders/145a33wtkxgBRvOzdAWnXaCowLhlxEE1_?usp=sharing
* **Dokumentasi Foto Alat:** 
https://drive.google.com/drive/folders/145a33wtkxgBRvOzdAWnXaCowLhlxEE1_?usp=sharing



---

## Panduan Checklist Kelengkapan (Alat bantu saja untuk memastikan tidak ada yang terlewat. Sesuaikan dengan yang sebenarnya.)
- [x] Target Spesifikasi (Bab 1.3) terisi jelas.
- [x] Pemodelan Matematis ada (Bab 2.2).
- [x] Grafik Open Loop (Linearitas) ada (Bab 3.1).
- [x] Tabel Perbandingan minimal 3 variasi tuning ada (Bab 3.2).
- [x] Tabel Statistik Repeatability (5x data) ada (Bab 3.3).
- [x] Grafik Uji Gangguan ada (Bab 3.4).

## 6. Rubrik Penilaian dan Pembobotan
* **[PLO-3]** Kemampuan menyusun rancangan komponen, sistem dan/atau proses pada bidang teknik komputer untuk memenuhi kebutuhan yang diharapkan di dalam batasan-batasan realistis.
*  **[CLO-2]:** Mampu menyusun rancangan dan menganalisis sistem kendali loop tertutup dari kondisi transien hingga steady state untuk mencapai kestabilan.

### A. RUBRIK TUGAS BESAR CLO 2 (*Design & Analysis*)
**Bobot:** 5% dari Nilai Akhir Mata Kuliah.

**Aspek 1: Desain Spesifikasi dan Pemodelan (40 Poin)**
| Level | Poin | Deskripsi Kriteria |
| :--- | :---: | :--- |
| **_Exemplary_** | **40** | Target spesifikasi ($T_s, M_p$) memiliki **alasan kuantitatif**. Diagram blok lengkap (*Closed-loop*) dan model matematis *Plant*, Z-N, atau PID dijelaskan dengan referensi yang benar. |
| **_Satisfactory_** | **30** | Diagram blok benar dan target spesifikasi ada. Alasan penetapan angka kurang kuat atau model matematis hanya bersifat umum. |
| **_Needs Improvement_** | **15** | Diagram blok tidak lengkap atau salah. Tidak ada target spesifikasi jelas, atau model matematis salah konsep. |
| **_Unsatisfactory_** | **0** | Tidak ada bab desain atau terindikasi plagiasi. |

**Aspek 2: Analisis Kritis Respon Transien (60 Poin)**
| Level | Poin | Deskripsi Kriteria |
| :--- | :---: | :--- |
| **_Exemplary_** | **60** | Analisis tajam menjelaskan **korelasi fisik** *gain* PID terhadap grafik ($T_d, T_r, T_p, M_p, T_s$). Menjelaskan *trade-off* desain dengan logis. |
| **_Satisfactory_** | **45** | Penjelasan benar secara teori namun bersifat **deskriptif** (hanya membaca grafik) tanpa analisis yang mendalam. |
| **_Needs Improvement_** | **25** | Analisis dangkal atau keliru. Kesimpulan bertentangan dengan data grafik. Hanya menyalin teori buku. |
| **_Unsatisfactory_** | **0** | Tidak ada analisis. |

---
---
* **[PLO-6]** Kemampuan menerapkan metode, keterampilan dan piranti teknik modern yang diperlukan untuk praktek keteknikan dalam bidang teknik komputer.
* **[CLO-3]:** Mampu menentukan dan menerapkan penggunaan kendali proporsional, integral, atau derivatif pada motor listrik untuk mencapai kestabilan.
---

### B. RUBRIK TUGAS BESAR CLO 3 (*Implementation & Tools*)
**Bobot:** 20% dari Nilai Akhir Mata Kuliah.

**Aspek 1: Metodologi *Tuning* dan Validitas Data (40 Poin)**
| Level | Poin | Deskripsi Kriteria |
| :--- | :---: | :--- |
| **_Exemplary_** | **40** | Ada grafik *Open-Loop*. Melakukan minimal **3 variasi *tuning***. Menyertakan bukti **Uji Repetisi (minimal 5x)** dengan standar deviasi kecil (data valid). |
| **_Satisfactory_** | **30** | Ada tuning PID dan alat jalan. Data perbandingan minim (<3) atau tidak ada uji repetisi (hanya sekali coba). |
| **_Needs Improvement_** | **15** | Metode tuning tidak jelas (*trial-error* acak). Grafik respon tidak jelas skalanya atau terlihat fiktif. |
| **_Unsatisfactory_** | **0** | Data fiktif atau tidak ada data. |

**Aspek 2: Kestabilan dan *Robustness* (30 Poin)**
| Level | Poin | Deskripsi Kriteria |
| :--- | :---: | :--- |
| **_Exemplary_** | **30** | Sistem stabil ($e_{ss} \approx 0$). Mampu ***Self-Recovery* (kembali stabil)** dengan cepat saat diberi gangguan fisik. Ada grafik bukti respon gangguan. |
| **_Satisfactory_** | **20** | Sistem stabil mencapai *setpoint*. Respon gangguan lambat atau berosilasi lama. Dokumentasi gangguan kurang jelas. |
| **_Needs Improvement_** | **10** | Sistem mencapai *setpoint*, tetapi tidak stabil (getar atau *drift*), gagal, atau berhenti saat diberi gangguan kecil. |
| **_Unsatisfactory_** | **0** | Alat tidak berfungsi. |

**Aspek 3: Demonstrasi Alat & Tanya Jawab (30 Poin) --> *Penilaian Individu***
| Level | Poin | Deskripsi Kriteria |
| :--- | :---: | :--- |
| **_Exemplary_** | **30** | Demo sempurna dan rapi. Mahasiswa menjawab pertanyaan teknis (seperti pemrograman dan rangkaian) dengan lancar dan paham secara mendetail. |
| **_Satisfactory_** | **20** | Demo ada kendala minor. Menjawab pertanyaan cukup baik meski ragu pada detail teknis. |
| **_Needs Improvement_** | **10** | Alat sering *error* saat demo. Mahasiswa bingung dengan alatnya sendiri (tidak menguasai). |
| **_Unsatisfactory_** | **0** | Tidak hadir demonstrasi dan presentasi. |

---

### REF

[1](https://ocw.mit.edu/courses/2-004-dynamics-and-control-ii-spring-2008/8e6878353de8beaeacbab817cb8c314b_lecture_21.pdf)
[2](https://www.analog.com/media/en/technical-documentation/data-sheets/ds18b20.pdf)
[3](https://garikoitz.info/blog/descargas/Z-N.pdf)
[4](https://www.ni.com/en/shop/labview/pid-theory-explained.html?srsltid=AfmBOooyBYQajxI6O3CM6LBG2_9mwMAvueCVktNPIAGB-_oCVwL2GyHB&)
