Algoritma kontrol PID adalah algoritma kontrol yang banyak digunakan, kontrol PID memiliki keunggulan parameter yang dapat disesuaikan, beragam aplikasi, akurasi kontrol yang tinggi. Dalam rekayasa praktis, algoritma PID dapat diterapkan pada kendali elektromekanis, otomasi industri, kendali robot, kendali mikroprosesor dan banyak bidang lainnya.
Tiga parameter algoritma PID disesuaikan: konstanta proporsionalitas Kp, konstanta waktu integral Ti, konstanta waktu diferensial Td. Sistem yang berbeda perlu menetapkan parameter PID yang berbeda, dan umumnya diperlukan untuk mendapatkan parameter optimal melalui eksperimen dan debugging. Konstanta proporsionalitas Kp menyesuaikan proporsi, menyesuaikan rasio kesalahan keluaran dan umpan balik dalam sistem kendali; konstanta waktu integral Ti menyesuaikan integral, menyesuaikan akumulasi kesalahan dalam sistem kendali; konstanta waktu diferensial Td menyesuaikan diferensial, menyesuaikan laju perubahan kesalahan dalam sistem kendali.
Apa ide mewujudkan algoritma pid dengan mikrokontroler
Untuk merealisasikan algoritma kendali PID pada mikrokontroler, berikut gambaran umum realisasinya:
1. **Tentukan parameter PID**:
- Sesuai dengan karakteristik dan kebutuhan objek kontrol sebenarnya, pilih koefisien proporsionalitas (Kp), waktu integrasi (Ti) dan waktu diferensiasi (Td) yang sesuai.
2. **Akuisisi data sensor**:
- Gunakan sensor yang sesuai (misalnya sensor suhu, sensor posisi, dll.) untuk mengumpulkan data umpan balik dari objek kontrol secara real-time.
3. **Tetapkan perbandingan nilai dan nilai umpan balik**:
- Bandingkan nilai yang ditetapkan (nilai yang diinginkan) dengan nilai umpan balik dan hitung nilai kesalahannya (Error).
4. **perhitungan PID**:
- Besaran kontrol (output) dihitung berdasarkan rumus algoritma PID: PID=Kp * Error + Ki * ∫ Error dt + Kd * d(Error)/dt.
- Kp, Ki dan Kd adalah parameter PID, Error adalah nilai error, ∫ Error dt menunjukkan suku integral dan d(Error)/dt menunjukkan suku diferensial.
5. **Batas Penanganan** (opsional):
- Untuk beberapa aplikasi, mungkin perlu membatasi rentang nilai keluaran untuk menghindari melebihi rentang objek kontrol yang dapat diterima.
6. **Sinyal kontrol keluaran**:
- Kuantitas kontrol yang dihitung dikeluarkan sebagai sinyal kontrol ke aktuator (misalnya motor, katup, dll.) untuk mewujudkan pengaturan dan pengendalian objek kontrol.
7. **Setel frekuensi kontrol**:
- Sesuai dengan kebutuhan aplikasi tertentu, atur frekuensi kontrol yang sesuai untuk mengontrol siklus eksekusi algoritme.
8. **Eksekusi siklus algoritma PID**:
- Dalam siklus-waktu nyata, langkah-langkah di atas dijalankan berulang kali untuk terus memantau nilai umpan balik, menghitung kuantitas kontrol, dan mengeluarkan sinyal kontrol untuk mewujudkan kontrol objek yang stabil.
Dalam pemrograman mikrokontroler yang sebenarnya, Anda dapat memilih alat pengembangan dan bahasa pemrograman yang sesuai (seperti bahasa C atau bahasa assembly) sesuai dengan model mikrokontroler dan platform pengembangan tertentu. Perlu dicatat bahwa dalam aplikasi praktis, akan banyak teknik untuk mengoptimalkan dan meningkatkan algoritma PID, seperti pemisahan integral, PID adaptif, dll, yang dapat diteliti lebih lanjut dan diimplementasikan sesuai dengan kebutuhan spesifik.
Prinsip dan alur kerja pengontrol PID
Pengontrol PID terdiri dari tiga bagian: proporsional (P), integral (I) dan diferensial (D), dan menghasilkan keluaran kontrol dengan memproses kesalahan, deviasi, dan laju perubahan sistem. Alur kerjanya mencakup langkah-langkah berikut:
- Memperoleh nilai target dan umpan balik
- Hitung kesalahannya
- Hitung keluaran kontrol berdasarkan koefisien proporsionalitas, suku integral, dan suku diferensial.
- Memperbarui parameter pengontrol
- Mengeluarkan 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; // faktor skala
mengapung Ki=0.2; // Koefisien integral
float Kd=0.1; // Koefisien diferensial
// Tentukan variabel penyimpanan
titik setel mengambang=50.0; // nilai target
umpan balik mengambang=0.0; // nilai umpan balik
kesalahan mengambang=0.0; // kesalahan
float last_error=0.0; // kesalahan terakhir
integral mengambang=0.0; // Suku integral
// Fungsi penghitungan keluaran pengontrol PID
float pidController(float dt)
float pidController(float dt) {
// Hitung kesalahannya
kesalahan=setpoint - umpan balik; // Hitung suku integralnya.
// Hitung suku integralnya
integral += kesalahan * dt; // hitung suku diferensialnya
// Hitung diferensialnya
turunan float=(kesalahan - last_error) / dt; // hitung keluaran kontrol.
// Hitung keluaran kontrol
keluaran float=Kp * error + Ki * integral + Kd * turunan; // Hitung keluaran kontrol.
// Perbarui kesalahan terakhir
kesalahan_terakhir=kesalahan; // perbarui kesalahan terakhir.
kesalahan_terakhir=kesalahan; mengembalikan keluaran; // Hitung keluaran kontrol.
}
int utama(batal)
{
sementara(1)
{
// Dapatkan nilai umpan balik
// Dapatkan interval waktunya
// Hitung keluaran PID
mengambang dt=0.01; // 0,01 detik sebagai interval waktu pada contoh
float control_output=pidController(dt); // mengeluarkan sinyal kontrol.
// Keluarkan sinyal kontrol
// Menunda sinyal kontrol untuk jangka waktu tertentu
untuk (int saya=0; saya 《 10000;i++).
}
kembali 0; }
}




