Utiliser la classe MeEncoderOnBoard¶
Les principales méthodes de la classe¶
Voici un tableau avec la description des principales méthodes pour utiliser la classe MeEncoderOnBoard.
| Méthode | Description |
|---|---|
int getPortA(), getPortB() |
Retourne l'état du port |
long getPulsePos() |
Retourne la valeur du compteur de pulsation. Cette valeur incrémente ou décrémente continuellement jusqu'à la remise à zéro. |
void setPulsePos(long pulse_pos) |
Sert à régler la position du compteur. Généralement pour remettre à la zéro le compteur. |
void pulsePosPlus(), void pulsePosMinus() |
Incrémente ou décrémente le compteur. |
void setCurrentSpeed(float speed), float getCurrentSpeed() |
Configure et retourne la vitesse du moteur. |
int getCurPwm() |
Retourne le PWM actuel |
void setTarPwm(int pwm) |
Configure le PWM ciblé |
void setMotorPwm(int pwm) |
Configure le PWM au moteur. Il s'agit de la seule méthode qui contrôle directement les broches du moteur. |
long getCurPos() |
Retourne la position actuelle en degrés. |
void runSpeed(float speed) |
Indique la vitesse ciblée pour le moteur. La vitesse est en rpm. Utilise le mode PID. |
void move(long position,float speed = 100) |
Le moteur se déplace à la position relative.
speed] : Vitesse à laquelle effectuer le mouvement. |
void moveTo(long position,float speed = 100) |
Le moteur se déplace à la position absolue. C'est-à-dire par rapport au zéro initial. L'unité est en degré. |
long distanceToGo() |
Distance en degrés à parcourir avant d'atteindre la cible. 360° = 1 rotation. |
void setSpeedPid(float p,float i,float d); |
Configure les paramètres PID de la vitesse de l'encodeur |
void setPosPid(float p,float i,float d); |
Configure les paramètres PID de la position de l'encodeur |
void setPosDeadBand(long deadBand), long getPosDeadBand() |
Configure et retourne la zone morte de la position, en degrés. Valeur par défaut : 10°. Lorsque la distance à la cible est dans cette zone, le moteur est coupé. Une valeur négative est traitée comme 0. Depuis la version 3.31.0. |
void setFullPositionPidEnabled(bool enabled) |
Active ou désactive le PID de position complet (P, I et D). Désactivé par défaut : le mode de position n'utilise alors que les termes P et D de setPosPid. Depuis la version 3.31.0. |
void setPulse(int16_t pulseValue); |
Configure le nombre de pulsation par rotation de l'encodeur. Doit être 9. |
void setRatio(float ratio); |
Configure le ratio de la boîte de motoréduction. Doit être 39.267. |
void setMotionMode(PID_MODE\|PWM_MODE) |
Configure le mode de déplacement. Les valeurs possibles sont PID_MODE ou PWM_MODE. |
void loop() |
Fonction qui doit être appelée sans blocage dans la boucle principale. |
bool isTarPosReached() |
Fonction qui retourne vrai ou faux si la cible de position est atteinte. |
Comprendre l'erreur¶
Avant de plonger dans les boucles d'asservissement et les régulateurs PID, il est essentiel de comprendre le concept fondamental de l'erreur dans un système de contrôle.
Qu'est-ce que l'erreur?¶
L'erreur est la différence entre ce que nous voulons obtenir (la consigne ou valeur cible) et ce que nous obtenons réellement (la valeur mesurée).
Formule de base : \(erreur = consigne - valeur\_mesurée\)
Exemples concrets d'erreur¶
-
Vitesse d'un moteur :
- Consigne : 100 RPM
- Vitesse mesurée : 95 RPM
- Erreur = 100 - 95 = +5 RPM
-
Position d'un robot :
- Consigne : avancer de 50 cm
- Distance parcourue : 48 cm
- Erreur = 50 - 48 = +2 cm
-
Angle de rotation :
- Consigne : tourner de 90°
- Angle mesuré : 92°
- Erreur = 90 - 92 = -2°
-
Température d'un four :
- Consigne : 200°C
- Température mesurée : 205°C
- Erreur = 200 - 205 = -5°C
-
Vitesse d'un véhicule :
- Consigne : 110 km/h
- Vitesse mesurée : 108 km/h
- Erreur = 110 - 108 = +2 km/h
Interprétation du signe :
- Erreur positive (+) : Le système est en dessous de la consigne (il faut augmenter)
- Erreur négative (-) : Le système est au-dessus de la consigne (il faut diminuer)
Comment mesurer l'erreur?¶
Pour mesurer l'erreur, nous avons besoin de capteurs qui nous donnent la valeur réelle du système :
- Encodeurs : mesurent la position et la vitesse des moteurs
- Gyroscope : mesure l'orientation et la rotation
- Capteurs de distance : mesurent la position du robot
- Accéléromètre : mesure l'accélération et l'inclinaison
- Thermomètres : mesurent la température
Exemple avec un encodeur¶
Exemple de correction simple¶
Une fois que nous connaissons l'erreur, nous pouvons tenter une correction basique : on ajoute l'erreur, multipliée par un facteur, au PWM actuel. Avec un facteur de 1.0, on ajoute simplement l'erreur.
Exemple concret¶
Situation initiale :
- Vitesse cible : 100 RPM
- Vitesse mesurée : 95 RPM
- PWM actuel : 150
- Erreur = 100 - 95 = +5 RPM
Correction :
- Correction = 5 × 1.0 = +5
- Nouveau PWM = 150 + 5 = 155
Résultat espéré : Le moteur devrait maintenant tourner plus vite et se rapprocher de 100 RPM.
En code¶
Voici la même correction en code. Ces lignes doivent être exécutées à chaque lecture de l'encodeur.
Et à la lecture suivante?¶
Le moteur ne réagit pas instantanément. Son inertie fait qu'il lui faut un certain temps avant d'atteindre la nouvelle vitesse. Pendant ce temps, on continue de lire l'encodeur aux 40 ms et d'ajouter l'erreur au PWM.
Voici ce qui peut se passer en poursuivant l'exemple concret (valeurs illustratives) :
| Temps (ms) | Vitesse mesurée | Erreur | PWM appliqué |
|---|---|---|---|
| 0 | 95 | +5 | 150 → 155 |
| 40 | 95 | +5 | 155 → 160 |
| 80 | 96 | +4 | 160 → 164 |
| 120 | 97 | +3 | 164 → 167 |
| 160 | 99 | +1 | 167 → 168 |
| 200 | 103 | -3 | 168 → 165 |
| 240 | 108 | -8 | 165 → 157 |
| 280 | 110 | -10 | 157 → 147 |
| 320 | 106 | -6 | 147 → 141 |
| 360 | 99 | +1 | 141 → 142 |
| 400 | 93 | +7 | 142 → 149 |
- Entre 0 et 160 ms, le moteur n'a pas encore réagi. Les corrections s'accumulent et le PWM monte trop haut.
- À 200 ms, la vitesse dépasse la consigne. On corrige dans l'autre sens, mais le moteur continue d'accélérer à cause des corrections précédentes.
- À 400 ms, la vitesse est repassée sous la consigne et le cycle recommence.
Le moteur oscille autour de la consigne sans jamais s'y stabiliser. Le code complet ci-dessous permet de l'observer avec le traceur série.
Exemple de code complet
Soulevez le robot, téléversez le code et ouvrez le traceur série à 115200 bauds.
La vitesse ne se stabilise jamais sur la consigne. Elle oscille autour de celle-ci. On corrige trop fort et trop souvent : le moteur n'a pas le temps de réagir à la correction précédente qu'on en ajoute une autre.
Problèmes de la correction simple¶
- Surcorrection : Si le facteur est trop grand, le système peut osciller
- Sous-correction : Si le facteur est trop petit, le système sera lent à corriger
- Pas de prévision : La correction ne tient pas compte de la tendance (si l'erreur augmente ou diminue)
La section suivante permet d'explorer l'effet du facteur sur la correction. C'est pour régler ces problèmes que nous utiliserons ensuite des régulateurs PID.
Correction proportionnelle¶
Cet exemple applique la correction simple au moteur de gauche (SLOT1). La consigne change automatiquement aux 3 secondes. La consigne et la vitesse mesurée sont envoyées au port série dans un format compatible avec le traceur série.
Marche à suivre :
- Soulevez le robot pour que les roues tournent dans le vide.
- Téléversez le code.
- Ouvrez le traceur série à 115200 bauds.
- Envoyez
a,boucpour changer le facteur de correctionkp.
Cliquez ici pour afficher le code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 | |
Ce qu'il faut observer :
a(petit facteur) : la vitesse met beaucoup de temps à atteindre la consigne. Elle ne l'atteint parfois pas avant le prochain changement.b(facteur moyen) : la vitesse dépasse la consigne, puis oscille avant de se stabiliser.c(grand facteur) : la vitesse oscille sans jamais se stabiliser. Le PWM saute d'un extrême à l'autre.- Pincez légèrement la roue : la vitesse chute et la correction réagit mal.
Il n'existe pas de facteur qui soit à la fois rapide et stable. La correction simple ne tient pas compte de la tendance de l'erreur. C'est pourquoi nous utilisons des régulateurs PID pour une correction plus efficace et stable.
La précision avec une boucle d'asservissement¶
Une boucle d'asservissement est une fonction dont l'objectif est d'atteindre le plus rapidement possible une consigne et de la maintenir, et ce, peu importe les perturbations externes. Le principe général est de comparer la consigne et l'état du système de manière à le corriger efficacement. (Wikipédia)
Principe¶
Le principe de base d'un asservissement est de mesurer, en permanence, l'écart entre la valeur réelle et la valeur de consigne que l'on désire atteindre (l'erreur que nous avons vue précédemment), et de calculer la commande appropriée à appliquer de manière à réduire cet écart le plus rapidement possible.
Régulateur PID¶
- Lorsque l'on donne une consigne à un moteur, on ne peut garantir que celui-ci atteindra vraiment la valeur ciblée.
- Ceci est dû à plusieurs facteurs externes tels que la friction, l'inertie, les imperfections, etc.
- C'est pour ces raisons que les robots ne font pas une belle ligne droite lorsque l'on programme directement les moteurs sans prendre en considération l'encodeur.
Il y a une méthode éprouvée qui permet à un mécanisme d'atteindre sa cible rapidement et avec précision. Cette méthode est un régulateur PID.
- Le principe est de lire l'erreur (comme nous l'avons vu dans la section précédente) et d'effectuer des opérations mathématiques spécifiques avec cette erreur pour calculer une correction optimale.
- PID signifie Proportionnelle, Intégrale et Dérivée (différentielle).
- Dans notre contexte, nous utiliserons principalement un système PD (Proportionnel-Dérivé), c'est-à-dire que nous laisserons de côté le terme intégral pour simplifier.
La fonction complète pour calculer est la suivante:
Votre réaction devant cette formule?
- \(k_x\) sont des coefficients arbitraires que l'on obtient en faisant des tests.
- \(e\) est l'erreur
- Le \(t\) est le temps
- L'intégrale est la somme des erreurs.
- La différentielle est le taux de variation (pente) depuis la dernière erreur.
L'intégrale, ce n'est qu'une somme¶
Le symbole \(\int\) fait peur, mais dans un microcontrôleur, l'intégrale est très simple. On ne lit pas l'erreur en continu : on la lit à intervalle régulier. La bibliothèque MeEncoderOnBoard calcule son PID environ toutes les 40 ms. C'est ce qu'on appelle l'échantillonnage.
Reprenons le graphique de l'erreur. À chaque lecture, on mesure l'erreur (trait rouge). Si on garde cette erreur jusqu'à la lecture suivante, on obtient un rectangle. Sa hauteur est l'erreur lue et sa largeur est le temps entre deux lectures, noté \(\Delta t\). Additionner les erreurs revient à additionner ces rectangles : c'est la surface rouge entre la consigne et la valeur mesurée.
Pour en savoir plus : la somme de Riemann
En mathématiques, l'intégrale \(\int_0^t e(\tau) \mathrm{d}\tau\) représente la surface exacte entre la consigne et la valeur mesurée.
Découper cette surface en rectangles et additionner leurs aires s'appelle une somme de Riemann. Chaque rectangle a une aire de \(e_k \times \Delta t\), où \(e_k\) est l'erreur à la \(k\)-ième lecture et \(\Delta t\) le temps entre deux lectures.
Plus les lectures sont rapprochées, plus les rectangles sont minces et plus la somme se rapproche de la surface exacte. Quand \(\Delta t\) tend vers 0, on obtient exactement l'intégrale :
Comme \(\Delta t\) est toujours le même (40 ms), on le regroupe dans \(k_\text{i}\). C'est pourquoi le code ne fait qu'additionner les erreurs.
Référence : Somme de Riemann (Wikipédia)
Avec des échantillons, l'intégrale devient une simple addition des erreurs lues jusqu'à maintenant. Reprenons les premières lectures du tableau de la correction simple :
| Temps (ms) | Erreur | Somme des erreurs |
|---|---|---|
| 0 | +5 | 5 |
| 40 | +5 | 10 |
| 80 | +4 | 14 |
| 120 | +3 | 17 |
| 160 | +1 | 18 |
À 160 ms, l'intégrale vaut donc :
Avec un coefficient \(k_\text{i} = 0.1\), le terme intégral donne :
Pas besoin de multiplier par le temps : les lectures sont toujours espacées de 40 ms, le coefficient \(k_\text{i}\) s'en charge.
Même si l'erreur diminue, la somme continue de grossir tant que l'erreur reste positive. C'est ce qui permet au terme intégral de corriger une petite erreur qui persiste dans le temps.
En code, il suffit d'une variable qui accumule l'erreur à chaque lecture :
La dérivée, ce n'est qu'une soustraction¶
La dérivée mesure à quelle vitesse l'erreur change. Sur le graphique, c'est la pente de la courbe. Pour calculer la pente entre deux points, on fait \(\frac{y_2 - y_1}{x_2 - x_1}\). Avec l'échantillonnage, les deux points sont deux lectures qui se suivent : \(x_2 - x_1\) n'est que le temps entre deux lectures, \(\Delta t\).
La hauteur \(y_2 - y_1\) correspond au changement de l'erreur entre les deux lectures : quand la valeur mesurée monte, l'erreur diminue d'autant. C'est encore plus simple que l'intégrale : on soustrait l'erreur précédente de l'erreur actuelle.
Pour en savoir plus : la pente en un point
La droite orange passe par deux lectures. Plus les lectures sont rapprochées, plus cette droite colle à la courbe. Quand \(\Delta t\) tend vers 0, elle ne touche la courbe qu'en un seul point : c'est la tangente, et sa pente est la dérivée exacte en ce point.
Comme \(\Delta t\) est toujours le même (40 ms), on le regroupe dans \(k_\text{d}\). C'est pourquoi le code ne fait que soustraire les erreurs.
Référence : Dérivée (Wikipédia)
Reprenons le tableau de la correction simple :
| Temps (ms) | Erreur | Erreur précédente | Variation de l'erreur |
|---|---|---|---|
| 80 | +4 | +5 | -1 |
| 120 | +3 | +4 | -1 |
| 160 | +1 | +3 | -2 |
| 200 | -3 | +1 | -4 |
| 240 | -8 | -3 | -5 |
À 200 ms, la variation de l'erreur vaut donc :
Avec un coefficient \(k_\text{d} = 0.5\), le terme dérivé donne :
Comme pour l'intégrale, pas besoin de diviser par le temps : les lectures sont toujours espacées de 40 ms, le coefficient \(k_\text{d}\) s'en charge.
Plus la variation est grande, plus la vitesse change rapidement. Ici, l'erreur diminue de plus en plus vite : le moteur accélère et va dépasser la consigne. Le terme dérivé est négatif, donc il réduit le PWM. Il agit comme un frein qui anticipe le dépassement.
En code, il suffit de garder l'erreur de la lecture précédente :
La correction finale¶
Récapitulons. À chaque lecture de l'encodeur (toutes les 40 ms), on calcule trois termes à partir de l'erreur :
| Terme | Ce qu'on calcule | En code | Rôle |
|---|---|---|---|
| P | erreur × \(k_\text{p}\) | prop = kp * error; |
Corrige selon l'erreur actuelle |
| I | somme des erreurs × \(k_\text{i}\) | integ = ki * errorSum; |
Élimine la petite erreur qui reste près de la consigne |
| D | (erreur − erreur précédente) × \(k_\text{d}\) | diff = kd * (error - errorPrevious); |
Freine quand l'erreur change rapidement |
La correction est la somme des trois termes. Comme pour la correction simple, on l'ajoute au PWM actuel.
Exemple concret¶
Reprenons la lecture à 200 ms du tableau de la correction simple, avec \(k_\text{p} = 1.0\), \(k_\text{i} = 0.1\) et \(k_\text{d} = 0.5\) :
- Erreur : \(-3\)
- Erreur précédente : \(+1\)
- Somme des erreurs : \(5 + 5 + 4 + 3 + 1 - 3 = 15\)
| Terme | Calcul | Résultat |
|---|---|---|
| P | \(1.0 \times (-3)\) | \(-3\) |
| I | \(0.1 \times 15\) | \(+1.5\) |
| D | \(0.5 \times (-3 - 1)\) | \(-2\) |
| Correction | \(-3 + 1.5 - 2\) | \(-3.5\) |
Le PWM passe donc de 168 à 164.5.
- Le terme D freine davantage que la correction simple, qui ne retirait que 3. Il anticipe le dépassement.
- Le terme I, lui, pousse encore vers le haut : les erreurs passées étaient positives, donc leur somme l'est encore. Si les erreurs négatives s'accumulent, la somme diminue et peut devenir négative. Le terme I pousse alors vers le bas.
- Le terme I est surtout utile près de la consigne. Quand il reste une petite erreur, le terme P devient trop faible pour la corriger. La somme, elle, continue de grossir à chaque lecture jusqu'à ce que l'erreur disparaisse. C'est ce qui permet d'atteindre exactement la consigne.
En code¶
Comme mentionné plus tôt, nous utilisons principalement les termes proportionnel et dérivé (PD). Si un terme n'est pas nécessaire, comme l'intégrale, on met son coefficient à 0.
L'effet de la modification des coefficients peut donner le résultat suivant :

Si on regarde le tableau des méthodes, on remarque la présence des méthodes setPosPid et setSpeedPid. Elles représentent l'implémentation d'un PID. Il suffit d'ajuster les coefficients au besoin. Pour calibrer ces paramètres, il faut faire des essais, car cela dépendra de chaque système (poids du robot, friction des roues, etc.).
Les valeurs par défaut qui sont dans les exemples répondent bien pour nos besoins. Ainsi nous allons utiliser celles-ci.
Extra
Si vous avez de l'intérêt pour fouiller un peu, regardez la méthode speedWithoutPos() dans le fichier src/MeEncoderOnBoard.cpp de la bibliothèque. C'est le PID utilisé par runSpeed(). Essayez d'y trouver les éléments vus dans la théorie précédente :
- la somme des erreurs (
Integral += speed_error); - la soustraction de l'erreur précédente (
speed_error - last_error); - la correction ajoutée au PWM actuel.
Vous remarquerez quelques différences :
- L'erreur est calculée à l'envers (
vitesse actuelle - consigne). La correction est donc soustraite du PWM plutôt qu'ajoutée. - La somme des erreurs est limitée à ±500 et cesse de grossir lorsque le PWM est au maximum.
- La correction est limitée à ±25 par calcul.
- Le calcul est fait dans
encoderMove(), environ toutes les 40 ms.
Faire rouler le robot droit¶
Maintenant que nous avons compris les concepts d'erreur et de régulation PID, nous pouvons apprécier les fonctions de précision comme runSpeed() qui utilisent ces principes.
Pour s'assurer que le robot suit une ligne droite, nous devons :
- Configurer les paramètres : PID, encodeur et ratio du motoréducteur
- Utiliser les bonnes fonctions : Les méthodes qui intègrent le contrôle PID
- Surveiller et ajuster : Observer le comportement et ajuster au besoin
Dans le cas présent, il faut utiliser les méthodes runSpeed avec les valeurs désirées.
Par exemple, on pourrait créer et utiliser la fonction suivante :
Vous pouvez tester avec le projet ranger_encoder_ligne_droite qui est dans mes exemples.
Mais ça ne marche pas!!!¶
En effet, même les roues vont à la même vitesse, certains robots tendent vers la droite ou la gauche. C'est dû à plusieurs facteurs. Voici quelques-uns :
- Le poids du robot n'est pas équilibré.
- Les roues ne sont pas bien alignées.
- Les roues ne sont pas bien fixées.
- Etc.
Vous constatez qu'il y a plusieurs facteurs possibles. Cela est principalement dû à la qualité des pièces et aux tolérances de fabrication. Il faut donc faire des ajustements logiciels pour compenser ces imperfections mécaniques.
Pour contourner le problème des imperfections mécaniques, on peut utiliser le gyroscope. Il suffira de lire la valeur du gyroscope et de faire une correction de vitesse en conséquence de la déviation par rapport à la direction souhaitée.
Le gyroscope¶
Dans un cours précédent, nous avons rapidement survolé le gyroscope. Nous n'avions pas vu comment l'exploiter.
Le gyroscope
Un gyroscope est un capteur qui mesure la vitesse angulaire. En intégrant la vitesse angulaire, on peut obtenir l'angle de rotation. Ce qui peut être utilisé pour déterminer l'orientation d'un objet dans l'espace. Dans le cas de notre robot, il nous permet de savoir si le robot dévie de sa trajectoire.
- Le gyroscope dans le robot permet de connaître l'angle de rotation du robot à partir de sa position initiale.
- Le gyroscope dans le robot est une des fonctionnalités du MPU-6050.
- La librairie
MeGyrooffre les fonctions suivantes :getAngleX|Y|Z(): Retourne l'angle de rotation sur l'axe X|Y|ZgetGyroX|Y|Z(): Retourne la vitesse angulaire sur l'axe X|YresetData(): Réinitialise les données du gyroscope
Exemple¶
Voici un exemple qui retourne en degré l'angle de rotation du robot. Utilisez le traceur série pour afficher les valeurs.
Utilisation¶
- Le gyroscope peut être utilisé pour qu'un actuateur (moteur) se déplace à un angle précis.
- On peut aussi l'utiliser pour que le robot se déplace en ligne droite. En corrigeant la trajectoire à chaque fois que l'angle de rotation change.
- Exemple : Avant d'aller en ligne droite, il faut lire la valeur actuelle du gyroscope en Z. Ensuite, on active les deux moteurs. À chaque fois que l'on lit le gyroscope, on compare la valeur actuelle avec la valeur initiale. Si la valeur est différente, on ajuste la vitesse des moteurs pour que le robot se déplace en ligne droite.
Le projet ranger_straight est un exemple qui utilise le gyroscope pour corriger la trajectoire du robot.
Voici la principale fonction qui permet au robot d'aller droit :
Pivoter le robot à un angle précis¶
Pour faire pivoter le robot avec précision, nous devons utiliser la géométrie du robot et les encodeurs. Voici une image avec les différentes mesures importantes :

Principe : Pour faire tourner le robot sur lui-même de 90°, chaque roue doit parcourir 1/4 de la circonférence du cercle formé par la trajectoire du robot.
Calculs nécessaires :
- Trouver la distance pour 1/4 tour.
- \(quartTour = circRobot / 4\)
- Trouver le nombre de tours de roue
- \(nbTours = quartTour / circRoue\)
- Trouver le nombre de pulsation pour effectuer 1/4 tour.
- \(nbPulsations = nbTours * 9 * 39.267\)
- Faire avancer/reculer le moteur de
nbPulsations
Faire tourner le robot¶

Pour faire tourner le robot en courbe, il faudra faire un peu de géométrie et d'algèbre.
- Trouver l'arc de cercle à parcourir en prenant le centre du robot. (
float arc)- \(arc = \frac{degre}{360}* 2\pi R\)
- Trouver les arcs des cercles externes et internes
- \(arcExt = \frac{degre}{360}* 2\pi (R + \frac{w2w}{2})\)
- \(arcInt = \frac{degre}{360}* 2\pi (R - \frac{w2w}{2})\)
Où :
- \(w2w\) = distance entre les 2 roues
- \(R\) = rayon de courbure à partir du centre du robot
- \(degre\) = Nombre de degrés à pivoter
- Trouver la distance pour les roues gauches et droites selon les arcs intérieurs et extérieurs.
IMPORTANT!!!
Ceci est la théorie où on ne prend pas en considération le niveau de la pile, le frottement, le glissement, etc. On pourra compenser avec le gyroscope.
Exercices¶
Objectifs : Mettre en pratique les concepts d'encodeurs et de précision vus dans ce cours.
-
Déplacement précis : Programmer le robot pour qu'il avance exactement de 1 mètre avec une précision de ±5%.
- Utiliser les encodeurs pour mesurer la distance parcourue
- Implémenter une correction si nécessaire
-
Aller-retour précis : Faire avancer le robot à 1 mètre ±5% puis le faire revenir exactement à son point de départ.
- Tester la répétabilité du système
- Observer l'accumulation des erreurs
Conseils :
- Calibrer les valeurs PID avant de commencer
- Mesurer physiquement la distance pour valider vos résultats
- Noter les facteurs qui affectent la précision (surface, batterie, etc.)
Questions¶
Questions de compréhension¶
- Définition de base :
- Qu'est-ce que l'erreur dans un système de contrôle? Donnez la formule.
- Quelle est la différence entre une erreur positive et une erreur négative?
- Calculs d'erreur :
- Si un moteur doit tourner à 120 RPM et qu'il tourne actuellement à 115 RPM, quelle est l'erreur?
- Interprétez le signe de cette erreur : que doit faire le système?
- Régulateur PID :
- Que signifient les lettres P, I et D dans "PID"?
- Pourquoi utilise-t-on principalement PD (sans l'intégrale) dans nos applications?
- Quel est le rôle du terme dérivé (D) dans le contrôle?
- Applications pratiques :
- Pourquoi un robot ne roule-t-il pas droit même si on donne la même vitesse aux deux moteurs?
- Comment le gyroscope peut-il aider à corriger la trajectoire d'un robot?
Questions de calcul¶
- Géométrie du robot :
- Un robot a un diamètre de roue de 6 cm et une distance entre roues de 15 cm. Combien de degrés chaque moteur doit-il tourner pour faire pivoter le robot de 90°?
- Montrez vos calculs étape par étape.
- Paramètres d'encodeur
- Avec 9 pulsations par tour et un ratio de 39.267, combien de pulsations représente une rotation complète de la roue?
- Si la roue a une circonférence de 18.8 cm, quelle distance représente une pulsation?
Questions d'analyse¶
- Problèmes de précision
- Listez 5 facteurs qui peuvent affecter la précision du déplacement d'un robot.
- Pour chaque facteur, proposez une solution ou compensation possible.
- Réglage PID :
- Si un système oscille beaucoup autour de sa cible, quel paramètre PID devriez-vous ajuster et comment?
- Si un système met trop de temps à atteindre sa cible, quel paramètre ajusteriez-vous?
- Capteurs et erreur :
- Quel capteur utiliseriez-vous pour mesurer l'erreur de vitesse d'un moteur? Pourquoi?
- Quel capteur utiliseriez-vous pour mesurer l'erreur d'orientation du robot? Pourquoi?
Questions de programmation¶
- Code pratique :
- Écrivez une fonction qui calcule l'erreur entre une consigne et une valeur mesurée.
- Écrivez une fonction simple qui applique une correction proportionnelle basée sur cette erreur.
- Configuration :
- Quel code utiliseriez-vous pour configurer les paramètres PID d'un encodeur avec kp=1.5, ki=0, kd=1.0?
- Comment faire pour que le robot avance en ligne droite à 80 RPM?