Algoritma kendali PID saat ini merupakan salah satu algoritma kendali yang paling banyak digunakan. Kontrol PID menawarkan keunggulan seperti parameter yang dapat disesuaikan, cakupan aplikasi yang luas, dan akurasi kontrol yang tinggi. Dalam rekayasa praktis, algoritma PID dapat diterapkan pada berbagai bidang, termasuk kendali elektromekanis, otomasi industri, robotika, dan kendali mikroprosesor.
Tiga parameter algoritma PID adalah: gain proporsional Kp, konstanta waktu integral Ti, dan konstanta waktu turunan Td. Sistem yang berbeda memerlukan parameter PID yang berbeda, dan parameter optimal biasanya diperoleh melalui eksperimen dan debugging. Konstanta proporsional Kp menyesuaikan penguatan proporsional, mengontrol rasio output sistem terhadap kesalahan umpan balik selama operasi; konstanta waktu integral Ti menyesuaikan penguatan integral, mengendalikan akumulasi kesalahan selama pengoperasian sistem; dan konstanta waktu turunan Td menyesuaikan penguatan turunan, mengendalikan laju perubahan kesalahan dalam sistem kendali.
Bagaimana pendekatan penerapan algoritma PID pada mikrokontroler?
Untuk mengimplementasikan algoritma kontrol PID pada mikrokontroler, pendekatan umumnya adalah sebagai berikut:
1. **Tentukan Parameter PID**:
- Pilih penguatan proporsional (Kp), waktu integral (Ti), dan waktu turunan (Td) yang sesuai berdasarkan karakteristik dan persyaratan objek yang dikontrol sebenarnya.
2. **Akuisisi Data Sensor**:
- Gunakan sensor yang sesuai (seperti sensor suhu, sensor posisi, dll.) untuk memperoleh data umpan balik-waktu nyata dari objek yang dikontrol.
3. **Perbandingan Nilai Setpoint dan Umpan Balik**:
- Bandingkan setpoint (nilai yang diinginkan) dengan nilai umpan balik untuk menghitung kesalahan (Error).
4. **Perhitungan PID**:
- Hitung variabel kontrol (output) menggunakan rumus algoritma PID: PID=Kp * Error + Ki * ∫ Error dt + Kd * d(Error)/dt.
- Kp, Ki, dan Kd adalah parameter PID; Kesalahan adalah nilai kesalahan; ∫ Kesalahan dt mewakili suku integral; dan d(Error)/dt mewakili suku turunannya.
5. **Membatasi** (Opsional):
- Untuk aplikasi tertentu, mungkin perlu membatasi rentang nilai keluaran untuk mencegahnya melebihi rentang yang dapat diterima dari objek yang dikontrol.
6. **Sinyal Kontrol Keluaran**:
- Variabel kontrol yang dihitung digunakan sebagai sinyal kontrol dan dikirim ke aktuator (seperti motor atau katup) untuk mengatur dan mengendalikan objek yang dikontrol.
7. **Setel Frekuensi Kontrol**:
- Tetapkan frekuensi kontrol yang sesuai-siklus eksekusi algoritme kontrol-berdasarkan persyaratan aplikasi spesifik.
8. **Iterasi Algoritma PID**:
- Dalam putaran-waktu nyata, jalankan langkah-langkah di atas berulang kali untuk terus memantau nilai umpan balik, menghitung variabel kontrol, dan mengeluarkan sinyal kontrol untuk mencapai kontrol sistem yang stabil.
Dalam pemrograman mikrokontroler yang sebenarnya, Anda dapat memilih alat pengembangan dan bahasa pemrograman yang sesuai (seperti bahasa C atau bahasa assembly) berdasarkan model mikrokontroler dan platform pengembangan tertentu. Perlu dicatat bahwa dalam aplikasi praktis, terdapat banyak teknik untuk mengoptimalkan dan meningkatkan algoritma PID, seperti pemisahan integral dan PID adaptif, yang dapat diteliti lebih lanjut dan diimplementasikan sesuai dengan kebutuhan spesifik.
Prinsip dan Pengoperasian Pengendali PID
Pengontrol PID terdiri dari tiga komponen: proporsional (P), integral (I), dan turunan (D). Ini menghasilkan keluaran kontrol dengan memproses kesalahan sistem, penyimpangan, dan laju perubahan. Pengoperasiannya melibatkan langkah-langkah berikut:
- Dapatkan nilai setpoint dan umpan balik
- Hitung kesalahannya
- Hitung keluaran kontrol berdasarkan penguatan proporsional, suku integral, dan suku turunan
- Perbarui parameter pengontrol
- Keluarkan sinyal kontrol
Implementasi Kode STM32
Berikut contoh kode perancangan dan implementasi pengontrol PID menggunakan mikrokontroler STM32:
```c
#sertakan "stm32f4xx.h"
// Tentukan parameter pengontrol PID
mengambang Kp=0.5; // Keuntungan proporsional
mengapung Ki=0.2; // Keuntungan integral
float Kd=0.1; // Keuntungan turunan
// Tentukan variabel penyimpanan
titik setel mengambang=50.0; // Titik yang dikehendaki
umpan balik mengambang=0.0; // Nilai umpan balik
kesalahan mengambang=0.0; // Kesalahan
float last_error=0.0; // Kesalahan sebelumnya
integral mengambang=0.0; // Suku integral
// Fungsi penghitungan keluaran pengontrol PID
float pidController(float dt)
{
// Hitung kesalahan
kesalahan=setpoint - umpan balik;
// Hitung suku integral
integral += kesalahan * dt;
// Hitung suku turunan
turunan float=(kesalahan - last_error) / dt;
// Hitung keluaran kontrol
keluaran float=Kp * error + Ki * integral + Kd * turunan;
// Perbarui kesalahan sebelumnya
kesalahan_terakhir=kesalahan;
mengembalikan keluaran;
}
int utama(batal)
{
sementara (1)
{
// Ambil nilai umpan balik
// Tetapkan interval waktu
// Hitung keluaran PID
mengambang dt=0.01; // Dalam contoh ini, interval waktunya adalah 0,01 detik
float control_output=pidController(dt);
// Keluarkan sinyal kontrol
// Penundaan untuk jangka waktu tertentu
untuk (int saya=0; saya < 10000; saya++);
}
kembali 0;
}