N20 Encoder Gearmotor

Présentation

Le N20 est le petit moteur à réducteur métal qu’on trouve partout où un robot a besoin de vrai couple dans très peu de place. Le moteur nu fait environ la taille d’une pile AA ; le réducteur à l’avant échange sa très haute vitesse contre du couple utilisable, et sur la version à codeur un disque magnétique sur l’arbre arrière rapporte de combien il a tourné.

Cette dernière partie lui vaut sa place dans un robot équilibriste. Sans retour de roue, un robot équilibriste peut rester debout mais n’a aucune idée d’où il est — il tiendra la verticale magnifiquement tout en errant dans la pièce. Le codeur comble cet écart.

Pourquoi le réducteur métal compte ici

Un moteur à réducteur plastique comme le motoréducteur TT convient parfaitement à un suiveur de ligne, qui roule surtout en avant. Un robot équilibriste est une autre charge : il inverse le sens en continu, des centaines de fois par seconde, par petits incréments.

Tout réducteur a du jeu — une petite zone morte où les engrenages se sont désengagés et la sortie ne bouge pas jusqu’à ce que les dents se retrouvent de l’autre côté. Dans un réducteur plastique, cette zone morte est large, et dans un robot équilibriste elle tombe exactement où la correction compte le plus : à l’instant de l’inversion, quand le robot a besoin que les roues répondent maintenant. Le résultat est un robot qui oscille autour de la verticale sans jamais se stabiliser, aussi soigneusement que les gains soient réglés.

Les engrenages métal ne suppriment pas le jeu mais le réduisent assez pour que la boucle fasse son travail. Ce qu’il en reste est un nombre mesurable en dix minutes — voici comment.

Lire le codeur

Le codeur produit deux signaux carrés déphasés de 90° — de la quadrature standard. La relation de phase donne le sens ; compter les fronts donne la distance.

Les couleurs de fils varient selon les fournisseurs, donc vérifiez l’annonce plutôt que supposer. Le piège classique est d’alimenter le codeur depuis le rail moteur : le codeur veut une alimentation logique propre, et l’alimenter en tension moteur le détruira ou remplira vos comptes de bruit à chaque commutation du moteur.

Mettez la voie A sur une broche capable de lever une interruption. Scruter un codeur depuis loop() sur un robot équilibriste perdra des pas, et des pas perdus signifient que la boucle externe perd lentement la trace d’où est le robot.

Choisir un rapport

Le rapport de réduction règle l’échange entre couple et vitesse, et un robot équilibriste a besoin des deux :

• Rapport trop élevé (1:250 et plus) donne plein de couple mais les roues ne peuvent pas tourner assez vite pour repasser sous un corps qui tombe.
• Rapport trop bas (1:30 et moins) tourne vite mais ne peut pas déplacer la masse du robot avec autorité.

Autour de 1:100 à 12 V — environ 200 tr/min — est un point de départ fiable pour un petit robot. Si le vôtre rattrape les petites perturbations mais perd les grandes, il faut probablement plus de vitesse, pas plus de gain.

Le piloter

Associez le N20 à un TB6612FNG plutôt qu’un L298N. La raison est la perte : le L298N perd environ 2 V sur son étage de sortie, donc une grande part de votre batterie n’atteint jamais le moteur, et les petites consignes de correction tombent sous la tension à laquelle le moteur bouge. Sur un robot équilibriste, cette zone morte est juste là où vivent les corrections fines.

Alimentez-le depuis un pack de batteries capable de fournir le courant de blocage des deux moteurs à la fois sans que sa tension s’affaisse — un rail qui s’affaisse réinitialise le microcontrôleur en pleine correction, et le robot tombe pour des raisons sans rapport avec votre boucle de commande.

Calculer les pas par tour de roue

C’est le nombre dont dépend tout calcul de distance, et celui qu’on se trompe le plus souvent — généralement d’un facteur quatre.

counts per wheel revolution = PPR x 4 x gear ratio

Le codeur magnétique donne 7 impulsions par tour moteur sur chaque voie. La quadrature signifie deux voies à 90°, ce qui produit quatre fronts comptables par cycle d’impulsion. Et le réducteur signifie que le moteur tourne de nombreuses fois par tour de roue.

La distance suit ensuite directement :

mm per count = (pi x wheel_diameter_mm) / counts_per_revolution

Deux pièges vivent dans cette première formule. Le ×4 n’est correct que si vous comptez réellement quatre fronts — les deux fronts sur les deux voies. Beaucoup d’exemples comptent seulement les fronts montants de la voie A, soit ×1, et utiliser une constante ×4 avec un comptage ×1 fausse toute distance d’exactement quatre. Et le rapport imprimé sur le moteur est souvent approximatif : un N20 « 1:100 » fait souvent 1:99,5 ou 1:100,37. Pour l’odométrie sur toute distance, étalonnez empiriquement : poussez le robot sur exactement 2 m et divisez.

Compter les fronts sans en perdre

À 200 tr/min avec un réducteur 1:100, l’arbre moteur tourne à 20 000 tr/min, donnant 20000/60 × 7 × 4 ≈ 9300 fronts par seconde par moteur. Deux moteurs font près de 19 000 interruptions par seconde, et c’est à pleine vitesse sans charge.

Le gestionnaire d’interruption doit être vraiment petit :

volatile long countL = 0;

// Full x4 decoding, table-driven. Both channels, both edges.
const int8_t QUAD_TABLE[16] = {0,-1,1,0, 1,0,0,-1, -1,0,0,1, 0,1,-1,0};
volatile uint8_t prevL = 0;

void isrLeft() {
  uint8_t now = (digitalRead(ENC_L_A) << 1) | digitalRead(ENC_L_B);
  countL += QUAD_TABLE[(prevL << 2) | now];
  prevL = now;
}

void setup() {
  pinMode(ENC_L_A, INPUT_PULLUP);
  pinMode(ENC_L_B, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(ENC_L_A), isrLeft, CHANGE);
  attachInterrupt(digitalPinToInterrupt(ENC_L_B), isrLeft, CHANGE);
}

long readCount() {           // long is not atomic on an 8-bit AVR
  noInterrupts();
  long v = countL;
  interrupts();
  return v;
}

Trois détails qui comptent :

volatile, et une lecture atomique. Un long fait quatre octets sur AVR, lus un octet à la fois. Une interruption tombant en pleine lecture donne une valeur moitié ancienne moitié nouvelle — ce qui produit un énorme saut occasionnel dans votre odométrie, au hasard, environ une fois toutes les quelques milliers de lectures.

La table de correspondance décode la transition plutôt que deviner le sens depuis une voie. Elle rejette aussi naturellement les transitions invalides (les deux bits changeant d’un coup, ce qui signifie qu’on en a manqué une) en apportant zéro.

Pression sur les broches. Un décodage ×4 complet sur deux moteurs veut quatre broches capables d’interruptions, et un Arduino Uno en a exactement deux. Les options : utiliser un décodage ×2 (une voie par moteur, CHANGE), qui divise la résolution par deux tout en gardant le sens ; passer à une carte avec plus de broches d’interruption comme un Mega ou un ESP32 ; ou utiliser des interruptions sur changement de broche, que toute broche AVR prend en charge mais qui exigent de gérer tout un port d’un coup.

La vitesse depuis les pas

La position est un compte. La vitesse veut une différence dans le temps, et la façon de la prendre décide si votre boucle de commande est utilisable.

long lastCount = 0;
unsigned long lastMicros = 0;

float speedMmPerSec() {
  long   c  = readCount();
  unsigned long t = micros();

  float dt = (t - lastMicros) * 1e-6f;
  if (dt < 0.005f) return lastSpeed;        // too short: quantisation dominates

  float mm = (c - lastCount) * MM_PER_COUNT;
  lastCount = c; lastMicros = t;

  lastSpeed = mm / dt;
  return lastSpeed;
}

Le garde dt est la ligne importante. Échantillonnez trop vite et vous divisez une différence d’un ou deux pas par un minuscule intervalle, donc l’erreur de quantification domine et la « vitesse » est surtout du bruit — qu’un terme dérivé dans une boucle PID amplifiera ensuite avec enthousiasme.

Il y a deux façons honnêtes de mesurer la vitesse depuis un codeur, adaptées aux extrémités opposées de la gamme. Compter les fronts dans une fenêtre fixe (le code ci-dessus) est bon à haute vitesse et mauvais à basse vitesse, où peu de fronts arrivent par fenêtre. Chronométrer l’intervalle entre fronts est l’inverse : excellent à basse vitesse, bruité à haute vitesse. Un robot qui a besoin des deux bouts bascule généralement entre eux à un seuil.

Dépannage

N20 ou motoréducteur TT ?

Le facteur décisif est rarement le couple et presque toujours le jeu et la rétroaction. Un suiveur de ligne roule surtout en avant et braque par un capteur qui regarde le sol — il ne remarque jamais le jeu du réducteur, et un moteur TT est la bonne réponse économique. Un robot équilibriste inverse le sens des centaines de fois par seconde par minuscules incréments, donc la zone morte à chaque inversion est exactement là où sa correction doit agir, et les engrenages plastique rendent la boucle instable quel que soit le réglage.

La même logique vaut pour un solveur de labyrinthe : il navigue en comptant la distance, donc le mouvement perdu à chaque virage s’accumule directement en erreur de position.

Utilisé dans

• Robot auto-équilibré — les moteurs d’entraînement, avec les codeurs alimentant la boucle de position externe