L'algorithme de contrôle PID est un algorithme de contrôle largement utilisé, le contrôle PID présente les avantages de paramètres réglables, d'une large gamme d'applications et d'une précision de contrôle élevée. En ingénierie pratique, l'algorithme PID peut être appliqué au contrôle électromécanique, à l'automatisation industrielle, au contrôle des robots, au contrôle par microprocesseur et à de nombreux autres domaines.
Les trois paramètres de l'algorithme PID sont ajustés : constante de proportionnalité Kp, constante de temps intégrale Ti, constante de temps différentielle Td. Différents systèmes doivent définir différents paramètres PID, et il est généralement nécessaire d'obtenir les paramètres optimaux par le biais d'expérimentations et de débogage. La constante de proportionnalité Kp ajuste la proportion, en ajustant le rapport entre l'erreur de sortie et l'erreur de rétroaction dans le système de contrôle ; la constante de temps intégrale Ti ajuste l'intégrale, ajustant l'accumulation d'erreurs dans le système de contrôle ; la constante de temps différentielle Td ajuste le différentiel, ajustant le taux de changement d'erreur dans le système de contrôle.
Quelle est l'idée de réaliser un algorithme pid avec un microcontrôleur
Pour réaliser l'algorithme de contrôle PID sur un microcontrôleur, voici l'idée générale de réalisation :
1. **Déterminez les paramètres PID** :
- En fonction des caractéristiques et des besoins de l'objet de contrôle réel, sélectionnez le coefficient de proportionnalité (Kp), le temps d'intégration (Ti) et le temps de différenciation (Td) appropriés.
2. **Acquisition de données de capteur** :
- Utilisez des capteurs appropriés (par exemple, des capteurs de température, des capteurs de position, etc.) pour collecter les données de retour de l'objet de contrôle en temps réel.
3. **Comparaison de la valeur définie et de la valeur de retour** :
- Comparez la valeur définie (valeur souhaitée) avec la valeur de retour et calculez la valeur d'erreur (Erreur).
4. **Calcul PID** :
- La quantité de contrôle (sortie) est calculée selon la formule de l'algorithme PID : PID=Kp * Erreur + Ki * ∫ Erreur dt + Kd * d (Erreur)/dt.
- Kp, Ki et Kd sont les paramètres PID, Error est la valeur de l'erreur, ∫ Error dt désigne le terme intégral et d(Error)/dt désigne le terme différentiel.
5. **Gestion des limites** (facultatif) :
- Pour certaines applications, il peut être nécessaire de limiter la plage de la valeur de sortie pour éviter de dépasser la plage acceptable de l'objet de contrôle.
6. **Signal de contrôle de sortie** :
- La quantité de contrôle calculée est émise sous forme de signal de commande à l'actionneur (par exemple moteur, vanne, etc.) pour réaliser la régulation et le contrôle de l'objet de contrôle.
7. **Régler la fréquence de contrôle** :
- En fonction des besoins des applications spécifiques, définissez la fréquence de contrôle appropriée pour contrôler le cycle d'exécution de l'algorithme.
8. **Exécution du cycle de l'algorithme PID** :
- Dans le cycle en temps réel-, les étapes ci-dessus sont exécutées à plusieurs reprises pour surveiller en continu la valeur de retour, calculer la quantité de contrôle et émettre le signal de contrôle pour réaliser le contrôle stable de l'objet.
Dans la programmation réelle du microcontrôleur, vous pouvez choisir les outils de développement et le langage de programmation appropriés (tels que le langage C ou 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 existera de nombreuses techniques pour optimiser et améliorer l'algorithme PID, telles que la séparation intégrale, le PID adaptatif, etc., qui pourront être étudiées plus en détail et mises en œuvre en fonction de besoins spécifiques.
Principe et flux de travail du contrôleur PID
Le contrôleur PID se compose de trois parties : proportionnelle (P), intégrale (I) et différentielle (D), et génère la sortie de contrôle en traitant l'erreur, l'écart et le taux de changement du système. Son flux de travail comprend les étapes suivantes :
- Obtention des valeurs cibles et des commentaires
- Calculez l'erreur
- Calculez la sortie de contrôle en fonction du coefficient de proportionnalité, du terme intégral et du terme différentiel.
- Mise à jour des paramètres du contrôleur
- Sortie de signaux de contrôle
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 ; // facteur d'échelle
flotter Ki=0.2 ; // Coefficient intégral
flotter Kd=0.1 ; // Coefficient différentiel
// Définir les variables de stockage
consigne flottante=50.0 ; // valeur cible
retour flottant=0.0 ; // valeur du retour
erreur flottante=0.0 ; // erreur
float last_error=0.0 ; // dernière erreur
float intégral=0.0 ; // Terme intégral
// Fonction de calcul de sortie du contrôleur PID
flotteur pidController (float dt)
float pidController (float dt) {
// Calculer l'erreur
erreur=point de consigne - retour ; // Calcule le terme intégral.
// Calculer le terme intégral
erreur intégrale += * dt ; // calcule le terme différentiel
// Calculer le différentiel
float dérivé=(erreur - last_error) / dt ; // calcule la sortie du contrôle.
// Calcule la sortie de contrôle
sortie float=Kp * erreur + Ki * intégrale + Kd * dérivée ; // Calcule la sortie de contrôle.
// Mise à jour de la dernière erreur
last_error=erreur ; // met à jour la dernière erreur.
last_error=erreur ; renvoyer la sortie ; // Calcule la sortie de contrôle.
}
int principal (vide)
{
pendant que(1)
{
// Récupère la valeur du feedback
// Récupère l'intervalle de temps
// Calcule la sortie PID
flotteur dt=0.01 ; // 0,01s comme intervalle de temps dans l'exemple
float control_output=pidController(dt); // génère le signal de contrôle.
// Sortie du signal de contrôle
// Retarde le signal de commande pendant un certain temps
pour (int je=0; je 《 10000;i++).
}
renvoie 0 ; }
}