Contrôle De La Vitesse D’un Moteur DC Avec Encodeur En Boucle Fermée À L’aide D’un Régulateur PI Discret Sur Arduino – V1.0

Dans ce projet, je présente un montage simple et pédagogique pour commander la vitesse d’un moteur à courant continu à l’aide d’un Arduino et d’un régulateur PI.

Le système est basé sur un JGB37-520 DC Gear Motor équipé d’un encodeur rotatif intégré et d’une roue montée sur l’arbre. L’encodeur génère des impulsions permettant à l’Arduino de calculer la vitesse en temps réel en tours par minute (RPM).

Un régulateur PI est implémenté pour contrôler la vitesse. La consigne est appliquée sous forme d’échelon (300 RPM pendant 5 secondes puis 0 RPM pendant 5 secondes) afin d’analyser le régime transitoire. La vitesse mesurée est filtrée par un filtre passe-bas du premier ordre et utilisée comme signal de retour pour améliorer la stabilité et réduire le bruit.

Ce projet illustre concrètement la commande en boucle fermée et l’analyse dynamique d’un moteur DC. Cette version V1.0 servira de point de départ pour des versions plus avancées.

1. Carte de développement Arduino Uno
2. Câble USB Type-A vers USB Type-B
3. Moteur à courant continu 6 V avec roue et encodeur ( JGB37-520)
4. Module driver de moteurs L298N
5. 2 piles rechargeables Li-ion 18650 (3,7 V)
6. Support pour piles 18650 avec interrupteur
7. Fils de connexion

Le schéma illustre le système complet de commande en vitesse en boucle fermée du moteur à courant continu. La vitesse de référence est d’abord comparée à la vitesse mesurée filtrée afin de générer le signal d’erreur. Cette erreur est traitée par le régulateur PI discret implémenté sur l’Arduino, qui calcule le signal de commande approprié.

La sortie du régulateur est envoyée au driver moteur L298N sous forme de signal PWM, permettant de contrôler la tension appliquée au moteur DC avec encodeur. L’encodeur mesure la vitesse de rotation du moteur et renvoie des impulsions vers l’Arduino. La vitesse mesurée est ensuite passée à travers un filtre passe-bas discret afin de réduire le bruit de mesure avant d’être réinjectée dans la boucle de rétroaction.

Cette structure en boucle fermée garantit une régulation stable et précise de la vitesse, tout en permettant l’analyse du régime transitoire lors des variations en échelon de la consigne.

Le moteur utilisé est un JGB37-520 DC Gear Motor présentant les caractéristiques suivantes :

1. Rapport de réduction : 9.6:1
2. Tension nominale : 6 V

À vide :

1. Vitesse : 620 RPM
2. Courant : 0.1 A

En charge nominale :

1. Vitesse : 450 RPM
2. Courant : 0.45 A
3. Couple : 0.22 kg·cm
4. Puissance : 2.7 W

L’encodeur possède une résolution de 11 impulsions par tour moteur. En tenant compte du réducteur 9.6:1, la résolution à l’arbre de sortie est :

CPR_TOTAL=11×9.6=105.6 impulsions par tour

Cette résolution est utilisée pour le calcul de la vitesse en RPM.

Pour déterminer la vitesse de rotation du moteur JGB37-520, on utilise un encodeur incrémental monté sur l’arbre moteur. Lorsque l’arbre tourne, l’encodeur génère une succession d’impulsions électriques. En comptant le nombre d’impulsions sur un intervalle de temps défini, il est possible d’estimer précisément la vitesse du moteur.

L’intervalle de temps de mesure est converti en secondes afin d’assurer la cohérence des unités. Le nombre total d’impulsions par tour de l’arbre de sortie tient compte à la fois de la résolution de l’encodeur et du rapport de réduction du réducteur :

CPR_TOTAL=CPR_MOTOR.Gearbox_Ratio

où CPR_MOTOR désigne le nombre d’impulsions générées par tour de l’arbre moteur, et Gearbox_Ratio correspond à la réduction mécanique du réducteur du JGB37-520.

La vitesse de rotation, exprimée en tours par minute (RPM), est alors calculée à l’aide de la relation suivante :

RPM=(ΔP/ΔT)×(60/CPR_TOTAL)

où ΔP représente le nombre d’impulsions comptées durant l’intervalle d’échantillonnage ΔT (en secondes). Cette formule permet de convertir les impulsions par seconde en tours par minute de l’arbre de sortie, tout en prenant en compte la résolution de l’encodeur ainsi que le rapport de réduction.

Cette approche permet ensuite de comparer la vitesse obtenue avec celle mesurée par un tachymètre externe, afin de vérifier la précision et la fiabilité des résultats.

Dans ce projet, le régulateur PI est implémenté sous sa forme discrète, l'algorithme s'exécutant numériquement sur l'Arduino avec une période d'échantillonnage fixe. Au lieu d'utiliser l'expression intégrale continue, le régulateur approxime l'intégrale par une somme cumulative de l'erreur au fil du temps. À chaque instant d'échantillonnage, l'erreur de vitesse est calculée comme la différence entre la vitesse de référence et la vitesse mesurée filtrée. Le terme intégral est ensuite mis à jour en ajoutant le produit de l'erreur et de la période d'échantillonnage.

Le signal de commande est calculé à l'aide de l'équation PI discrète :

u[n] = Kp.e[n] + Ki.∑(e[n].ΔT) avec e[n] = yr[n] − y[n].

Kp améliore la réponse dynamique, tandis que Ki élimine l'erreur en régime permanent. yr[n] représente la vitesse de référence, y[n] la vitesse mesurée filtrée et ΔT l'intervalle d'échantillonnage exprimé en secondes. Cette implémentation discrète rend le régulateur adapté aux systèmes embarqués temps réel tout en assurant une régulation de vitesse en boucle fermée efficace.

Dans ce projet, nous avons utilisé un filtre passe-bas du premier ordre pour lisser le signal de vitesse bruité du moteur et ainsi obtenir une mesure plus stable. En version discrète, le filtre s’écrit :

y[n]=α.y[n−1]+(1−α).x[n]

y[n] est la vitesse filtrée, x[n] est la vitesse bruitée, et la constante α est reliée à la constante de temps du filtre tau et à la période d’échantillonnage Ts par :

α=tau / (tau+Ts)

cette approche permet d’atténuer les variations rapides du signal et d’obtenir une estimation plus fiable de la vitesse du moteur.

Câblage :

1. M1 : Fil rouge => alimentation positive du moteur (+)(changer le positif et le négatif du moteur, la rotation changera)
2. M2 : Fil blanc => alimentation négative du moteur (-)(changer le positif et le négatif du moteur, la rotation changera)
3. C1 : Fil jaune => Première sortie de l’encodeur.
4. C2 : Fil vert => Deuxième sortie de l’encodeur.
5. 3.3V - 5V : Fil bleu => positif de l'alimentation de l’encodeur (+), ne peut pas être erroné
6. GND : Fil noir => négatif de l'alimentation de l’encodeur (-), ne peut pas être erroné

Le schéma a été réalisé avec Tinkercad et Fritzing, car le module L298D n’est pas disponible sur Tinkercad.

Les variables du système sont affichées à l’aide des outils de communication série d’Arduino : le Serial Monitor et le Serial Plotter. Le programme envoie quatre variables via le port série : le temps ttt, la vitesse de référence (rpmRefrpmRefrpmRef), la vitesse mesurée (rpmrpmrpm) et la vitesse mesurée filtrée (rpmFiltrpmFiltrpmFilt). Ces valeurs sont transmises sous forme de données séparées par des virgules, ce qui les rend faciles à lire et à traiter.

Le Serial Monitor affiche ces variables sous forme numérique, ce qui permet d’observer en temps réel le comportement du système de commande et de vérifier que le programme fonctionne correctement. Les données affichées dans le Serial Monitor peuvent également être copiées et collées dans un fichier texte. Ce fichier peut ensuite être importé dans un logiciel externe comme MATLAB ou Google Sheets afin de tracer des graphiques et réaliser une analyse plus détaillée de la réponse du système. Si vous souhaitez savoir comment afficher et tracer directement les données dans Google Sheets, vous pouvez consulter la vidéo suivante : https://www.youtube.com/watch?v=QWIbKbOPyxY&t=52s

Le Serial Plotter permet d’obtenir une visualisation graphique rapide des signaux, ce qui est utile pour observer le comportement général du système pendant les tests. Cependant, en raison de certaines limitations d’affichage telles que la vitesse de rafraîchissement et la mise à l’échelle automatique, les courbes affichées peuvent ne pas représenter parfaitement les données mesurées. Pour une analyse plus précise et une meilleure visualisation des résultats, il est donc recommandé d’utiliser des outils d’analyse de données dédiés.

Les paramètres du contrôleur, notamment Kp​, Ki​ ainsi que le coefficient du filtre α, influencent fortement le comportement du système. Ils agissent sur plusieurs caractéristiques importantes telles que le lissage du signal de vitesse, le dépassement, le temps de réponse et l’erreur statique. Dans ce projet, les valeurs α=0.7, Kp​=2 et Ki​=3 ont été déterminées expérimentalement afin d’obtenir une réponse satisfaisante du moteur. Cependant, ces paramètres peuvent être ajustés selon l’application et les performances souhaitées, car les caractéristiques peuvent varier d’un moteur à l’autre. Il est donc recommandé de rechercher des paramètres optimaux afin d’obtenir le meilleur compromis entre rapidité, stabilité et précision du contrôle de vitesse.