ULN2003A Driver Moteur Pas à pas

La carte driver ULN2003A est la pièce qui manque entre un microcontrôleur et un moteur pas à pas unipolaire. Le circuit qu’elle porte est un réseau de sept transistors Darlington : il reçoit un ordre de quelques milliampères et laisse passer plusieurs centaines de milliampères vers la charge. C’est très exactement ce que demande un bobinage de moteur, qu’aucune broche d’Arduino ne peut alimenter directement sans se détériorer.

C’est le compagnon habituel du moteur pas à pas 28BYJ-48, dont la fiche à cinq fils se clipse sur le connecteur blanc de la carte. Elle sert aussi, plus largement, à commander tout ce qui réclame plus de courant qu’une sortie logique : relais, électro-aimant, petite lampe, buzzer puissant.

Ce que la carte fait, et pourquoi elle est indispensable

Un moteur pas à pas unipolaire se commande en alimentant ses bobinages les uns après les autres. Chaque bobinage du 28BYJ-48 demande de l’ordre de 90 mA sous 5 V : dix-huit fois ce qu’une broche de microcontrôleur peut fournir sans dommage. Le ULN2003A sert d’intermédiaire : la broche de l’Arduino n’envoie qu’un signal de commande, et c’est la carte qui laisse passer le courant du moteur.

Deux détails du circuit méritent d’être connus, car ils expliquent la popularité de cette carte :

• Les diodes de roue libre sont déjà dans le circuit. Un bobinage qui s’ouvre brutalement produit une surtension qui détruit un transistor nu. Le ULN2003A les encaisse en interne — il n’y a rien à ajouter au montage.
• La sortie travaille par le négatif. Le ULN2003A relie la charge à la masse ; le pôle positif de la charge reste, lui, branché à l’alimentation. Ce détail compte dès que l’on pilote autre chose qu’un moteur (voir plus bas).

Ce que la photo montre

Le module est une carte verte à quatre trous de fixation, sur laquelle on reconnaît :

• le circuit ULN2003A en boîtier DIP à seize broches, au centre ;
• le connecteur blanc à cinq broches, sur le bord, où vient se clipser la fiche du moteur ;
• les entrées de commande repérées IN1, IN2, IN3, IN4 — la sérigraphie peut aller jusqu’à IN7, le circuit comptant sept canaux ;
• quatre LED de phase avec leurs résistances de limitation : elles s’allument à tour de rôle quand les bobinages sont alimentés, ce qui rend le séquencement visible ;
• un bornier à vis à deux pôles, repéré + et −, pour l’alimentation du moteur ;
• un cavalier à deux broches près du bornier, dont le rôle varie selon les fabricants.

Caractéristiques techniques

Le câblage des entrées

Les quatre entrées se relient aux broches de commande du microcontrôleur. L’ordre compte : il fixe l’ordre dans lequel les bobinages seront alimentés, donc la façon dont le programme désignera le sens de rotation.

N’importe quel jeu de quatre broches convient, à condition de le déclarer dans le programme : D8 à D11 laisse libres les broches 0 et 1, réservées à la liaison série. Les canaux non utilisés (IN5 à IN7 lorsqu’ils sont accessibles) ne gênent en rien le pilotage d’un moteur à quatre phases.

Mini-projet : faire tourner le 28BYJ-48 pas à pas

Le montage de mise en route. Le programme fonctionne en demi-pas : il alterne un bobinage et deux bobinages, ce qui double la finesse du déplacement et rend la rotation plus douce. Le moteur fait un tour, attend un ordre au clavier de la liaison série, puis recommence.

Ce qu’il faut

Le câblage

Le programme

À coller dans l’IDE Arduino, puis à téléverser. Ouvrez le moniteur série à 9600 bauds : taper g fait un tour dans un sens, d dans l’autre.

/*
 * Carte driver ULN2003A - moteur pas a pas unipolaire 28BYJ-48
 * Carte de developpement : Arduino Uno R3
 * Montage : la fiche du moteur se clipse sur le connecteur de la carte
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

const byte ENTREES[4] = {8, 9, 10, 11};   // IN1 a IN4 de la carte driver

// Sequence en demi-pas : huit etapes par cycle. Deux bobinages sont
// alimentes aux etapes paires, un seul aux etapes impaires.
const byte SEQUENCE[8][4] = {
  {1, 0, 0, 0},
  {1, 1, 0, 0},
  {0, 1, 0, 0},
  {0, 1, 1, 0},
  {0, 0, 1, 0},
  {0, 0, 1, 1},
  {0, 0, 0, 1},
  {1, 0, 0, 1}
};

const int DEMI_PAS_PAR_TOUR = 4096;   // un tour complet a l'arbre de sortie
const int DELAI_DEMI_PAS = 2;         // millisecondes entre deux demi-pas

int sens = 1;   // 1 : sens des aiguilles d'une montre ; -1 : sens inverse

void appliquer(byte index) {
  for (byte b = 0; b != 4; b++) {
    digitalWrite(ENTREES[b], SEQUENCE[index][b]);
  }
}

void tourComplet() {
  for (int i = 0; i != DEMI_PAS_PAR_TOUR; i++) {
    byte index = i % 8;
    if (sens != 1) {
      index = 7 - index;        // parcourt la table a l'envers
    }
    appliquer(index);
    delay(DELAI_DEMI_PAS);
  }
}

void setup() {
  for (byte b = 0; b != 4; b++) {
    pinMode(ENTREES[b], OUTPUT);
  }
  Serial.begin(9600);
  Serial.println("Pret : g pour un sens, d pour l'autre");
}

void loop() {
  if (Serial.available() != 0) {
    int touche = Serial.read();
    if (touche == 'g') {
      sens = 1;
    }
    if (touche == 'd') {
      sens = -1;
    }
    tourComplet();
    Serial.println("Un tour termine");
  }
}

Comment ça marche

• La table des phases est le cœur du programme. Chaque ligne décrit l’état des quatre entrées à un instant donné. Lire les lignes dans l’ordre fait avancer le moteur ; les lire à l’envers le fait reculer. Aucun câblage n’est à modifier pour changer de sens.
• Le demi-pas double la résolution. En pas complet, un tour à l’arbre de sortie demande 2048 pas ; en demi-pas, 4096. Le déplacement élémentaire passe ainsi d’environ 0,18° à environ 0,09°.
• Le délai règle la vitesse et rien d’autre. À 2 ms par demi-pas, un tour prend environ huit secondes. Descendez vers 1 ms pour accélérer : en dessous, le rotor n’a plus le temps de suivre et se contente de vibrer.
• Le moteur reste tenu entre deux mouvements. Les bobinages demeurent alimentés et maintiennent la position, même si une force extérieure pousse l’axe. C’est ce qui distingue ce moteur d’un moteur continu.
• Les LED de la carte suivent le programme. À l’arrêt, deux LED allumées signalent une étape à deux bobinages ; une seule LED, une étape intermédiaire. Elles servent aussi de diagnostic : si elles clignotent dans l’ordre sans que le moteur tourne, la commande est bonne et le problème est côté alimentation.

Variante : alimenter le moteur par le bornier

Sur un montage d’essai, les 5 V de l’Arduino suffisent. Dès que le moteur tourne longtemps, ou que deux moteurs sont branchés, il vaut mieux nourrir les bobinages par le bornier, avec une alimentation 5 V 2 A : le régulateur de la carte Arduino chauffe, et la tension finit par s’effondrer au point de faire redémarrer le microcontrôleur en pleine rotation.

Dans cette configuration, le + de l’alimentation va sur le + du bornier, le − sur la masse, et la masse de l’alimentation doit être reliée à celle de l’Arduino. Sans ce fil commun, les signaux de commande n’ont plus de référence et le moteur reste immobile — c’est l’erreur la plus fréquente de ce montage.

Piloter autre chose qu’un moteur

Les sept canaux du circuit ne servent pas qu’aux moteurs pas à pas. Chacun peut commuter une charge qui demande plus de courant qu’une broche logique : un relais 5 V, un électro-aimant, une électrovanne, un buzzer puissant, une guirlande de LED. Le relais seul ne se branche pas non plus directement sur un microcontrôleur : sa bobine demande le même courant qu’un bobinage de moteur, pour la même raison.

Deux règles pour ces usages : la charge se branche entre son alimentation et une sortie du ULN2003A — c’est la carte qui met la charge à la masse, jamais l’inverse — et le courant demandé par la charge doit rester dans les limites d’un canal, de l’ordre de 500 mA.

Points d’attention

• Mesurez avant de brancher le moteur. La sérigraphie et la position des repères varient d’un fabricant à l’autre. Repérez les broches par leur nom, pas par leur place, vérifiez au multimètre la tension entre le + et le − du bornier — 5 V pour un 28BYJ-48 — et laissez le cavalier dans la position où la carte est livrée.
• N’appliquez jamais 12 V à un moteur prévu pour 5 V. Le bornier et le circuit tolèrent des tensions bien plus élevées que le moteur de ce montage : c’est le moteur qui cuit, pas la carte.
• Ne branchez jamais le moteur directement sur l’Arduino, même « juste pour voir ». Chaque phase absorbe de l’ordre de 90 mA, très au-delà de ce qu’une broche supporte sans se détériorer.
• Ne forcez jamais l’axe du moteur à la main. Le réducteur interne est en plastique : un tour forcé casse des dents et rend le moteur irréparable.
• Un moteur tiède est normal puisque les bobinages restent alimentés en position. Une carte qui devient franchement chaude, en revanche, signale un courant trop élevé pour le canal sollicité.
• Aucun retour de position. Le programme sait combien de pas il a envoyés, jamais où se trouve réellement l’axe. Si la position compte, prévoyez un mouvement de référence au démarrage et une butée ou un capteur.
• Gardez une masse commune entre la carte, le microcontrôleur et l’alimentation du moteur.

Questions fréquentes

Le moteur vibre mais ne tourne pas

Trois causes, dans l’ordre de fréquence : le fil commun du moteur n’arrive pas au + de l’alimentation (sans lui, chaque phase est alimentée sans référence) ; l’alimentation du bornier n’est pas branchée ; les masses de l’Arduino et de l’alimentation ne sont pas reliées. Vérifiez aussi que les quatre entrées IN1 à IN4 occupent chacune une broche distincte.

Comment inverser le sens de rotation ?

Dans le programme. Inversez l’ordre des lignes de la table, ou parcourez-la à l’envers comme le fait l’exemple ci-dessus avec sa variable sens. Rien à débrancher : inverser deux fils du moteur ne ferait que rebrancher un bobinage à la place d’un autre.

Peut-on commander un moteur pas à pas plus gros ?

Pas par cette carte. Au-delà de quelques centaines de milliampères par phase, il faut un driver à régulation de courant, qui limite lui-même l’intensité : un driver A4988 convient à un moteur bipolaire, comme un Nema 17. Le ULN2003A reste le bon choix pour les petits moteurs unipolaires à cinq fils.

Pourquoi les bobinages sifflent-ils ou tintent-ils ?

Les phases sont commutées plusieurs centaines de fois par seconde : le léger sifflement vient des vibrations de la mécanique à cette cadence. Il s’atténue en passant au demi-pas, qui rend la rotation plus régulière.

La carte peut-elle piloter huit charges ?

Non, sept au maximum : le circuit compte sept canaux. Attention également au total, chaque canal ayant sa propre limite de courant — sept relais en même temps ne sollicitent pas la carte comme un seul.

À combiner avec

La carte est vendue seule, sans moteur. Si vous prenez les deux ensemble, le pack 28BYJ-48 avec son driver ULN2003A est la formule la plus directe. Pour démarrer de zéro, le kit Arduino Uno starter apporte la carte de développement et les câbles de liaison — il ne restera qu’à y ajouter le moteur et son driver. Et si votre mécanisme réclame franchement plus de couple, passez au moteur Nema 17 avec un driver à régulation de courant.