ปัจจุบันอัลกอริธึมควบคุม PID เป็นหนึ่งในอัลกอริธึมควบคุมที่ใช้กันอย่างแพร่หลายที่สุด การควบคุม PID มีข้อดีต่างๆ เช่น พารามิเตอร์ที่ปรับได้ การใช้งานที่หลากหลาย และความแม่นยำในการควบคุมสูง ในทางวิศวกรรมเชิงปฏิบัติ อัลกอริธึม PID สามารถนำไปใช้กับสาขาต่างๆ ได้ รวมถึงการควบคุมระบบเครื่องกลไฟฟ้า ระบบอัตโนมัติทางอุตสาหกรรม หุ่นยนต์ และการควบคุมไมโครโปรเซสเซอร์
พารามิเตอร์ทั้งสามของอัลกอริทึม PID ได้แก่ Kp อัตราขยายตามสัดส่วน ค่าคงที่เวลาอินทิกรัล Ti และค่าคงที่เวลาอนุพันธ์ Td ระบบที่ต่างกันต้องการพารามิเตอร์ PID ที่แตกต่างกัน และโดยทั่วไปแล้วพารามิเตอร์ที่เหมาะสมที่สุดจะได้มาจากการทดลองและการดีบัก ค่าคงที่ตามสัดส่วน Kp จะปรับอัตราขยายตามสัดส่วน โดยควบคุมอัตราส่วนของเอาท์พุตของระบบต่อข้อผิดพลาดป้อนกลับระหว่างการทำงาน ค่าคงที่เวลาอินทิกรัล Ti จะปรับเกนอินทิกรัลควบคุมการสะสมของข้อผิดพลาดระหว่างการทำงานของระบบ และค่าคงที่เวลาของอนุพันธ์ Td จะปรับค่าเกนของอนุพันธ์เพื่อควบคุมอัตราการเปลี่ยนแปลงข้อผิดพลาดในระบบควบคุม
แนวทางการนำอัลกอริธึม PID ไปใช้บนไมโครคอนโทรลเลอร์คืออะไร?
หากต้องการใช้อัลกอริธึมควบคุม PID บนไมโครคอนโทรลเลอร์ วิธีการทั่วไปมีดังนี้:
1. **กำหนดพารามิเตอร์ PID**:
- เลือกอัตราขยายตามสัดส่วนที่เหมาะสม (Kp) เวลาอินทิกรัล (Ti) และเวลาอนุพันธ์ (Td) ตามคุณลักษณะและข้อกำหนดของวัตถุควบคุมจริง
2. **การได้มาซึ่งข้อมูลเซ็นเซอร์**:
- ใช้เซ็นเซอร์ที่เหมาะสม (เช่น เซ็นเซอร์อุณหภูมิ เซ็นเซอร์ตำแหน่ง ฯลฯ) เพื่อรับ-ข้อมูลป้อนกลับตามเวลาจริงจากวัตถุที่ถูกควบคุม
3. **การเปรียบเทียบค่าเซ็ตพอยต์และค่าป้อนกลับ**:
- เปรียบเทียบเซ็ตพอยต์ (ค่าที่ต้องการ) กับค่าป้อนกลับเพื่อคำนวณข้อผิดพลาด (ข้อผิดพลาด)
4. **การคำนวณ PID**:
- คำนวณตัวแปรควบคุม (เอาต์พุต) โดยใช้สูตรอัลกอริทึม PID: PID=Kp * Error + Ki * ∫ Error dt + Kd * d(Error)/dt.
- Kp, Ki และ Kd เป็นพารามิเตอร์ PID ข้อผิดพลาดคือค่าความผิดพลาด ∫ ข้อผิดพลาด dt แสดงถึงพจน์อินทิกรัล และ d(Error)/dt แทนคำอนุพันธ์
5. **ข้อจำกัด** (ไม่บังคับ):
- สำหรับบางแอปพลิเคชัน อาจจำเป็นต้องจำกัดช่วงของค่าเอาท์พุตเพื่อป้องกันไม่ให้เกินช่วงที่ยอมรับได้ของออบเจ็กต์ควบคุม
6. **สัญญาณควบคุมเอาต์พุต**:
- ตัวแปรควบคุมที่คำนวณได้ถูกใช้เป็นสัญญาณควบคุมและส่งไปยังแอคชูเอเตอร์ (เช่น มอเตอร์หรือวาล์ว) เพื่อควบคุมและควบคุมวัตถุที่ถูกควบคุม
7. **ตั้งค่าความถี่ควบคุม**:
- กำหนดความถี่การควบคุมที่เหมาะสม-รอบการทำงานของอัลกอริทึมการควบคุม-โดยอิงตามข้อกำหนดเฉพาะของแอปพลิเคชัน
8. **ทำซ้ำอัลกอริทึม PID**:
- ในลูปเวลาจริง- ให้ดำเนินการตามขั้นตอนข้างต้นซ้ำๆ เพื่อตรวจสอบค่าป้อนกลับอย่างต่อเนื่อง คำนวณตัวแปรควบคุม และส่งสัญญาณควบคุมออกเพื่อให้ได้การควบคุมระบบที่เสถียร
ในการเขียนโปรแกรมไมโครคอนโทรลเลอร์จริง คุณสามารถเลือกเครื่องมือการพัฒนาและภาษาการเขียนโปรแกรมที่เหมาะสม (เช่น ภาษา C หรือภาษาแอสเซมบลี) ตามโมเดลไมโครคอนโทรลเลอร์และแพลตฟอร์มการพัฒนาเฉพาะ ควรสังเกตว่าในการใช้งานจริง มีเทคนิคมากมายในการเพิ่มประสิทธิภาพและปรับปรุงอัลกอริทึม PID เช่น การแยกแบบอินทิกรัลและ PID แบบปรับตัว ซึ่งสามารถวิจัยและนำไปใช้เพิ่มเติมได้ตามความต้องการเฉพาะ
หลักการและการทำงานของตัวควบคุม PID
ตัวควบคุม PID ประกอบด้วยองค์ประกอบ 3 ส่วน ได้แก่ สัดส่วน (P) อินทิกรัล (I) และอนุพันธ์ (D) สร้างเอาต์พุตควบคุมโดยการประมวลผลข้อผิดพลาด ความเบี่ยงเบน และอัตราการเปลี่ยนแปลงของระบบ การดำเนินการเกี่ยวข้องกับขั้นตอนต่อไปนี้:
- รับค่าเซ็ตพอยต์และค่าป้อนกลับ
- คำนวณข้อผิดพลาด
- คำนวณเอาต์พุตควบคุมโดยพิจารณาจากอัตราขยายตามสัดส่วน เทอมอินทิกรัล และเทอมอนุพันธ์
- อัปเดตพารามิเตอร์คอนโทรลเลอร์
- เอาท์พุตสัญญาณควบคุม
การใช้โค้ด STM32
ต่อไปนี้คือโค้ดตัวอย่างสำหรับการออกแบบและการใช้งานคอนโทรลเลอร์ PID โดยใช้ไมโครคอนโทรลเลอร์ STM32:
```c
#รวม"stm32f4xx.h"
// กำหนดพารามิเตอร์คอนโทรลเลอร์ PID
ลอย Kp=0.5; // กำไรตามสัดส่วน
ลอยกี่=0.2; // กำไรที่เป็นอินทิกรัล
ลอย Kd=0.1; // กำไรจากอนุพันธ์
// กำหนดตัวแปรหน่วยเก็บข้อมูล
จุดกำหนดลอย=50.0; //เซ็ตพอยต์
ข้อเสนอแนะแบบลอยตัว=0.0; // ค่าตอบรับ
ข้อผิดพลาดลอยตัว=0.0; // ข้อผิดพลาด
ลอยlast_error=0.0; // ข้อผิดพลาดก่อนหน้า
อินทิกรัลลอย=0.0; // เทอมอินทิกรัล
// ฟังก์ชั่นการคำนวณเอาต์พุตคอนโทรลเลอร์ PID
float pidController (ลอย dt)
{
// คำนวณข้อผิดพลาด
ข้อผิดพลาด=จุดกำหนด - ข้อเสนอแนะ;
// คำนวณเทอมอินทิกรัล
อินทิกรัล += ข้อผิดพลาด * dt;
// คำนวณเทอมอนุพันธ์
อนุพันธ์ลอยตัว=(ข้อผิดพลาด - Last_error) / dt;
// คำนวณเอาต์พุตควบคุม
เอาต์พุตลอยตัว=Kp * ข้อผิดพลาด + Ki * อินทิกรัล + Kd * อนุพันธ์;
// อัปเดตข้อผิดพลาดก่อนหน้า
Last_error=ข้อผิดพลาด;
เอาท์พุทกลับ;
}
int main (เป็นโมฆะ)
{
ในขณะที่ (1)
{
// รับค่าผลตอบรับ
// กำหนดช่วงเวลา
// คำนวณเอาต์พุต PID
ลอย dt=0.01; // ในตัวอย่างนี้ ช่วงเวลาคือ 0.01 วินาที
float control_output=pidController (dt);
// ส่งสัญญาณควบคุม
// หน่วงเวลาเป็นระยะเวลาหนึ่ง
สำหรับ (int i=0; i < 10000; i++);
}
กลับ 0;
}