Aller au contenu

Utilisation des encodeurs moteurs CC avec Arduino

Utilisation des encodeurs moteurs CC avec Arduino

Objectifs : Apprendre a utiliser des encodeurs, savoir comment ils fonctionnent.

Difficulté : 3/5

Temps d'exécution : 20 min

Matériel nécessaire :

Pour connaitre la position d'un robot ou la vitesse d'un moteur rien de tel qu'un encodeur !  Il existe plusieurs technologies d'encodeurs : encodeur magnétique, encodeur optique. Les encodeurs magnétiques fonctionnent en générale grâce à un capteur à effet Hall. Tandis que les encodeurs optiques fonctionnent à l'aide d'une roue codeuse et d'un émetteur et récepteur optique.

Ci-dessus les images d'un moteur avec encodeur magnétique, avec encodeur optique et roue codeuse et un encodeur optique "fait maison" par ashira en utilisant le ventilateur de son moteur !

Signaux des encodeurs :

L'encodeur présent sur le moteur à courant continu que j'utilise se présente sous cette forme :

Il s'agit d'un encodeur magnétique qui possède 6 ticks par tour.

Il y a 4 broches à connecter sur cet encodeur (M1 et M2 sont les entrées du moteur). Il doit être alimenter enn 3,3 V et non en 5 V. Les deux broches au centre correspondent aux deux canaux de sorties de l'encodeur, C1 et C2.

Une fois l'encodeur correctement alimenté et les voies de l'oscilloscope reliées à C1 et C2, voici ce qu'on observe :

L'encodeur est à peu près en quadrature de phase (décalage de 90° entre les deux signaux). L'intérêt d'une telle forme de signal est de pouvoir connaitre le sens de rotation du moteur. En effet, en regardant quel signal est en avance par rapport à l'autre on peut en déduire si le moteur avance ou recule.

Sur l'image ci-dessus, c'est la courbe jaune (C1) qui est en avance sur la courbe bleue (C2), le moteur fonctionne en marche avant.

Sur cette image on voit que c'est la courbe bleue qui en avance par rapport à la courbe jaune (les fronts montants de la bleue sont déclenchés avant celles de la jaune), le moteur fonctionne en marche arrière.

L'intérêt également d'avoir deux signaux est de pouvoir doubler la résolution de l'encodeur en comptant une impulsion par front montant de chaque signal !

Pour un même intervalle de temps, je fais varier la vitesse du moteur : le nombre d'impulsions augmentent dans cet intervalle.

Ci-dessus, le moteur tourne à une vitesse intermédiaire et ci-dessous il tourne à sa vitesse maximale.

On peut calculer la vitesse de rotation du moteur grâce au nombre d'impulsions. On peut en déduire la distance parcourue par une roue en connaissant de son diamètre.

Enfin, la résolution des encodeurs est très importante, plus elle est grande et plus la mesure de la vitesse de rotation du moteur est précise ! Cette résolution ne dépend pas du type d'encodeur mais du nombre de ticks par tour d'arbre moteur. Ce nombre de ticks peut être défini par exemple par le nombre d'encoche dans une roue codeuse ou le nombre d'aimant dans un encodeur magnétique.

Détection des fronts de l'encodeur :

Pour lire les données envoyées par l'encodeur, je vais brancher celui-ci sur une carte arduino uno. Mais d'abord il faut dénuder, étamer et souder (comme le montre ce tutoriel sur la soudure) les fils de l'encodeur avec des fils mâle mâle pour les connections soit plus simples ! 

Ensuite, on peut passer au câblage ! Pour piloter le moteur j'utilise le driver l9110, le détail de ses broches a été vu dans le test du driver.

Le moteur est connecté au bornier à vis du driver. Le driver possède 4 broches à utiliser : la masse, l'alimentation (5V), la commande de vitesse (broche IA) et la commande de direction (broche IB). Les broches IA et IB sont reliées à deux entrées analogiques de la carte arduino.

L'encodeur est aussi alimenté par la carte (en 3.3V) et les voies C1 et C2 sont reliés à des entrées numériques (broches 2 et 3 de la carte arduino si on veut faire des interruptions).

Le programme que j'ai utilisé est le suivant (télécharger la librairie "TimerOne" avant de compiler) :

Il permet d'incrémenter un compteur à chaque fois qu'un front montant est détecté. Il lit la valeur des canaux de l'encodeur et donne la vitesse de rotation du moteur. Ce programme utilise une entrée d'interruption (broche 2) et tiens compte du sens de rotation du moteur.

Voilà le résultat dans le moniteur série de l'IDE arduino :

lorsque le moteur est arrêté,

et lorsqu'il tourne à pleine vitesse.

J'espère que ce tutoriel sur les encodeurs vous a aidé à comprendre leur fonctionnement. Maintenant vous n'avez plus qu'à tester !

Partagez vos projets sur le forum !

2 Commentaires

  • Avatar
    Maximusk
    juin 6, 2017

    Super tuto, par contre il y a un detail qui manque dans l'explication : Il ne faut pas prendre que les fronts montants, car si le codeur oscille autour d'une position (a cause de vibrations par exemple), le compteur va beaucoup augmenter ou diminuer au lieu de rester a peu pres constant.

    • Avatar
      Mike118
      juil. 2, 2017

      En fait, le code ne prend pas que le front montant mais bien tous les changements d'état ! ligne 49 : attachInterrupt(0,counter, CHANGE); Pour détecter que des front montant il faudrait mettre RISING au lieu de CHANGE. Pour les fronts descendant il faudrait mettre FALLING =) .

Cet article vous a plu ? Laissez-nous un commentaire !

Tous les champs sont obligatoires

Nom:
E-mail: (ne sera pas publié)
Commentaire:
Recopier le code