Bagaimana mewujudkan kontrol pid dengan mikrokontroler

Jun 25, 2025 Tinggalkan pesan

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; }

}

Kirim permintaan

whatsapp

Telepon

Email

Permintaan