UTCoupe

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Asservissement ======


L'asservissement c'est ce qui permet au robot de se déplacer comme on le souhaite. Un exemple est beaucoup plus parlant qu'un long discours alors on commence par la :\\
Prenons un robot avec deux roues, et deux moteurs. Alimentons les deux moteurs à fond, le robot roule-t-il droit ? Eh bien non, car un des moteurs est un peu moins puissant, ou frotte un peu. Un controle de ce type s'apelle un controle en boucle ouverte : on envoit une commande aux moteurs, et sachant comment ils vont réagir, on peut prévoir ou le robot va aller, l'inverse marche aussi. Toutefois avec l'exemple que j'ai donné plus haut, on comprend que controler un robot de cette manière est inenvisageable dans notre cas : il faut l'asservir.

Un point important à noter est que l'asservissement est bête, on lui donne point auquel le robot doit aller, et il s'y rend le plus vite possible, il ne s'occupe pas d'éviter les obstacles ou autres. C'est à l'IA de décomposer la trajectoire du robot en points qui seront un à un données au robot.

===== Théorie =====

{{ http://upload.wikimedia.org/wikipedia/commons/2/20/Reponse_echelon_PID.JPG?200|}}
Asservir un système c'est le forcer à faire ce que l'on veut faire, dans notre cas, le forcer à aller à l'endroit voulu. Pour cela on utilise un asservissement par PID (Produit Intégrale Dérivée). Dans la suite, on prend l'exemple d'un robot ne pouvant se déplacer que sur une droite (un seul moteur). Voilà le concept :\\
1. On mesure l'erreur E entre le but et l'etat actuel - la distance dans notre exemple.\\
2. On calcule l'intégrale E_I et la dérivée E_D de l'erreur.\\
3. On calcule la commande de sortie C à l'aide des coefficients PID : C = P*E + I*E_I + D*E_D.\\
4. On applique la commande à la sortie. Dans notre exemple cela peut être une commande de tension ou de vitesse.\\
5. On répète le processus

C'est un système au final assez simple, qui se configure à l'aide de 3 paramètres __positifs__ P, I et D. Toute la puissance de ce modèle rédisde dans le fait que la commande de sortie peut être à peu près n'importe quoi. Que je commande mon moteur en tension, en vitesse, en accélération ou autre, le modèle sera utilisable, seuls les coefficients PID seront changés.


===== Pratique =====

==== Un asservissement simple ====

Premièrement en pratique, la boucle d'asservissement est exécutée à une fréquence constante, cela évite d'avoir à mesurer le temps pour calculer les intégrales et les dérivées. De plus cela donne plus de constance au système. On parle par exemple d'asservissement à 200Hz. 200 n'est pas qu'un exemple, c'est une fréquence qui semble correcte pour nous. Bien entendu, plus la fréquence est élevée, mieux c'est (il y aura moins d'erreurs sur intégrales et dérivées, et le système sera plus réactif).

En C, un asservissement peut avoir la tête suivante :
  double asserv(double e){
  	static double last_e = 0, integral_e = 0;
  	double derivative_e = e - last_e;
  	integral_e += e;
  	last_e = e;
  	return P*e + I*integral_e + D*derivative_e;
  }

De plus, en pratique, si le temps d'établissement est grand, il se peut que l'intégrale devienne très grande et par conséquent que cela ait un effet négatif sur le système, on apelle cela l'effet de "windup" de l'intégrale. Il existe plusieurs méthodes pour corriger ce problème : ajouter une borne supérieure et inférieure à l'intégrale, ou ne calculer l'intégrale que sur un temps donné (par exemple sur les 5 dernières secondes).

==== Les coefficients ====

Le réglage des coefficients d'asserv est assez ardu, il existe de nombreuses méthodes sur internet, qu'elle soient génériques, ou utilisées par les autres équipes de la coupe. Tout ce que je peux dire pour l'instant c'est l'influence des paramètres sur le comportement du système.
{{ http://upload.wikimedia.org/wikipedia/commons/thumb/1/11/TableauPID.jpg/220px-TableauPID.jpg?250 |}}

==== Double asservissement ===

Notre robot peut se déplacer dans un plan, et non sur une droite come dans l'exemple, il va donc falloir asservir indépendamment les deux roues. Ici il y a deux possibilités :\\
1. Asservir les deux roues indépendamment\\
2. Asservir en angle/distance\\
Nous utilisons la deuxieme solution qui consiste a effectuer un asservissement sur la distance et un sur l'angle. Ayant Cd la consigne résultant de l'asservissement en distance et Ca celle de l'asservissement en angle, on peut controler les moteurs comme suit :\\
Consigne moteur droit Cdroit = Cd + Ca\\
Consigne moteur gauche Cgauche = Cd - Ca

Cela donne un trajectoire curviligne, ce qui n'est pas toujours ce que l'on veut. En effet si l'erreur en angle est grande, le robot va partir en avant tout en tournant et risque de rentrer dans un mur si cette trajectoire n'était pas prévue. Pour éviter ce genre de comportement, au delà d'une certaine erreur en angle, on l'asservit tout d'abord uniquement en angle puis en angle et distance. Cela permet de faire tourner le robot sur lui même pour s'aligner avec l'objectif avant de se lancer en avant.\\
Autre point important : en l'etat actuel, l'asservissement ne peut pas reculer. Pour faire reculer le robot il faut lui donner directement des consignes au moteurs. Si l'asserv recoit un point "derriere" le robot, un fera demi-tour avant de s'élancer.


==== Les problèmes ====

=== Le terme intégral ===

Le premier problème dont on peut parler est celui du terme intégral. Comme évoqué précédemment, il existe des techniques pour atténuer les effets de dépassement liés au terme I. En revanche, dans notre cas, nous cherchons à établir le régime stable le plus vite possible, alors que l'erreur statique n'importe que peu.
En effet, établir le régime stable signifie atteindre la position voulue, et l'erreur statique correspond à une distance d'erreur par rapport à la condigne donnée.\\
Suite à de nombreux tests, l'erreur statique est en réalité très faible (de l'ordre de quelques millimètres au maximum). Nous allons donc résoudre le problème en supprimant le terme intégral. Cela nous permet d'atteindre la position désirée très rapidement, sans dépassement, et ce tout en gardant une erreur statique très faible. Sans compter que dans la majorité des cas, le robot ne restera pas à sa position. Une fois atteinte, le robot va vouloir aller à la position suivante de sa trajectoire, l'erreur statique est alors d'une importance très faible.

=== La phase d'approche ===

Le principal problème dans l'asservissement d'un robot à deux roues est la phase d'approche. Dans la réalité, malgré l'asservissement, le robot va souvent arriver quelques millimètre à côté de son objectif. Dans ce cas, imaginons le robot "bien orienté", mais 1 millimètre à côté de son objectif. Si on calcule son erreur en angle par rapport à son objetcif, celui ci est alors de 90° !\\
Lorsque cela se produit, le robot se met à se tourner sur lui même dans tous les sens, en tournant, le robot se décale, et cherche donc à se recaler, en touranant à nouveau. Une toute petite erreur en position produit donc une très forte instabilité en rotation.\\
Afin de corriger ce problème, nous allons définir une zone d'arrivée. Lorsque le robot sera suffisamment proche de son point d'arrivée, il ne cherchera plus à tourner sur lui même.

Cela permet de stabiliser le robot, en revanche, il faut paramétrer la taille de la zone d'arrivée en fonction de la précision de l'asservissement. Ainsi, si l'asservissement est mal réglé, la précision de l'asservissement sera faible.


==== Les réglages ====

Régler l'asservissement n'est pas une mince affaire, il y a de nombreux paramètres, les plus importants étant les 3 coefficients de chacun des deux asservissements. Nous allons commencer par régler les coefficients d'angle, car pour se déplacer en distance, le robot devra également stabiliser sa trajectoire, utilisant l'asservissement en angle.

=== Le PID d'angle ===

Commencer par mettre les coefficients I et D à zéro.\\
Faire tourner le robot d'un demi-tour.\\
Tant que le robot ne dépasse pas son objectif, augmenter le P.\\
Recommencer.\\

Une fois le P réglé, nous allons introduire le coefficient D, augmenter le D va permettre d'augmenter le P sans dépassement. Le but est alors d'augmenter les deux coefficients P et D pas à pas.\\
Si le robot tremble, c'est que le rapport (P/D) est trop faible, il faut diminuer D ou augmenter P
Si le robot dépasse sa consigne, c'est l'inverse.

Il faut augmenter ces deux coefficients de manière à ce que le robot ne dépasse pas, et ne vibre pas, et ce quelquesoit le rotation que vous donnez à faire au robot (faible rotation ou grande rotation). Vous saurez que les coefficients sont suffisamment hauts lorsque les augmenter ne changera presque pas le résultat. Au delà, il deviendra difficile de stabiliser le robot pour des consignes différentes.

De plus, vous pouvez effectuer ce test pour vérifier que les réglages sont bons :\\
Donner une consigne en angle au robot.\\
Essayer de le faire tourner sur lui-même à la main.\\

Le robot doit résister et revenir à sa position initiale le plus vite possible, la encore sans tremblement.

=== Le PID en distance ===

Le PID en distance se régle d'une manière très similaire à celui en angle, mais au lieu de donner des consigne de rotation, lui donner des consigne de déplacement.
UTCoupe

Outils d'utilisateurs

Outils du Site

Outils de la Page
