Arduino Calculer Le Nombre De Tour D Un Moteur

Cette page vous permet de calculer rapidement le nombre de tours, la vitesse en tr/min et la rotation de sortie d’un moteur mesuré avec un capteur à impulsions ou un encodeur. L’outil est pensé pour les projets Arduino avec codeur optique, encodeur magnétique, capteur Hall ou disque à fentes.

Calculateur interactif

Guide expert : comment utiliser Arduino pour calculer le nombre de tour d’un moteur

Calculer le nombre de tour d’un moteur avec Arduino est une opération centrale dès qu’on travaille sur un robot mobile, un convoyeur, une imprimante 3D, un système d’ouverture, un banc de test ou une machine de dosage. En pratique, on cherche souvent à répondre à trois questions : combien de tours ont été effectués, à quelle vitesse le moteur tourne-t-il, et quelle rotation a réellement été transmise à l’arbre de sortie après réduction. Avec un Arduino, on peut mesurer ces données avec une excellente précision à condition de bien comprendre le type de capteur, la résolution du signal et la formule utilisée pour convertir les impulsions en tours.

Le principe général est simple. Un capteur produit un certain nombre d’impulsions à chaque rotation. L’Arduino compte ces impulsions via une interruption ou une lecture très rapide, puis applique une formule pour retrouver le nombre de tours. Si l’on connaît aussi la durée de mesure, on peut en déduire la vitesse en tours par minute. Cette logique fonctionne aussi bien avec un codeur incrémental optique qu’avec un capteur Hall et un aimant fixé sur l’arbre.

Formule de base :
nombre de tours = impulsions comptées / impulsions par tour effectives
tr/min = (nombre de tours / durée en secondes) × 60

1. Comprendre ce que signifie impulsions par tour

L’erreur la plus courante consiste à mal interpréter la résolution du capteur. Si un disque codeur possède 20 fentes, on pense souvent qu’il donne 20 impulsions par tour. C’est vrai en comptage simple X1 si l’on ne regarde qu’un front ou un seul canal. En revanche, un encodeur quadrature peut générer plus d’informations. En comptage X2, vous exploitez deux fronts par cycle. En X4, vous utilisez les fronts montants et descendants des deux canaux. Dans ce cas, le nombre d’impulsions effectives par tour devient bien plus élevé et votre calcul doit intégrer ce facteur.

• X1 : 1 comptage par cycle logique.
• X2 : 2 comptages par cycle.
• X4 : 4 comptages par cycle, très utile pour améliorer la résolution angulaire.

Par exemple, si votre encodeur est donné pour 100 PPR et que vous comptez en X4, votre Arduino verra 400 événements par tour. Si vous oubliez ce détail, vous risquez d’afficher une vitesse quatre fois trop élevée ou quatre fois trop faible.

2. Différence entre nombre de tours moteur et nombre de tours de sortie

Dans beaucoup de projets, le moteur est équipé d’un réducteur. Dans ce cas, le nombre de tours de l’arbre moteur n’est pas le même que celui de l’arbre de sortie. Si le réducteur est de 30:1, cela veut dire que le moteur tourne 30 fois pour obtenir un seul tour de l’axe de sortie. Cette distinction est essentielle pour les petits motoréducteurs DC, les moteurs N20, les boîtes planétaires et de nombreux mécanismes robotiques.

1. Si le capteur est placé sur l’arbre moteur, vous mesurez directement les tours moteur.
2. Pour obtenir les tours de sortie, divisez par le rapport de réduction.
3. Si le capteur est sur l’arbre de sortie, faites l’inverse pour retrouver les tours moteur.

Le calculateur ci-dessus gère les deux cas. Il peut donc être utilisé aussi bien pour un encodeur interne sur moteur que pour un disque externe monté sur l’axe de sortie.

3. Formules pratiques pour Arduino

Supposons que vous comptiez N impulsions, que votre capteur fournisse PPR impulsions par tour en lecture de base, et que vous utilisiez un facteur de comptage M égal à 1, 2 ou 4. Le nombre de tours mesuré au point de lecture est :

tours = N / (PPR × M)

Si la mesure est faite pendant T secondes, la vitesse en tours par minute est :

RPM = tours × 60 / T

Avec un réducteur R :

• si le capteur est sur le moteur, tours sortie = tours moteur / R
• si le capteur est sur la sortie, tours moteur = tours sortie × R

4. Exemple concret

Imaginez un moteur équipé d’un disque à 20 fentes, lu en X1 pendant 10 secondes. Arduino compte 1200 impulsions. Le nombre de tours vaut :

1200 / 20 = 60 tours

La vitesse moyenne est donc :

60 × 60 / 10 = 360 tr/min

Si ce moteur possède ensuite un réducteur 30:1 et que le capteur est monté sur l’arbre moteur, l’arbre de sortie aura effectué :

60 / 30 = 2 tours

et sa vitesse moyenne sera :

360 / 30 = 12 tr/min

5. Capteurs courants pour compter les tours

Le choix du capteur conditionne la qualité de la mesure. Les solutions les plus fréquentes sur Arduino sont les suivantes :

• Capteur Hall : robuste, compact, excellent pour un aimant sur arbre. Très simple à interfacer.
• Encodeur optique : haute résolution, bon pour les mesures précises de vitesse et de position.
• Encodeur magnétique : bonne résistance à la poussière, souvent plus compact.
• Interrupteur mécanique : possible pour des vitesses faibles, mais moins fiable à cause des rebonds.

Type de capteur	Résolution typique	Avantages	Limites
Capteur Hall + 1 aimant	1 impulsion par tour	Très simple, économique, fiable en environnement sale	Résolution faible, précision limitée à basse durée de mesure
Disque optique 20 fentes	20 impulsions par tour en X1	Bonne base pour mesurer tours et vitesse	Sensible à l’alignement et à la poussière
Encodeur quadrature 100 PPR	100 PPR, jusqu’à 400 comptages par tour en X4	Mesure du sens et meilleure précision	Traitement plus exigeant côté microcontrôleur
Encodeur industriel 600 PPR	600 PPR, jusqu’à 2400 comptages par tour en X4	Très haute finesse angulaire	Débit d’impulsions élevé à haute vitesse

6. Capacités réelles de quelques cartes Arduino pour cette tâche

Le comptage d’impulsions rapides dépend de la fréquence CPU, du nombre d’interruptions disponibles et de la qualité du code. Une carte peu puissante peut perdre des impulsions si vous affichez trop souvent sur le port série ou si vous exécutez des calculs lourds pendant la mesure. Voici un comparatif pratique de cartes très utilisées :

Carte	Fréquence CPU	Interruptions externes matérielles	Usage typique
Arduino Uno R3	16 MHz	2 broches d’interruption dédiées	Parfait pour un encodeur simple ou un petit moteur DC
Arduino Mega 2560	16 MHz	6 broches d’interruption dédiées	Pratique pour plusieurs moteurs ou plus d’entrées capteurs
Arduino Due	84 MHz	Nombreuses interruptions sur plus de broches	Adapté aux signaux rapides et aux traitements plus lourds
Arduino Nano Every	20 MHz	Interruptions selon configuration des broches	Format compact avec un peu plus de marge qu’un Uno

7. Méthodes de mesure : compter pendant une durée ou mesurer la période

Il existe deux grandes approches. La première consiste à compter le nombre d’impulsions pendant un intervalle fixe, par exemple 100 ms, 1 s ou 10 s. C’est simple et robuste. Plus la fenêtre est longue, plus la mesure moyenne est stable. En revanche, la réactivité diminue. La seconde approche mesure le temps entre deux impulsions, ce qui est très efficace à basse vitesse. Pour un moteur lent, attendre un grand nombre d’impulsions peut être trop long. Mesurer la période peut alors donner une valeur de vitesse plus rapidement.

Dans un projet réel, on combine souvent les deux :

• comptage sur fenêtre fixe pour les vitesses moyennes à élevées,
• mesure de période pour les très basses vitesses,
• filtrage logiciel pour lisser les variations.

8. Erreurs fréquentes qui faussent le nombre de tours

• Confondre PPR, CPR et comptage X4.
• Ne pas utiliser d’interruptions pour un signal rapide.
• Laisser des rebonds électriques sur un capteur mécanique.
• Oublier le rapport de réduction du motoréducteur.
• Calculer des tr/min sur une durée trop courte, ce qui augmente le bruit de mesure.
• Bloquer le programme avec des délais trop longs et perdre des impulsions.

9. Exemple de logique Arduino

Voici une base très simple en lecture par interruption. Elle compte les impulsions et calcule les tours toutes les secondes. Le code n’est pas un logiciel complet de production, mais il illustre la méthode standard utilisée dans de nombreux montages.

volatile unsigned long wpcPulseCount = 0;
const int wpcEncoderPin = 2;
const float wpcPPR = 20.0;

void wpcCountPulse() {
  wpcPulseCount++;
}

void setup() {
  Serial.begin(115200);
  pinMode(wpcEncoderPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(wpcEncoderPin), wpcCountPulse, RISING);
}

void loop() {
  static unsigned long wpcLastTime = 0;
  unsigned long wpcNow = millis();

  if (wpcNow - wpcLastTime >= 1000) {
    noInterrupts();
    unsigned long wpcCount = wpcPulseCount;
    wpcPulseCount = 0;
    interrupts();

    float wpcTurns = wpcCount / wpcPPR;
    float wpcRPM = wpcTurns * 60.0;

    Serial.print("Tours en 1 s : ");
    Serial.println(wpcTurns);
    Serial.print("Vitesse RPM : ");
    Serial.println(wpcRPM);

    wpcLastTime = wpcNow;
  }
}

10. Comment améliorer la précision

Pour obtenir une mesure fiable, il faut agir à la fois sur le matériel et sur le logiciel. Côté matériel, privilégiez des fils courts, un blindage si nécessaire, des masses propres et un capteur adapté à la vitesse. Côté logiciel, évitez les traitements bloquants, stockez le compteur dans une variable volatile et copiez-la proprement avant calcul. Pour les moteurs très rapides, il peut être utile d’utiliser un microcontrôleur plus performant ou une bibliothèque spécialisée pour encodeur quadrature.

La précision dépend aussi du nombre d’impulsions disponible. Plus la résolution du capteur est élevée, plus l’estimation du tour et de la vitesse sera fine. Avec un seul aimant, vous obtenez une mesure simple mais peu détaillée. Avec un encodeur 600 PPR en X4, vous atteignez jusqu’à 2400 comptages par tour, ce qui devient excellent pour l’asservissement précis.

11. Quand calculer le nombre de tours est indispensable

Le calcul du nombre de tours n’est pas seulement utile pour afficher une donnée. Il sert aussi à piloter le système. Dans un robot, connaître les tours permet d’estimer une distance parcourue. Dans une machine de dosage, on relie directement le nombre de tours à un volume distribué. Dans un système de positionnement, les impulsions mesurées deviennent la base d’une boucle PID. Plus votre conversion impulsions vers tours est juste, plus le comportement final du système sera stable et répétable.

12. Ressources d’autorité pour aller plus loin

Pour approfondir les notions de vitesse angulaire, de cinématique et de mesure, vous pouvez consulter :

• NASA.gov : introduction à la vitesse angulaire
• MIT OpenCourseWare : angular kinematics
• Penn State University : rappels utiles sur les unités

Conclusion

Avec Arduino, calculer le nombre de tour d’un moteur est à la fois simple en apparence et très sensible aux détails de mise en oeuvre. La clé est de partir d’un comptage d’impulsions propre, de connaître précisément les impulsions par tour effectives et de ne pas oublier le facteur de quadrature ainsi que le rapport de réduction. Une fois ces éléments maîtrisés, vous obtenez immédiatement le nombre de tours, l’angle parcouru et la vitesse en tr/min. Le calculateur présent sur cette page a été conçu pour transformer ces formules en résultats concrets, lisibles et directement exploitables dans vos projets embarqués, robotiques et industriels.