PID-kontrollalgoritm är en allmänt använd kontrollalgoritm, PID-kontroll har fördelarna med justerbara parametrar, brett utbud av applikationer, hög kontrollnoggrannhet. Inom praktisk teknik kan PID-algoritmen tillämpas på elektromekanisk styrning, industriell automation, robotstyrning, mikroprocessorstyrning och många andra områden.
De tre parametrarna för PID-algoritmen justeras: proportionalitetskonstant Kp, integraltidskonstant Ti, differentialtidskonstant Td. Olika system behöver ställa in olika PID-parametrar, och det är i allmänhet nödvändigt att erhålla de optimala parametrarna genom experiment och felsökning. Proportionalitetskonstanten Kp justerar proportionen och justerar förhållandet mellan uteffekt och återkopplingsfel i styrsystemet; integraltidskonstanten Ti justerar integralen, justerar ackumuleringen av fel i styrsystemet; differentialtidskonstanten Td justerar differentialen och justerar hastigheten för feländringen i styrsystemet.
Vad är idén med att förverkliga pid-algoritmen med mikrokontroller
För att realisera PID-kontrollalgoritmen på en mikrokontroller är följande den allmänna idén om förverkligande:
1. **Fastställ PID-parametrarna**:
- Välj lämplig proportionalitetskoefficient (Kp), integrationstid (Ti) och differentieringstid (Td), beroende på egenskaperna och behoven för det faktiska kontrollobjektet.
2. **Sensordatainsamling**:
- Använd lämpliga sensorer (t.ex. temperatursensorer, positionssensorer etc.) för att samla in återkopplingsdata från kontrollobjektet i realtid.
3. **Jämförelse av ange värde och feedback**:
- Jämför det inställda värdet (önskat värde) med återkopplingsvärdet och beräkna felvärdet (Error).
4. **PID-beräkning**:
- Kontrollmängden (utdata) beräknas enligt PID-algoritmens formel: PID=Kp * Error + Ki * ∫ Error dt + Kd * d(Error)/dt.
- Kp, Ki och Kd är PID-parametrarna, Error är felvärdet, ∫ Error dt anger integraltermen och d(Error)/dt anger differentialtermen.
5. **Begränsningshantering** (valfritt):
- För vissa applikationer kan det vara nödvändigt att begränsa intervallet för utdatavärdet för att undvika att överskrida det acceptabla intervallet för kontrollobjektet.
6. **Utgångsstyrsignal**:
- Den beräknade styrmängden matas ut som en styrsignal till ställdonet (t.ex. motor, ventil, etc.) för att realisera regleringen och styrningen av styrobjektet.
7. **Ställ in kontrollfrekvens**:
- Ställ in lämplig kontrollfrekvens för att styra exekveringscykeln för algoritmen enligt behoven hos specifika applikationer.
8. **Cykelexekvering av PID-algoritm**:
- I realtidscykeln- exekveras stegen ovan upprepade gånger för att kontinuerligt övervaka återkopplingsvärdet, beräkna kontrollmängden och mata ut styrsignalen för att realisera den stabila kontrollen av objektet.
I själva mikrokontrollerprogrammeringen kan du välja lämpliga utvecklingsverktyg och programmeringsspråk (som C eller assemblerspråk) enligt den specifika mikrokontrollermodellen och utvecklingsplattformen. Det bör noteras att i praktiska tillämpningar kommer det att finnas många tekniker för att optimera och förbättra PID-algoritmen, såsom integral separation, adaptiv PID, etc., som kan undersökas vidare och implementeras enligt specifika behov.
PID-regulatorprincip och arbetsflöde
PID-regulatorn består av tre delar: proportionell (P), integral (I) och differential (D), och genererar styrutgången genom att bearbeta systemets fel, avvikelse och förändringshastighet. Dess arbetsflöde inkluderar följande steg:
- Få mål- och feedbackvärden
- Beräkna felet
- Beräkna kontrollutgången baserat på proportionalitetskoefficienten, integralterm och differentialterm.
- Uppdaterar styrenhetens parametrar
- Matar ut styrsignaler
STM32 kodimplementering
Följande är exempelkod för att designa och implementera en PID-kontroller med en STM32-mikrokontroller:
```c
#include "stm32f4xx.h"
// Definiera PID-regulatorns parametrar
flyta Kp=0.5; // skalfaktor
flyta Ki=0.2; // Integralkoefficient
flyta Kd=0.1; // Differentialkoefficient
// Definiera lagringsvariabler
flytande börvärde=50.0; // målvärde
flytåterkoppling=0.0; // feedback värde
flytfel=0.0; // fel
float last_error=0.0; // senaste felet
flytande integral=0.0; // Integral term
// Funktion för beräkning av PID-regulatorns utgång
float pidController(float dt)
float pidController(float dt) {
// Beräkna felet
fel=börvärde - feedback; // Beräkna integraltermen.
// Beräkna integraltermen
integral += fel * dt; // beräkna differentialtermen
// Beräkna differentialen
floatderivata=(fel - last_error) / dt; // beräkna kontrollutgången.
// Beräkna kontrollutgången
flytande utgång=Kp * fel + Ki * integral + Kd * derivata; // Beräkna kontrollutgången.
// Uppdatera senaste felet
last_error=fel; // uppdatera senaste felet.
last_error=fel; returnera utgång; // Beräkna kontrollutgången.
}
int main(void)
{
medan (1)
{
// Få feedbackvärdet
// Få tidsintervallet
// Beräkna PID-utgången
float dt=0.01; // 0,01s som tidsintervall i exemplet
float control_output=pidController(dt); // mata ut styrsignalen.
// Mata ut styrsignalen
// Fördröj styrsignalen under en viss tid
för (int i=0; i 《 10000;i++).
}
returnera 0; }
}




