L'algorithme de contrôle PID est actuellement l'un des algorithmes de contrôle les plus utilisés. Le contrôle PID offre des avantages tels que des paramètres réglables, une large gamme d'applications et une précision de contrôle élevée. En ingénierie pratique, l'algorithme PID peut être appliqué à divers domaines, notamment le contrôle électromécanique, l'automatisation industrielle, la robotique et le contrôle par microprocesseur.
Les trois paramètres de l'algorithme PID sont : le gain proportionnel Kp, la constante de temps intégrale Ti et la constante de temps dérivée Td. Différents systèmes nécessitent différents paramètres PID, et les paramètres optimaux sont généralement obtenus par expérimentation et débogage. La constante proportionnelle Kp ajuste le gain proportionnel, contrôlant le rapport entre la sortie du système et l'erreur de rétroaction pendant le fonctionnement ; la constante de temps intégrale Ti ajuste le gain intégral, contrôlant l'accumulation d'erreurs pendant le fonctionnement du système ; et la constante de temps dérivée Td ajuste le gain dérivé, contrôlant le taux de variation des erreurs dans le système de commande.
Quelle est l’approche pour implémenter l’algorithme PID sur un microcontrôleur ?
Pour implémenter un algorithme de contrôle PID sur un microcontrôleur, l'approche générale est la suivante :
1. **Déterminer les paramètres PID** :
- Sélectionnez le gain proportionnel (Kp), le temps intégral (Ti) et le temps dérivé (Td) appropriés en fonction des caractéristiques et des exigences de l'objet contrôlé réel.
2. **Acquisition de données de capteur** :
- Utilisez des capteurs appropriés (tels que des capteurs de température, des capteurs de position, etc.) pour acquérir des données de retour-en temps réel de l'objet contrôlé.
3. **Comparaison des valeurs de point de consigne et de retour** :
- Comparez le point de consigne (valeur souhaitée) avec la valeur de retour pour calculer l'erreur (Erreur).
4. **Calcul PID** :
- Calculez la variable de contrôle (sortie) à l'aide de la formule de l'algorithme PID : PID=Kp * Erreur + Ki * ∫ Erreur dt + Kd * d (Erreur)/dt.
- Kp, Ki et Kd sont des paramètres PID ; L'erreur est la valeur de l'erreur ; ∫ L'erreur dt représente le terme intégral ; et d(Erreur)/dt représente le terme dérivé.
5. **Limitation** (Facultatif) :
- Pour certaines applications, il peut être nécessaire de limiter la plage de la valeur de sortie pour éviter qu'elle ne dépasse la plage acceptable de l'objet contrôlé.
6. **Signal de contrôle de sortie** :
- La variable de contrôle calculée est utilisée comme signal de contrôle et envoyée à l'actionneur (tel qu'un moteur ou une vanne) pour réguler et contrôler l'objet contrôlé.
7. **Définissez la fréquence de contrôle** :
-Définissez une fréquence de contrôle appropriée-le cycle d'exécution de l'algorithme de contrôle-en fonction des exigences spécifiques de l'application.
8. **Itérer l'algorithme PID** :
- Dans une boucle en temps réel-, exécutez à plusieurs reprises les étapes ci-dessus pour surveiller en continu la valeur de retour, calculer la variable de contrôle et émettre le signal de contrôle pour obtenir un contrôle stable du système.
Dans la programmation réelle du microcontrôleur, vous pouvez sélectionner les outils de développement et les langages de programmation appropriés (tels que le C ou le langage assembleur) en fonction du modèle de microcontrôleur et de la plate-forme de développement spécifiques. Il convient de noter que dans les applications pratiques, il existe de nombreuses techniques pour optimiser et améliorer l'algorithme PID, telles que la séparation intégrale et le PID adaptatif, qui peuvent être étudiées plus en détail et mises en œuvre en fonction d'exigences spécifiques.
Principes et fonctionnement des contrôleurs PID
Un contrôleur PID se compose de trois composants : proportionnel (P), intégral (I) et dérivé (D). Il génère une sortie de contrôle en traitant l'erreur, l'écart et le taux de changement du système. Son fonctionnement comporte les étapes suivantes :
- Obtenir les valeurs de consigne et de retour
- Calculez l'erreur
- Calculez la sortie de contrôle en fonction du gain proportionnel, du terme intégral et du terme dérivé
- Mettre à jour les paramètres du contrôleur
- Émettre le signal de commande
Implémentation du code STM32
Voici un exemple de code pour concevoir et implémenter un contrôleur PID à l'aide d'un microcontrôleur STM32 :
```c
#inclure "stm32f4xx.h"
// Définir les paramètres du contrôleur PID
flotteur Kp=0.5 ; // Gain proportionnel
flotter Ki=0.2 ; // Gain intégral
flotter Kd=0.1 ; // Gain dérivé
// Définir les variables de stockage
consigne flottante=50.0 ; // Point de consigne
retour flottant=0.0 ; // Valeur du retour
erreur flottante=0.0 ; // Erreur
float last_error=0.0 ; // Erreur précédente
float intégral=0.0 ; // Terme intégral
// Fonction de calcul de sortie du contrôleur PID
flotteur pidController (float dt)
{
// Calculer l'erreur
erreur=point de consigne - retour ;
// Calculer le terme intégral
erreur intégrale += * dt ;
// Calculer le terme dérivé
float dérivé=(erreur - last_error) / dt ;
// Calculer la sortie du contrôle
sortie float=Kp * erreur + Ki * intégrale + Kd * dérivée ;
// Mise à jour de l'erreur précédente
last_error=erreur ;
renvoyer la sortie ;
}
int principal (vide)
{
tandis que (1)
{
// Récupère la valeur du feedback
// Définir l'intervalle de temps
// Calculer la sortie PID
flotteur dt=0.01 ; // Dans cet exemple, l'intervalle de temps est de 0,01 s
float control_output=pidController(dt);
// Sortie du signal de contrôle
// Retard d'un certain temps
pour (int je=0; je < 10000; je++);
}
renvoie 0 ;
}