Bases et didacticiel du contrôleur PID : implémentation PID dans Arduino

Pour ceux qui travaillent dans le domaine des contrôles industriels, la théorie proportionnelle, intégrale et dérivée (PID) est probablement un concept familier. Pour la plupart des gens, ce terme est totalement inconnu, mais vous êtes peut-être plus familiarisé avec lui que vous ne le pensez. Lorsque vous appuyez sur la pédale d’accélérateur d’une voiture, vous ne tenez pas seulement compte de la distance qui vous sépare de votre vitesse idéale, la partie proportionnelle du PID, mais aussi de la façon dont votre véhicule accélère et de conditions telles que des collines.

Pour ceux qui travaillent dans le domaine des contrôles industriels, la théorie proportionnelle, intégrale et dérivée (PID) est probablement un concept familier. Pour la plupart des gens, ce terme est totalement inconnu, mais vous êtes peut-être plus familiarisé avec lui que vous ne le pensez. Lorsque vous appuyez sur la pédale d’accélérateur d’une voiture, vous ne tenez pas seulement compte de la distance qui vous sépare de votre vitesse idéale, la partie proportionnelle du PID, mais aussi de la façon dont votre véhicule accélère et de conditions telles que des collines.

Ces effets plus subtils sont ce que les termes I et D considèrent mathématiquement. Dans cet exemple, ils empêcheraient la vitesse d’une voiture de passer d’une limite supérieure à une limite inférieure, et nous pouvons appliquer le même concept à toute une série de situations de contrôle. Bien qu’un contrôle basé sur des limites puisse vous permettre d’obtenir des résultats, votre système aura tendance à agir de manière quelque peu erratique.

Équation PID

La commande PID peut être exprimée mathématiquement par l’équation suivante. P, I et D sont représentés par les trois termes qui s’additionnent ici. K_p, K_i et K_d sont des constantes qui déterminent la façon dont le système réagit à chaque facteur :

Nous pouvons également remplacer K_i et K_d par 1/T_i et T_d, respectivement. Ce changement permet à l’équation d’être plus proche de sa signification physique et aux unités de s’exprimer correctement en un nombre sans unité :

Nous pouvons également transposer l’équation pour en extraire la valeur K_p et l’appliquer à l’ensemble de l’équation, dans ce que l’on appelle la forme standard. L’un des avantages de cette forme est que nous pouvons ajuster la constante K_p globale pour l’ensemble de l’équation en une seule fois :

Tout cela peut paraître un peu intimidant, même pour quelqu’un qui a obtenu un diplôme d’ingénieur. La bonne nouvelle, c’est que vous n’avez pas besoin de ressortir votre manuel Modélisation et analyse des systèmes dynamiques pour comprendre ce qui se passe ici. Et même si cela ne fait pas de mal, il n’est pas nécessaire de savoir calculer.

En décomposant la première équation, nous obtenons u(t) - la sortie du régulateur sans unité du côté gauche de l’équation - en ajoutant trois éléments mathématiques du côté droit du signe égal : P, I et D. Chaque élément est précédé d’une valeur constante K (K_p, K_i et K_d), qui indique le poids de chaque élément lorsqu’il forme u(t), c’est-à-dire la sortie du régulateur à un moment donné. Il est possible de régler individuellement chaque valeur K pour améliorer les performances du système, ce que nous expliquerons plus loin :

Proportionnel (P—K_p)

Le premier terme de cette équation, le plus important, est e(t). Ainsi, la valeur K_p qui la précède est généralement plus importante que les autres valeurs K de l’équation. Ici, e(t) est simplement l’erreur instantanée à un moment donné - la valeur réelle d’un dispositif contrôlé moins la valeur souhaitée. Multipliez ce chiffre par K_p et vous obtenez sa contribution à la puissance globale du régulateur.

Intégral (I—K_I)

Le deuxième terme de cette équation est lié à l’erreur combinée dans le temps. Il s’agit de la somme de toutes les erreurs rencontrées sur l’appareil :

Chaque fois qu’un contrôleur calcule u(t), il ajoute l’erreur instantanée à un compte courant.

Ce chiffre est multiplié par K_i et ajouté à u(t).

Considérons une situation où une force maintient un moteur en place et ne lui permet pas de revenir au point de consigne dans des conditions normales. Au fur et à mesure que les spécifications sont dépassées, le terme I continue d’augmenter, ce qui permet de surmonter cette force ou d’atteindre les limites de la capacité du moteur.

Dérivé (D-K_d)

Le troisième terme de cette équation est lié à la vitesse à laquelle l’erreur change :

Théoriquement, si vous n’aviez qu’un terme D dans cette équation et que votre processus maintenait constamment la mauvaise valeur, ce terme resterait nul et ne contribuerait pas à la production correcte. En revanche, si l’un des deux autres termes tente de faire en sorte que la sortie de l’appareil se remette en place trop rapidement, la dérivée peut contribuer à atténuer l’effet.

Si l’expression calculatoire de ce concept peut être utile, la réalité du contrôle PID est beaucoup moins magique qu’il n’y paraît à première vue. En pratique, nous calculons le rendement en utilisant uniquement l’addition, la soustraction et la multiplication, en tenant compte de l’erreur et du temps écoulé entre les relevés. En fait, nous avons utilisé des systèmes pneumatiques pour mettre en œuvre les premières formes de contrôle PID, en utilisant des moyens mécaniques pour saisir chaque « terme ».

1. Les contrôleurs effectuent une lecture instantanée de l’erreur.

2. Soustrayez-en la valeur instantanée précédente.

3. Multipliez la valeur obtenue par K_d pour calculer sa contribution à u(t).

Tutoriel sur le contrôleur Arduino PID

Dans de nombreuses situations, il est plus pratique de brancher un contrôleur PID dédié à votre processus, mais vous pouvez en fabriquer un vous-même à l’aide d’un Arduino ou d’une autre carte de développement similaire. Vous pouvez même écrire votre propre routine PID. Exprimez chaque terme de votre code de la manière suivante :

• P:instanteneousError = point de consigne – entrée ;
• I:cumulativeError = += erreur * elapsedTime ;
• D:rateOfError = (erreur – errorLastCalculation)/elapsedTime

Pour obtenir la production nécessaire, multipliez chacun de ces termes par sa valeur K respective et additionnez-les. En revanche, si vous souhaitez éviter de réinventer la roue, vous pouvez vous lancer dans l’aventure avec le référentiel PID de Brett Beuregard. Cette bibliothèque s’occupe des détails pour vous et vous permet de vous concentrer sur l’ajustement des valeurs des constantes P, I et D selon vos besoins.

Pour démontrer la théorie du PID en action, j’ai sorti un Arduino Nano Every de ma boîte à outils, ainsi que les pièces suivantes :

• Carte pilote moteur
• Capteur infrarouge
• Moteur récupéré d’un drone Hubsan H107C

J’ai imprimé un support de platine d’expérimentation pour le moteur ainsi qu’un « ventilateur » qui bloque la lumière 50 % du temps pour éviter de manquer des impulsions lorsqu’il tourne. Le pilote du moteur est l’entrée du moteur (autrement incontrôlé), et le retour d’information est basé sur le temps entre les impulsions.

Lorsque j’ai finalement trouvé le code et obtenu les pièces imprimées en 3D, j’ai pu contrôler le moteur d’une manière plus sophistiquée qu’en actionnant le bouton d’alimentation avec une sortie PWM (pulse-width modulation) constante.

Extrait de code de la routine PID associée ci-dessus

Parmi les éléments de code notables, citons l’utilisation d’une routine d’interruption pour enregistrer chaque impulsion au fur et à mesure que le dispositif de blocage tourne et le calcul du temps entre les impulsions à l’aide de millis(). J’ai configuré le PID dans la première partie du code en dehors des fonctions avec :

PID myPID (&difference, &driverOut, &setPoint,Kp,Ki,Kd, DIRECT)

Kp, Ki et Kd sont définis avant cette ligne dans le code et les contrôles &difference &driverOut, où &setPoint est modifié par le moniteur série. Nous pouvons manipuler ce calcul pour transformer cette différence de temps en régime, mais les paramètres PID fonctionnent comme des sorties DIRECTES parce que ce pilote particulier s’active lorsque l’entrée est tirée vers le bas. Lorsque la sortie analogique augmente (moteurs éteints), le délai entre les impulsions augmente également.

Une version antérieure de la routine PID. Remarque CH1 lit les impulsions d’entrée, tandis que CH2 est la sortie calculée à l’aide de la routine PID - les impulsions basses sont envoyées au moteur..

Cet exemple de contrôleur PID simple a été réalisé à l’aide de pièces disponibles (y compris le nouvel Arduino Nano Every) et d’un moteur avec lequel j’étais vaguement familier. Mais j’ai pu démontrer comment appliquer le contrôle PID dans une grande variété de situations, même sans disposer de tous les éléments. Qu’il s’agisse de la commande d’un moteur, du contrôle de la température d’un four ou de l’équilibrage d’un robot, un peu de configuration et de réglage PID vous offre des possibilités d’expérimentation infinies.

Êtes-vous sur la liste ?

Inscrivez-vous afin de recevoir des offres exclusives, des annonces de produit et les dernières nouvelles du secteur.