Planete Sciences

OK, merci.

Quand je tourne seulement un moteur avance, l'autre et arrete, son trajet en est que plus fluide.

Je beug quand meme,je me pose des question mais arrive pas a les formuler
Pourrier vous me decrire un peu plus en detail le process, par exemple, quand est ce que le compteur est censé etre remis a 0? que ce passe t'il si je tourne ? A quelle frequence l'int du timer doit elle se produire (100ms, 1000ms) ?
Desoler de posé tant de question, et merci de l'interet que vous porter a mon Probleme.
Je comprend bien le principe, mais ne comprend pas comment l'executé et a quelle moment.

Le temps entre 2 interruptions dépend de la dynamique de tes moteurs (en gros regarde la constante de temps mécanique du moteur c'est souvent marqué dans la datasheet). Il faudra donc que ta correction s'effectue plus rapidement.
Si tu veux aller droit effectivement il faut que la vitesse du moteur droit soit egale a la vitesse du moteur gauche (logique).
Avec ta solution : Pour tourner avec une roue arrêtée, ben tu dois mettre la consigne de vitesse de la roue arrêtée à 0 (logique). Et il faudra donc que tu fasses 2 sous programme : 1 pour avancer, l'autre pour tourner.

_________________
L'asservissement c'est simple comme un PI

je n'ai jamais eu d'asservissement abouti avec des roues codeuses. Ceci dit, voici comment je structurerais mon programme :
en interruption (toutes les 10ms - 100ms) je lis le nombre de pas de chaque moteur, je remets à 0 les compteurs et je positionne un drapeau.

dans le code principale, on a trois parties :
1) déterminer l'orientation du robot (et sa position si souhaitée)
2) déterminer l'ecart d'orientation, en deduire une consigne pour chacun des moteurs
3) déterminer l'ecart (l'erreur) entre la consigne et la vitesse réelle. Et sortir une commande pour les moteurs.

le code 1) doit vraiment s'executer a chaque lecture, le code 3) doit s'executer frequement, le 2) étant plus tolerant. Mais tu dois pouvoir tout faire tourner avec un cycle de 10ms

si tu suis la structure de ce message, tu risques d'avoir quelques question, nous y repondrons certainement

_________________
Équipe Poivron
Coupe 2012 : Équipe Poivron (73e)
Coupe 2011 : Équipe Poivron (122e) - Prix des équipes !
Coupe 2010 : Équipe Poivron (78e)

Passez voir le Portail des équipes

Les questions que tu te poses, on se les ai posé aussi. Et je confirme que le net est bien pauvre sur ce type de sujet


Tu remets le compteur à 0 chaque fois que tu appliques ton correcteur.
1) Tu sauvegardes la valeur de ton compteur.
2) Tu le remets à 0 pour compter à nouveau.
3) Tu appliques ton correcteur, PID en l'occurence avec la valeur sauvegardée en 1).



Un moteur avec une consigne à 0. L'autre avec la consigne qui suit ton profil de vitesse.


Ca dépend. Il faut que tu ais suffisamment de pulses comptabilisés par ton compteur pour pouvoir avoir un calcul cohérent mais pas trop non plus pour ne pas risquer le débordement. Nous on le faisait toutes les 100 ms, D'autres toutes les 10ms. Ca dépend de la vitesse max de ton robot et de tes codeurs principalement.

[edit] Dagguy et Keuronde ont été plus rapide. ^^
Keuronde, je précise juste que tu es en asservissement polaire il me semble. Alors que notre ami asservit indépendamment ses deux moteurs. [/edit]

A+
Jorus

_________________
Geonobot
Le blog : http://geonobotblog.free.fr
Le wiki : http://geonobotwiki.free.fr

Le Portail des équipes :
http://poivron-robotique.fr/planet/

Salut,

Paul qui fait l'asservissement de notre robot en .net à poster deux articles pour décrire le code de notre asservissement, tu peux jeter un oeil ca pourrait t eclairer un peu :
part1
part2

_________________
MLRobotic
http://www.mlrobotic.com | Blog

!

Si je met dans mon 'else' qui fait avancer droit le robot un

if (valeur en ms depuis que le programe a demarer (millis)-temp_precedent =100)
if ( codeur droit=codeur gauche && vitesse = 200)
{vitesse moteur droit= vitesse moteur gauche
codeur droit=0=codeur gauche}
else if (codeur droit < codeur gauche && vitesse =200)
{ vitesse moteur droit ++
codeur droit=0=codeur gauche}
else if (codeur droit > codeur gauche && vitesse =200)
{ vitesse moteur gauche ++
codeur droit=0=codeur gauche }

Est ce que quelque chose comme ca pourrait marcher , ou suis completement a coté de la plaque ?
Merci.

A côté de la plaque.

Je t'arrête dès la seconde ligne.
A la première je te conseille de gérer ca par interruptions.

Pour la seconde : tu supposes qu'à un instant t donné, tes deux compteurs auront compté le même nombre de pulses. Or ce n'est pas plausible puisque cela supposerait deux moteurs parfaitement identiques et donc pas besoin de correcteur. Si tu as un correcteur c'est justement parce que tu ne maitrises pas l'erreur de chaque moteur.

J'ai retrouvé un excellent PDF écrit par totofweb, expliquant l'asservissement et sa mise en oeuvre, c'est long mais très complet et bien expliqué :
http://www.totofweb.net/projets/pid/rapport.pdf
Je t'en conseille une lecture approfondie car ce genre de document est bien trop rare.

A+
Jorus

_________________
Geonobot
Le blog : http://geonobotblog.free.fr
Le wiki : http://geonobotwiki.free.fr

Le Portail des équipes :
http://poivron-robotique.fr/planet/

oK, merci !

Mais quand je vois les formule avec des lettres bizares, comprend plus rien....
Bon, je reprendrais tout ça cette apres midi.

Au point où tu en es, soit tu veux un truc propre (que tu pourras faire évoluer facilement). Auquel cas, il va falloir utiliser les interruptions et tout ce qui va avec. => dis nous ce que tu utilise comme matériel/compilateur.

Soit tu veux juste avoir un truc qui avance droit, même fait à l'arrache. Et là, j'ai une proposition malhonnête à te faire :
Oublie le PID, cet algo peut faire l'affaire :

Initialise les compteur de tes roues à 0. Fixe un seuil en nombre de pas (disons 50 pour commencer).
Lance tes moteurs.
Dés qu'un moteur atteint le seuil, arrête le, remet son compteur à 0 (ou décrémente-le de la valeur de ton seuil - plus efficace si tu n'utilises pas les interruptions).
Si tes deux moteur sont à l'arrêt, remets les tous les deux en marche.

De mémoire un tel algo te permet de te décaler sur le coté de moins de 15cm sur 5m. (c'est la performance que j'avais, et je pense que je ne l'avais pas bien codé, notamment la remise à 0 des compteurs ne se faisait probablement pas au bon moment).

_________________
Équipe Poivron
Coupe 2012 : Équipe Poivron (73e)
Coupe 2011 : Équipe Poivron (122e) - Prix des équipes !
Coupe 2010 : Équipe Poivron (78e)

Passez voir le Portail des équipes

Eh oui on est tous passé par là. Pourtant, je pense qu'on peut expliquer les choses sans avoir à utiliser de formule.

@Keuronde : Avec ta méthode, ton robot n'avais pas de spasme (arrêt puis repartir puis arrêt etc ...)?

_________________
L'asservissement c'est simple comme un PI

Non, pas de spasme.
Dès que l'on coupe l'alimentation du deuxième moteur, on le réalimente. La, c'est fluide !
En choisissant des seuil qui représente des déplacement de l'ordre du cm, l'écart entre les deux roue n'est jamais très grand. Faut plutôt voir ça comme une MLI asservie. (même si je ne voyais pas ça comme ça quand je l'ai conçu).

Quand je parle de couper l'alimentation du moteur, je pense "le mettre en roue libre", pas en mode freinage;

_________________
Équipe Poivron
Coupe 2012 : Équipe Poivron (73e)
Coupe 2011 : Équipe Poivron (122e) - Prix des équipes !
Coupe 2010 : Équipe Poivron (78e)

Passez voir le Portail des équipes

c'est d'ailleurs ce genre de manip que je conseillais lorsque je disais de faire simple
on parle partout d'asservissement PID et compagnie alors qu'il ne se justifie pas toujours.

L’objectif principal lorsque l'on développe c'est d'avoir quelque chose qui fonctionne quitte à le faire évoluer après si on ne le trouve pas suffisamment efficace et que l'on a du temps a perdre dessus.
L’objectif secondaire (un peu hors sujet) c'est de faire quelque chose que l'on peut réutiliser après

Personnellement j'ai étudié l'asservissement en cour, je n’ai jamais eu le temps de le mettre en pratique. Dans mon prochain robot qui sera plus évolué , je ne compte pas faire de PID mais un turc un peu plus batard (un peu comme Keuronde) l'objectif est d'essayé d'asservir et commandé des moteur brushless a partir d'un CPLD a 2 euro et d'un peu de composants analogiques (3euro) et de 3 demie pont et leur commande à 5 euro les 3, soit environ 10 euro par moteur
Actuellement j'ai fini de dimensionné toute la partie analogique et il me reste a effectué le programme sur le CPLD, je ne garantie donc pas le fonctionnement car je ne sais pas encore si le programme va tenir sur un composant aussi faible que EPM3032.Bref tout ca pour dire que des solutions simple mais efficace peuvent être utilisé et qu'il y a beaucoup d'équipe qui ne fond pas de PID.

Re, desoler, un peu occupé...
Je ne souhaite pas obligatoirement un PID, un asservissement basic ira trés bien, du moment ou le robot se decale pas de 10m sur 10m !
Je suis sur une Arduino Mega, et je code avec leur IDE.
Demain soir je relirait tout le topic, la il faut que j'aille dormir et demain je travail, donc..
En tout cas merci pour toutes ces reponse.
Keuronde, j'aime bien ta proposition mal honnete !

J'ai envie de dire, un PID est un asservissement basic.
Tu veux asservir en vitesse chaque moteur indépendamment de l'autre (déjà je ne suis pas sûre que ça soit ce que tu veux, parce que pour aller droit....)
Asservir un moteur c'est lui fixer une consigne et le forcer à calquer sa sortie le plus fidelement possible.
Ton système à donc:
- Une entrée (ta consigne de vitesse d'un moteur)
- Une sortie (ta commande moteur)
- Une seconde entrée "Retour" (l'image de la vitesse de ton moteur)

L'image de ta vitesse tu l'exprime en tick/sec, néanmoins ton capteur te donne uniquement des ticks. Ton programme doit compter ces tick et relevé le compteur tout les xtemps (x étant 100ms par exemple), pour créer une variable en tick/100ms.

1) Un asservissement basique c'est calculer l'erreur entre la consigne et le Retour. Erreur = (Retour - consigne).
On affecte alors cette erreur à ta sortie : Sortie = Erreur.

Tu ajoute un coefficient proportionnel (P) pour améliorer la dynamique de ton système (sa réactivite).
2) Sortie = P*Erreur.

Tu peux prendre en compte l'erreur précédent dans ton calcul pour garantir une erreur statique nul (précision) avec un coefficient intégral(I).
3) Sortie = P*Erreur + I*(Ancienne_Erreur+Erreur)

Enfin tu peux ajouter le coefficient D pour apporter de la stabilité au système.
4) Sortie = P*Erreur + I*(Ancienne_Erreur+Erreur) + D*(Ancienne_Erreur-Erreur)

Pour les puristes, j'ai pris des libertés avec l'automatique dans mes explications, néanmoins si tu joues petit à petit avec les équations que je viens d'énoncé, tu devrais seul arriver à un résultat potable. Attention tout de même, tu parles d'asservissement en vitesse de chaque moteur indépendant, et plus loin tu souhaiterais aller droit. De mon expérience, il est très difficile d'avoir un résultat potable en asservissement de robot, en prenant en compte uniquement les moteurs seuls sans prendre en compte l’interaction d'un moteur sur le mouvement du robot. Même en faisant deux PID (un par moteur) et en synchronisant mon code pour que les moteurs s'attendent, j'ai eu dans le passé des comportements trop dégradé pour avoir une précision intéressante.

Donc attention à bien te fixer un objectif à la hauteur de ton apprentissage/prototype.

_________________
Président de l'association de robotique I-Grebot de Grenoble
http://www.igrebot.fr | Wiki | Forum| Vidéos

dans tout les cas il es préférable de vérifier a la fois la vitesse et la position a partir de la on a déjà un model de valable.

Apres je pense qu’il y a une multitude de moyen utilisable mais le principal c’est de commencer simple et améliorer après en fonction des résultats