NXT-G, leçon n° 14 : Le PID, un contrôleur intelligent

Pour expliquer certains fonctionnements, principes et fondements.
Avatar de l’utilisateur
roboleo
Level 8
Level 8
 
Messages: 955
Localisation: Hauts de Seine
expertnxt

Messagepar roboleo » Lun Mai 03, 2010 5:18 pm

Je pense que l'écriture en NXT-G est possible. On trouve en effet un exemple sur nxtprograms.com.

Pour résoudre ce problème, il faudra 3 MonBlocs et un programme principal.
Dans les MonBlocs, on trouvera:
le calcul de la moyenne du niveau lumineux,
Le calcul des P, I, et D (Erreur en entrée et correcteur PID en sortie),
Le contrôle des moteurs au niveau de la puissance (problème de l'inversion du sens de rotation),
Le programme principal comprendra une boucle incluant le calcul du PID et celui de la puissance du moteur. Il affichera également le temps de déroulement de 10.000 cycles et le nombre de rotations des moteurs A et C.

Voila pour le principe, reste à écrire… ce qui est une autre affaire! :reflechi:
Thibaud a sans doute raison quand il pense que le langage C facilite la programmation.
Il ne me reste plus qu'à faire la démo et çà, nous le verrons plus tard… :ouch:
A+
Roboleo
" Je ne cherche pas, je trouve…" P. Picasso

NeuroMimetis
Level 10
Level 10
 
Messages: 1574
collectionneur

Messagepar NeuroMimetis » Lun Mai 10, 2010 12:09 pm

Roboleo a écrit:Reste à présent à aborder la partie la plus délicate du PID: le réglage. Il s'agit en fait de déterminer les valeurs optimales à attribuer aux constantes Kp, Ki et Kd.


J'ai découvert assez récemment le mécanisme des contrôleurs PID avec les articles de Roboleo, je suis donc encore novice en la matière mais je souhaitais partager avec d’autres (novices) une façon différente de dire les choses pour régler ces foutus paramètres.

Ce que j'en vois, c'est que :

- Kp contrôle le "niveau" de correction d'erreur et donc, plus Kp est grand, plus la correction est rapide mais plus le dépassement est important : si ma réaction est trop forte je dépasse l'objectif de beaucoup.

- Ki permet de limiter l'erreur, lorsque le système est "stable" (ie : lorsqu'il a cessé d'osciller). Ki contrôle donc la précision : une valeur de Ki élevée augmente la précision mais augmente le temps nécessaire à stabiliser le système.

- Kd permet de limiter le dépassement. Lorsque Kd augmente, on limite l’amplitude des oscillations mais le système en « anticipant » de trop, met plus de temps à atteindre l’objectif. C'est un peu comme freiner en "gardant le pied au plancher" ...

Ajoutez à cela la mécanique de votre robot (couple / accélération / diamètre des roues ...) et vous verrez vite à quel point notre cerveau est une fabuleuse machine capable de suivre un tracé à 130 km/h, tout en réfléchissant à son prochain MOC :lol:

Neuro

Avatar de l’utilisateur
roboleo
Level 8
Level 8
 
Messages: 955
Localisation: Hauts de Seine
expertnxt

Messagepar roboleo » Mer Mai 12, 2010 2:21 pm

Un contrôleur PID pour les robots Mindstorms NXT (suite 3)

Chapitre 4

Réglage d'un contrôleur PID sans faire usage aux calculs complexes (mais nous devons tout de même faire un peu de mathématiques).

Nous abordons ici un aspect de la question qui nous réserve des surprises. Ou plutôt nous choisirons la méthode expérimentale, qui est celle des chercheurs. C'est par répétition et essais multiples, par approximations successives que nous procéderons aux réglages. Les constantes sont liées à trop de paramètres variables pour être fixées une fois pour toutes.

En clair, il faudra faire des séries d'essais en modifiant les paramètres.

Les personnes averties ont déjà compris comment régler un contrôleur PID.
Pour ma part, n'étant pas aussi doué, j'utiliserai ce qu'ils ont appris. Il s'avère que le relevé d'un couple de paramètres permet de calculer des valeurs pour Kp, Ki et Kd avec une précision suffisante.
Peu importe le système qui contrôle les équations de réglage, elles fonctionnent presque toujours correctement. Il y a plusieurs techniques pour calculer le Ks, l'une d'entre elles est appelée la "Méthode Ziegler-Nichols"; c'est celle que nous utiliserons. Une recherche sur Google offrira de nombreuses pages Web qui décrivent cette technique. La version utilisée est extraite de la page de 'Wiki page on PID Controllers' (le même traitement est trouvé en beaucoup d'autres endroits). Il y aura juste une petite modification en insérant la boucle temps (dT) dans les calculs figurants dans la table ci-dessous.

Pour régler votre Contrôleur PID, suivez ces étapes:

1 - Fixez la valeur zéro aux constantes Ki et Kd. Cela force le contrôleur à se conduire comme un simple contrôleur P.
2 - Attribuez au terme Tp une valeur la plus faible possible. Pour nos moteurs, 25 serait une bonne valeur de début.
3 - Attribuez au terme Kp une valeur "raisonnable". Qu'est-ce qui est "raisonnable" ?
a ) choisissez la valeur maximale du contrôle de puissance du moteur (100) et divisez la par la valeur d'erreur utilisable maximale. Pour notre robot suiveur de tracé nous avons supposé que l'erreur maximale était de 5, donc notre projection pour Kp est 100/5=20. Quand l'erreur est égale à + 5 la puissance du moteur sera de 100 unités. Quand l'erreur sera égale à zéro la puissance du moteur sera assise au niveau de Tp.
b ) Ou alors, fixez la valeur de Kp à 1 (ou 100) et notez le résultat.
c ) Si vous avez introduit un multiplicateur pour les K's de 100 fois leur valeur réelle, vous devez en tenir compte ici. 1 sera saisi comme 100, 20 comme 2000, 100 comme 10000.

4 - Lancez le programme et observez le comportement du robot. S'il ne peut pas suivre le tracé et se déplace à l'aveuglette, alors augmentez la valeur de Kp. S'il oscille d'une manière extravagante alors diminuez la valeur de Kp. Continuez à modifier la valeur de Kp jusqu'à ce que vous trouviez celle qui fournit une oscillation sur le tracé acceptable. Nous appellerons ce Kp "Kc" ("le gain critique" dans la littérature PID).
5 - Utilisez la valeur Kc comme Kp, Lancez le programme du robot et essayez de déterminer la vitesse de l'oscillation. Cela peut être délicat, mais heureusement le relevé n'a pas besoin d'une grande précision. La période d'oscillation (Pc) représente le temps nécessaire au robot pour balayer de part et d'autre du tracé et revenir à son point de départ. Pour des robots Lego Pc sera probablement dans la plage d'environ 0.5 seconde à une seconde ou deux.
6 - Vous devez aussi connaître à quelle vitesse tournent les cycles du robot au travers de la boucle de contrôle. On a ici donné arbitrairement à la boucle un nombre fixe de tours (comme 10,000) ainsi que le temps nécessaire au robot pour accomplir ce travail (ou demander au robot de chronométrer et afficher le résultat.) le temps par boucle (dT) est le temps mesuré divisé par le nombre de boucles. Pour un contrôleur PID complet, programmé en NXT-G, sans aucun bloc de sons, le dT sera dans la plage de 0.015 à 0.020 secondes par boucle.
7 - Utilisez la table ci-dessous pour calculer une série de valeurs Kp, Ki et Kc. Si vous voulez juste un contrôleur P utilisez alors la ligne dans la table marquée P pour calculer la valeur "correcte" Kp (Ki ' et Kd ' ont tous les deux une valeur zéro). Si vous ne voulez qu'un contrôleur PI utilisez alors la ligne suivante. Le contrôleur PID complet est le résultat final(la ligne inférieure).

8 - Si vous avez déjà multiplié K par 100 pour tenir compte de l'absence de valeurs décimales, ignorez cette opération pour les calculs. Ce facteur de 100 est déjà pris en compte dans Kp = Kc valeur que vous avez déterminé.
9 - Lancez le programme et observez le comportement du robot.
10 - Faîtes varier la valeur Kp, Ki et des valeurs de Kd pour obtenir la meilleure performance possible. Vous pouvez commencer par une assez grande variation, disons 30 % puis essayez alors une plus petite afin d'obtenir une valeur optimale (ou au moins acceptable) de la performance.
11 - Une fois réunis un bon jeu d'essais de K's augmenter la valeur de Tp, qui contrôle la vitesse rectiligne du robot.
12 - Réajustez K's ou peut-être revenez à l'étape 1 et répéter le processus en entier pour une nouvelle valeur de Tp.
13 - Répéter a nouveau jusqu'à ce que le comportement du robot vous convienne.
Fig 7

Image

La virgule (en exposant) sur les Ki's et Kd's sont là juste pour rappeler qu'ils sont calculés en supposant dT constant et compris dans les valeurs de K.

James Sluka, auteur de cet article, a testé pour son robot certaines valeurs avec les commentaires suivants:
Pour Kc = 200 et quand Kp = Kc, la fréquence des oscillations du robot était de 0,8 seconde. Donc Pc = 0,8.
Il a mesuré Pc en comptant à haute voix chaque fois que le robot oscillait totalement dans une direction particulière. Il a alors comparé sa perception du comptage à " 1 potato, 2 potato, 3 potato…". Ce n'est peut-être pas de la mécanique de précision, mais cela fonctionne assez bien dans ce que nous appellerons "l'ingénierie pratique". La boucle de temps dT, est de 0.014 secondes par cycle déterminée en exécutant simplement le programme 10,000 fois et en affichant sur l'écran du NXT le temps écoulé. En utilisant la table ci-dessus pour un contrôleur PID on arrive au résultat suivant:

Kp = (0.60)(Kc) = (0.60)(200) = 120

Ki = 2(Kp)(dT) / (Pc) = 2(120)(0,014) / (0,8) = 4,2 (arrondi à 4)

Kd = (Kp)(Pc) / ((8)(dT)) = (120)(0,8) / ((8)(0,014)) = 857
Après plusieurs essais et réglages, les valeurs suivantes ont été retenues: 220, 7, et 500 pour respectivement Kp, Ki, et Kd. Sans oublier que tous les K's étaient affectés du facteur 100, ce qui signifie que les valeurs réelles sont respectivement 2,2 - 0,07 - et 5.

Comment les variations des Kp, Ki, et Kd modifient les performances des robots.

Le tableau et la méthode décrits ci-dessus constituent un bon point de départ pour optimiser votre PID. C'est aussi une aide pour une meilleure compréhension du résultat selon l'augmentation ou la diminution de l'un des trois Ks. La table ci-dessous est disponible sur beaucoup de sites Web. La version particulière ci-après est celle du Wiki sur des contrôleurs PID.

Fig. 8

Image

Le "temps de réactivité" correspond au temps de rectification de l'erreur par le robot.
Dans notre cas type il correspond au temps mis par le robot dans sa tentative de revenir au bord du tracé après s'en être éloigné. Le temps de réactivité est surtout contrôlé par Kp. Plus Kp est grand, et plus le robot accélère ce retour en diminuant le temps de réactivité. Si Kp est trop grand le robot perd le contrôle..

"Le Dépassement" est à la distance d'écartement (par rapport au bord du tracé) que le robot a tendance à prendre alors qu'il réagit à une erreur. Par exemple, si le dépassant est petit, le robot ne vire pas à droite du tracé, il essaye alors de rectifier en virant à gauche du tracé. Si le dépassement est grand, alors le robot oscille devant le bord du tracé et essaye de corriger l'erreur. Le dépassement est en grande partie contrôlé par le terme Kd, mais est fortement affecté par les termes Kp et Ki. D'habitude pour corriger fortement le dépassement vous serez tenté d'augmenter Kd.
Rappelez-vous notre premier suivi de tracé le plus simple, celui qui ne fait rien d'autre que virer à droite ou gauche ! Ce dispositif a un très mauvais dépassement.

"Variation du temps" est le temps pris par le robot pour prendre en compte un grand changement. Dans notre cas, un grand changement survient quand le robot procède à un virage. Alors que le robot répond à la courbe, il corrigera l'erreur puis le dépassement par une certaine valeur. Il doit alors corriger ce dépassement et revenir dans l'autre sens.
Il doit alors corriger ce dépassement… bien, vous avez l'idée. Pour réagir à une erreur le robot aura tendance à osciller autour de la position souhaitée. "Variation du temps" est le temps pris par cette oscillation pour revenir à zéro. "Variation du temps" répond fortement tant au terme de Kd qu'à celui de Ki. Plus Ki est grand et plus "Variation du temps" est long. Plus Kd est grand et plus "Variation du temps" est court.

"L'Erreur à l'Équilibre" est l'erreur restante alors que le dispositif fonctionne sans être "dérangé". Pour notre suivi de tracé, ce serait comme suivre une trajectoire rectiligne. Les contrôleurs P et PD résolvent souvent cette sorte d'erreur. Elle peut être réduite en augmentant Kp mais cela peut déclencher une oscillation du robot. Incluant un terme I et en augmentant Ki on corrigera souvent un contrôleur P ou PD qui conserve une erreur constante à l'équilibre. (Cela suppose que vous vous souciez même d'une petite erreur restante alors que le robot suit le tracé. Cela se traduit par une petite correction d'un côté ou d'un autre par une petite valeur).

A suivre… ;)

EDIT: correction apportée dans le calcul de Kc (200 au lieu de 300).
Dernière édition par roboleo le Mer Mai 12, 2010 7:07 pm, édité 2 fois au total.
A+
Roboleo
" Je ne cherche pas, je trouve…" P. Picasso

NeuroMimetis
Level 10
Level 10
 
Messages: 1574
collectionneur

Messagepar NeuroMimetis » Mer Mai 12, 2010 2:40 pm

A ne lire que les algos, ma vision était bien réductrice ...

Bon, il faut vraiment que j'écrive le programme pour me faire une idée. Je pense que ce programme commencera par la "saisie" des paramètres à l'aide d'une roue codeuse. Ce sera beaucoup plus pratique que d'éditer sans cesse le programme.

Si j'arrive à un truc propre (en NXT-G, ce serait très surprenant), je vous le poste.

Neuro

PS : avec tout ça, j'allais oublier de remercier Roboleo notre PID's guru :resp: qui met à notre portée des trucs que l'on ne chercherait même pas à aborder.

Avatar de l’utilisateur
BUZ
Level 9
Level 9
 
Messages: 1410
Localisation: Région de la quenelle // Avignon
expertgbb

Messagepar BUZ » Mer Mai 12, 2010 3:41 pm

roboleo a écrit:Kp = (0.60)(Kc) = (0.60)(300) = 120



0.6*300 = 180 :oops:
sinon Kc = 200

Avatar de l’utilisateur
roboleo
Level 8
Level 8
 
Messages: 955
Localisation: Hauts de Seine
expertnxt

Messagepar roboleo » Mer Mai 12, 2010 4:30 pm

BUZ a écrit:
roboleo a écrit:Kp = (0.60)(Kc) = (0.60)(300) = 120



0.6*300 = 180 :oops:
sinon Kc = 200


Il y a une erreur (?), incohérence (?) du texte original.
Je vérifie sur les tableaux de valeurs calculées par l'auteur. Il y a derrière toute une série de calculs intermédiaires.
Je rectifierai par la suite… ;)
A+
Roboleo
" Je ne cherche pas, je trouve…" P. Picasso

Avatar de l’utilisateur
BUZ
Level 9
Level 9
 
Messages: 1410
Localisation: Région de la quenelle // Avignon
expertgbb

Messagepar BUZ » Mer Mai 12, 2010 4:44 pm

une erreur sur le calcul

car 0.6*300 = 180 et non 120
mais ça ne change rien aux autres calculs qui eux sont justes (les 3 lignes en dessous)

;)

EDIT : pour l'exemple avec KC = 300
EDIT2 : donc tu dois changer le KC =300 par KC = 200

Avatar de l’utilisateur
roboleo
Level 8
Level 8
 
Messages: 955
Localisation: Hauts de Seine
expertnxt

Messagepar roboleo » Mer Mai 12, 2010 5:39 pm

BUZ a écrit:une erreur sur le calcul


EDIT2 : donc tu dois changer le KC =300 par KC = 200

C'est la conclusion à laquelle je suis arrivé. Dans ses tableaux, l'auteur ne fait aucune allusion à une valeur précise, mais je trouve bien une plage autour de 200 avec des valeurs proches pour Ki et Kd.
Je vais en informer l'auteur.
;)
A+
Roboleo
" Je ne cherche pas, je trouve…" P. Picasso

Avatar de l’utilisateur
roboleo
Level 8
Level 8
 
Messages: 955
Localisation: Hauts de Seine
expertnxt

Messagepar roboleo » Sam Mai 22, 2010 3:22 pm

Un contrôleur PID pour les robots Mindstorms NXT (suite 4 et fin)

Chapitre 5

Un programme complet d'un contrôleur PID pour un robot suiveur de tracé muni d'un simple capteur lumineux.

Nous abordons enfin l'élaboration du programme en NXT-G.

Rappelons rapidement les caractéristiques du dispositif.
Ce contrôleur est un suiveur de ligne gauche ("left hand line follower") et dispose d'un moteur A à gauche et un moteur C à droite. Le capteur lumineux est connecté au port 2.

Nous utiliserons 4 programmes NXT-G pour résoudre le problème:
3 MonBlocs qui devront être rangés dans la palette "perso" Monbloc (songez à les installer avant d'utiliser le programme principal).
Un Programme principal qui contiendra ces 3 Monblocs.

1 ) Le MonBloc PID_LF_Calib mesure le niveau lumineux maximum and minimum et calcule le niveau de "gris" (déjà vu au chapitre 2). Il est déjà installé si vous avez suivi les parties précédentes.
Ce Bloc peut-être supprimé et la valeur "gray" écrite directement dans la variable "TargLight", si vous préférez une valeur non calibrée.

2 ) Le MonBloc LF_PID effectue les calculs du PID. En entrée on trouve l'erreur courante, et en sortie la correction du niveau de puissance des moteurs (intitulé "PID"). Les Ks sont envoyés au bloc LF_PID comme des variables globales (variables définies à la fois dans le programme principal et dans le MonBloc utilisant le même nom et le même type).

3 ) Le MonBloc qui contrôle les moteurs (PID_LF_MotorControl) utilise les variables "A-motor" et "B-motor" pour respectivement les moteurs gauche et droit. Les moteurs présents contrôlés sont A et C (pauvre choix pour des noms de variables. Il aurait mieux valu les appeler Left_motor et Right_motor).

Le MonBloc PID_LF_MotorControl prend en entrée la valeur du PID (de LF_PID) au port "Turn" et la puissance moteur cible (au port "Target"), calcule le niveau de puissance actuel pour chaque moteur et adresse ces valeurs aux moteurs. Si le calcul du niveau de puissance est de signe négatif, il est inversé et envoyé à un Bloc MOTOR pour une rotation inversée (le Bloc MOTOR ne comprend pas une puissance négative signifiant une rotation inverse).
Les 3 constantes (Kp, Ki et Kd) sont inscrites dans les variables valises. De plus, les niveaux "TargLight" et "TargPower" sont également inscrits dans leurs valises respectives. La valeur "TargLight" est la valeur moyenne ( entre le blanc et le noir lus par le capteur). Le "TargPower" est le niveau de puissance moyenne pour les 2 moteurs lorsqu'ils se déplacent en ligne droite.

Enfin,

PID_lineFol_4 est le programme principal. La boucle principale est calibrée pour un nombre de cycles déterminé. A la sortie de cette boucle, le temps en millisecondes est affiché sur l'écran du NXT ainsi que le nombre de rotations du moteur A (en degrés). Le temps écoulé et le nombre de boucles sont utilisés pour calculer la durée d'un cycle (dT), très utile pour calibrer le PID. La durée d'une boucle est de 14 milisecondes environ.

Tableau des essais:

Après toute une série de tests analysés en fonction du comportement du robot, J. Sluka a considéré ces valeurs donnant un résultat satisfaisant.
    PowerTarget--------Kp-----Ki-------Kd

    -------80--------220-----7-------500-----7111 *** (fairly smooth, OK speed, no beeps)

Application des formules par la Méthode Ziegler-Nichols:

Type----------Kp----------Ki------------------Kd

P------------0.5Kc----------0------------------0
PI------------0.45Kc----1.2(Kp)(dT)/Pc------------0
PID-----------0.6Kc ------2(Kp)(dT)/Pc----------KpPc/8/dT

Ki et Kd sont mis à zéro. Kp est égal à 100. Lancer et observer le suivi du tracé ovale et les oscillations du robot.
Augmenter Kp jusqu'à ce que le système oscille d'une manière satisfaisante. Cette valeur Kp est alors considérée comme convenable pour Kc. La période Pc se détermine à partir de ce Kc.
Dans les conditions des essais, on obtient les résultats suivants par application de la méthode:

Kc = 280 ; Pc = 0,7 et dT = 0,014 sec. La Puissance "TargetPower" est limitée à 60.
Les tops sonores qu'on pourrait entendre sont utiles pour l'optimisation et le débugging. L'idéal serait qu'aucun top ne se fasse entendre.

Type----------Kp----------Ki----------Kd
P----0,5*280=140----------0 ----------0

PI----0,45*280=126-----1,2*280*0,014/0,7= 3,…-----0

PID---0,6*280=168-------2*168*0,014/0,7= 6,72 soit 7-----168*0,7/8/0,014=1050


En appliquant ces valeurs au programme principal, nous obtenons 3 modes de comportement du robot dans son parcours:
Les P et PI des calculs précédents donnent une bonne réponse au parcours de test ovale (test pad).
Par contre, le PID donne un parcours médiocre avec une grande quantité de tops sonores.
Après correction de "TargetPower" à 80, les K's suivants sont considérés comme acceptables:

PID----->170----->7----->400
Le choix du PID complet trouve son avantage dans la puissance cible accrue, donc vitesse accrue.

Pour vous faire une idée des programmes NXT-G:
Les MonBlocs à télécharger ici:
http://files.me.com/roboleo/m68hec
http://files.me.com/roboleo/68rrsl

Et voici à quoi ces MonBlocs ressemblent:
LF_PID: module de calcul

Image

PID_LF_MotoControl

Image

Et enfin le programme principal
A télécharger ici

http://files.me.com/roboleo/zntc6v

PID_Linefol_4

Image

Nous sommes arrivés au terme de cette leçon et j'espère que vous aurez assimilé le principe du PID.
C'est un outil puissant et il faut rendre hommage à J. Sluka pour son approche en NXT-G (ce qui n'est pas du tout évident). Ses nombreux essais et tests avec commentaires m'ont permis d'en tirer quelques éléments suffisants pour illustrer cette leçon. Si le coeur vous en dit, rien ne vous empêche de tester plus finement, sachant que les résultats dépendent de chaque tracé avec ses propres conditions de luminosité. Le programme principal se prête parfaitement à toutes ces mesures et à toutes les valeurs des k's.

Et maintenant, bon travail… ;)
A+
Roboleo
" Je ne cherche pas, je trouve…" P. Picasso

Avatar de l’utilisateur
roboleo
Level 8
Level 8
 
Messages: 955
Localisation: Hauts de Seine
expertnxt

Messagepar roboleo » Lun Déc 20, 2010 5:54 pm

Cas d'un Segway soulevé par Mackhdo

Processus d'étalonnage pour les constantes Kp, Ki et Kd.
Comment étalonner les constantes autrement que par des valeurs "figées"?

Le contrôleur PID dépend de trois paramètres qui sont déterminés par la méthode expérimentale. Il n'existe pas, à ma connaissance, d'autre moyen puisqu'ils sont directement fonction des conditions environnementales (luminosité, support d'évolution, frottements, etc.), et de la construction du robot qui est différente d'un modèle à un autre (même quand ils sont identiques).
Voir chapitre 4 de la leçon 14.
Les 3 constantes Kp, Ki, Kd sont donc fixées en début de programme.

Une méthode consisterait à donner la valeur zéro aux constantes Ki et Kd ( voir fig.7, chapitre 4- Méthode Ziegler-Nichols) et procéder par étapes successives.

Petit rappel:
Au départ, le robot est tenu à la main et le capteur fournit une valeur considérée comme valeur moyenne, soit en calculant la demie somme de 2 lectures extrêmes, soit en la fixant arbitrairement. Cela explique le délai nécessaire, ponctué par des tops sonores, avant de lâcher le segway. C'est le premier paramètre (Mid) stocké nécessaire pour calculer les erreurs.
Ensuite Mid est constamment comparé à la valeur lue du capteur; la différence fournit l'Erreur. La sommation de ces erreurs fournit l'Intégrale qui croît systématiquement.
Ensuite, et en même temps, on calcule la Dérivée de l'Erreur qui est la différence entre l'erreur courante et l'erreur précédente (celle du cycle précédent).

Le (Kp x Erreur) + (Ki x Intégrale) + (Kd x Dérivée) fournit la correction à apporter simultanément aux 2 moteurs (exprimée en puissance).
Ce qu'on appelle le PID, c'est la somme de ces 3 expressions.

A noter que les valeurs négatives se traduisent par une inversion du sens de rotation des moteurs qu'il faut prendre en compte à l'aide d'un paramétrage de "Direction". ;)
A+
Roboleo
" Je ne cherche pas, je trouve…" P. Picasso

Avatar de l’utilisateur
Mackhdo
Level 3
Level 3
 
Messages: 38

Messagepar Mackhdo » Lun Déc 20, 2010 6:51 pm

j'ai essayer de faire l'étalonnage en partant de la méthode expérimentale consistant à simuler un contrôleur P en assignant la valeur 0 à Ki et Kd.
J'ai fait un petit prog qui me permet d'augmenter la valeur de Kp pas à pas en appuyant sur le bouton enter du NXT, et je relève les valeurs des variables a chaque boucle sur le PC par bluetooth ( je me rends compte a l'instant ou je rédige que cela doit influencer sur le temps d'exécution de la boucle).

Malheureusement cela ne me donne rien de concluant, à cause de ceci:
Le capteur gyroscopique fournit une vitesse angulaire en degré par seconde.
De ce fait lors de la chute le capteur va fournir une valeur du genre 60, si c'est le sens positif.
Et des que le moteur va essayer de compenser il va faire remonter le robot, de ce fait le capteur repart dans l'autre sens et va donc fournir une valeur de -60 par exemple a la lecture.
Du coup le moteur repart dans l'autre sens, etc...

Tu vois ou je veux en venir, il m'est impossible d'étalonner Kp de cette façon.

J'ai lu une études sur le Segway en NXT avec ce capteur, l'auteur a calculé ces valeurs de départs a partir de MathLab et d'autres logiciels, les formules sont assez complexes malheureusement.
Voici le lien:
http://code.google.com/p/gelway/

Je m'inspire majoritairement de son étude étant donné qu'il l'a réalisé avec les mêmes composants dont je dispose et en Lejos, ce qui est mon but.

J'espère réussir rapidement à atteindre mon but car j'ai beaucoup de projet en tête à partir du moment ou je maitriserais le PID en Lejos.

De plus je pourrais ainsi vous faire un retour détaillé sur tout ce projet.
Qui fait le malin tombe dans le ravin

Avatar de l’utilisateur
Alban42800
Level 11
Level 11
 
Messages: 2473
Localisation: Loire (42)
Âge: 51 ans
expertgbbexpertnxtvainqueurconcours

Messagepar Alban42800 » Lun Déc 20, 2010 7:24 pm

Le gyro et le capteur de lumière ne renvoient pas les mêmes grandeurs. La lumière renvoie une grandeur statique (proportionnelle à l'angle du robot donc en degrés) alors que le gyro renvoie une grandeur dynamique (lié au mouvement donc en degrés/secondes).
Ne devrais-tu pas cumuler les lecture du gyro pour avoir zéro quand le moteur à tourné ?

Cela dit je ne savais pas que le gyro marchait comme ça, tu es sur que tu n'a pas pris un accéléromètre ? (je demande au cas ou...)

Avatar de l’utilisateur
Mackhdo
Level 3
Level 3
 
Messages: 38

Messagepar Mackhdo » Lun Déc 20, 2010 7:48 pm

Non je me suis pas trompé, cf site constructeur :

The NXT Gyro Sensor contains a single axis gyroscopic sensor that detects rotation and returns a value representing the number of degrees per second of rotation. The Gyro Sensor can measure up to +/- 360° per second of rotation.

The Gyro Sensor connects to an NXT sensor port using a standard NXT wire and utilizes the analog sensor interface. The rotation rate can be read up to approximately 300 times per second.


Pour l'intégrale je cumule effectivement les lectures du gyro, mais la mon problème est sur la recherche du Kp, mais peut être as tu raison, en faisant un calcul maison il y a peut être moyen d'annuler cet effet sinusoïdale.
Je vais voir cela ce soir.
Qui fait le malin tombe dans le ravin

Avatar de l’utilisateur
Alban42800
Level 11
Level 11
 
Messages: 2473
Localisation: Loire (42)
Âge: 51 ans
expertgbbexpertnxtvainqueurconcours

Messagepar Alban42800 » Lun Déc 20, 2010 9:40 pm

Tu as déjà regardé ça ? http://www.hitechnic.com/blog/gyro-sensor/htway/
Le programme en nxc à l'air bien documenté.

Avatar de l’utilisateur
Mackhdo
Level 3
Level 3
 
Messages: 38

Messagepar Mackhdo » Mar Déc 21, 2010 11:37 am

Merci Alban, effectivement je n'avais pas vu ce lien auparavant, je me demande comment j'ai pu le rater...

Sinon j'ai bien avancé, le robot tiens bien en équilibre, maintenant je suis sur la partie contrôle par téléphone portable, c'est une autre paire de manches.

Cette partie n'étant plus en rapport direct avec le PID je vais ouvrir un topic a part pour poster mes avancées.
Qui fait le malin tombe dans le ravin


Retourner vers De la théorie à la pratique

Qui est en ligne ?

Utilisateurs parcourant actuellement ce forum : Aucun utilisateur inscrit et 15 invités