ModelleisenbahN

La carte de commande de pont tournant version Arduino (2)

Jean-Luc — 2014-02-06T19:40:00Z

Le montage de la motorisation sous le pont est atypique. En effet, au lieu de séparer la partie mécanique de la partie électronique, j'ai choisi d'utiliser la carte électronique comme support du moteur. Une plaque époxy de 1,6mm d'épaisseur a une rigidité suffisante pour supporter le poids du moteur et comme on le verra dans l'article suivant, la hauteur du pont est réglable.

La carte doit s'inscrire dans le cercle du pont tournant PECO NB-55. Le diamètre externe de la fosse est de 154mm. La dimension choisie est de 132mm x 80mm, ce qui correspond à une diagonale de 154mm en limant un peu les coins. Ces dimensions permettent de placer un Arduino Nano entre le petit côté et le moteur pas-à-pas ou bien, pour la version PIC + CAN pour mon réseau, un PIC en boîtier DIP 28 broches comme le 18F26K80 et le transcepteur CAN. Elle permet aussi d'utiliser une roue codeuse de grand diamètre sans placer les capteurs sur une diagonale.

Implantation des composants

Vu côté composants, avec l'alimentation et la DRV8824 en haut et l'Arduino Nano en bas, la partie commande et l'alimentation sont placées à gauche, la partie relais pour l'alimentation traction et les capteurs de position sont placés à droite.

Carte vue côté composants et Arduino

Lors du montage du prototype, il est apparu que le connecteur d'alimentation de la DRV8824, en haut à gauche sur la photo, était mal placé. En effet, la prise qui vient se brancher dans le connecteur dépasse un peu côté cuivre et gêne le mouvement de la roue. Une pièce d'époxy de 1mm d'épaisseur vient donc s'insérer sous le connecteur sur la carte prototype. Dans la version définitive, le connecteur sera déplacé sur le petit côté de manière à ne pas gêner la rotation de la roue codeuse.

Supports de la DRV8824 et de l'Arduino Nano

Les deux modules sont montés sur des barrettes à broche femelle. L'espacement entre la carte et les modules est assez important, presque 10mm, et permet de monter des composants sous les modules. Cette caractéristique est assez peu exploitée sur la carte prototype mais pourrait permettre une conception plus compacte en implantant les transistors de commande des relais et des capteurs ainsi que les résistances sous l'Arduino Nano.

Carte vue côté composants et DRV8824

Les capteurs IR par reflexion

Les capteurs sont les OMRON EE-SY193 déjà présentés. Ces capteurs sont en boîtier CMS et soudés côté cuivre. Contrairement à des composants ordinaires qui peuvent être soudés un peu n'importe comment pourvu qu'électriquement tout soit correct, ces capteurs doivent être soudés à leur emplacement précis afin d'être bien alignés au centre des zones noires et blanches de la roue codeuse.

Carte vue côté cuivre

La technique pour souder correctement et rapidement ces composants consiste à les coller à la colle en bombe sur une barre de largeur équivalente à celle du EE-SY193. En l'occurrence, une barre en laiton 3mm x 2mm a été utilisée. L'empreinte des composant est imprimée sur une feuille et collée sur la barre. La barre est ensuite passée à la colle en bombe puis les composants sont disposés à la brucelle.

Positionnement des capteurs sur leurs empreintes

Il suffit ensuite de retourner et positionner l'ensemble sur la carte et de le maintenir avec une pince. Les deux mains restent libres pour les soudures.

Positionnement de l'ensemble sur la carte en vue du soudage

Soudage des capteurs

Les premier essais ont montré un fonctionnement tout à fait satisfaisant de la commande du moteur. Notamment, le moteur ne rayonne pas au point de perturber l'électronique. La résistance en série avec les LED IR des capteurs ayant été mal calculée (180Ω au lieu des 90Ω indiqués dans « La carte de commande de pont tournant version Arduino (1) »), le niveau bas, obtenu pour les zones blanches, était insuffisant car le faisceau IR incident était trop faible et engendrait parfois des lectures erronées. La qualité de réalisation de la première roue codeuse était également insuffisante [1]. Le remplacement de la résistance de 180Ω en série avec les LED IR par une résistance de 100Ω a résolu les problèmes de niveau bas.

Le prochain article traitera du montage de la motorisation sous le pont tournant.

[1] Ce point sera traité dans le prochain article

La carte de commande de pont tournant version Arduino (1)

Jean-Luc — 2014-01-22T18:21:20Z

Comme indiqué dans « Une carte Arduino pour le pilotage du pont tournant », j'ai conçu deux cartes de pilotage du pont tournant. La première, qui est décrite ici, intègre un Arduino Nano et une DRV8824 et est destiné à une commande manuelle. Par manuelle, j'entends que l'utilisateur, après avoir programmé quelles sont les positions correspondant à une voie, utilise des poussoirs pour demander l'alignement avec la voie correspondante.

L'alimentation

La carte est alimentée en 12V continu. Le courant nécessaire ne dépasse pas les 500mA. On trouve facilement de petites alimentations industrielles à découpage pour une quinzaine d'Euros.

Cette tension passe par une diode de protection. Cette diode, une 1N4007, évite de détruire l'électronique par un branchement inversé de l'alimentation.

On trouve ensuite le schéma classique des composants autour du régulateur 7805 : deux condensateurs, un électrochimique de 470µF destiner à filtrer les basses fréquences et notamment le pic de la mise sous tension et un polyester de 100nF destiné à filtrer les hautes fréquences. Le 7805 lui même qui, à partir du 12V rectifié, fabrique le 5V d'alimentation de l'Arduino Nano et des LED témoin. Enfin, deux condensateurs en sortie, un électrochimique de 47µF pour le filtrage basse fréquence du 5V et l'autre de 100nF pour le filtrage haute fréquence.

On peut noter que sur le schéma, le boîtier du moteur pas-à-pas qui est fixé à la carte est relié à la masse pour constituer une cage de Faraday et limiter l'émission de rayonnement électromagnétique issu du moteur.

Alimentation de la carte

La tension de 12V, rectifiée par la diode et appelée VMOT, sert directement pour l'alimentation moteur de la DRV8824, pour l'alimentation des bobines de 2 relais donc la fonction est décrite plus loin et pour l'alimentation des diodes IR des capteurs. Cette diode engendre une chute de tension de 1V. VMOT est donc de 11V et il faut en tenir compte. Ce n'est pas un problème pour les relais qui collent à partir de 9,6V maximum ou pour le moteur pas-à-pas car avec les courants employés, environ la moitié de ce que consomme le moteur sous 12V, il y a de la marge. Par contre, le calcul du courant dans les diodes IR doit être effectivement fait avec une alimentation de 11V.

L'intégration de la DRV8824

Le montage est repris de l'expérimentation sur breadboard. Les broches qui nous intéressent sont le RST (reset) qui permet d'initialiser la DRV8824 par programme, DIR qui permet de fixer la direction de rotation, STEP qui permet de franchir un micropas à chaque transition de l'état bas à l'état haut et FAULT qui permettra au programme de diagnostiquer un problème sur la DRV8824. SLP est fixé à 5V pour que la DRV8824 ne soit jamais endormie, EN est laissé en l'air pour la même raison. Les broches M0, M1 et M2 sont reliées à 5V via un DIP-switch. Ceci n'est pas très utile car le mode 32µPas sera toujours sélectionné mais j'avais des DIP-switch 3 interrupteurs en stock. Le rôle de chacune de ces broches est décrit plus précisément dans l'article sur de la DRV8824.

Schéma d'intégration de la DRV8824

L'intégration de l'Arduino Nano v3.0

L'Arduino Nano v3.0 est une des incarnations de la famille Arduino. Il est équipé du micro-contrôleur AT-Mega 328. Il s'agit en fait d'une breakout board de 30 broches permettant le montage sur une breadboard mais aussi sur un support. C'est donc un bon choix pour intégrer un Arduino sur une carte de votre conception. Le Nano dispose de 14 entrées/sorties numériques et de 8 entrées analogiques dont 6 peuvent être aussi utilisées en entrées/sorties numériques. Il dispose également d'une prise mini-USB pour le téléversement et la console. Il peut être alimenté via l'USB, via son entrée VIN et son régulateur intégré ou via l'entrée 5V [1]. J'ai choisi de l'alimenter via le 5V et de laisser VIN en l'air.

Schéma d'intégration de l'Arduino Nano v3

TON et REVERSE sont les commandes des relais, STEP et DIR permettent de piloter le moteur pas-à-pas, RESET_DRV permet de faire une remise à 0 du DRV8824, FAULT permet de détecter d'éventuelles erreurs sur ce même DRV8824, ENABLE_C active les capteurs de positions, enfin, b0 à b6 sont les 6 bits lus des capteurs de position.

Les capteurs de position

Il s'agit du capteur OMRON EE-SY193 déjà présenté. Les LED IR des capteurs sont placés en série. La tension de seuil typique avec un courant de 25mA est d'environ 1,25V. 7 capteurs en série donne donc une tension de seuil totale de 8,75V. Par conséquent, sous 11V, la résistance de limitation du courant doit avoir une valeur de (11 - 8,75V) / 25mA = 90Ω.

Les LED IR des capteurs ne sont pas alimentées en permanence mais mises sous tension par programme. Ceci permet d'augmenter la durée de vie du capteur qui n'est utilisé que rarement [2]. À cet effet, un transistor NPN est mis en série avec les LED IR et sa base est attaquée par la sortie D8 de l'Arduino au travers d'un résistance de 10kΩ.

Les phototransistors sont montés en émetteur commun. L'émetteur est à la masse et le collecteur est tiré à 5V par une résistance de 3,3kΩ établissant un niveau haut au niveau du collecteur lorsque la surface en vis-à-vis du capteur est noire. Lorsque le phototransistor est passant de par la présence d'une surface blanche, le collecteur est au niveau bas.

Schéma du capteur de position

Les relais d'alimentation traction et d'inversion de marche

On se place dans le cas d'un réseau analogique. Par sécurité, on peut souhaiter couper l'alimentation traction lorsque le pont n'est pas aligné sur une des voies de sortie. À cet effet, un relai DPDT est intercalé entre l'alimentation du pont et l'alimentation traction. D'autre part, le pont peut aussi opérer une inversion de marche lors du passage d'une position à une autre. Un second relai DPDT permet de décider du sens de marche. Une inversion de marche mécanique est prévue sur le pont PECO NB-55 mais peut s'avérer peu pratique.

Schéma des relais traction

La commande de ces relais est classique. Un transistor permet de commander le relai et une diode roue libre absorbe le courant résiduel de la bobine du relai. Les résistances 47kΩ assurent que le transistor reste bloqué à la mise sous tension alors que le micro-contrôleur ne pilote pas encore les bases des transistors.

[1] qui peut être une sortie si VIN est utilisé

[2] Si on considère qu'il faut moins d'une milliseconde pour lire les capteurs, que le temps minimum entre deux lectures est le temps nécessaire pour avancer de 128µPas, soit plus de 2,3s, les capteurs ne sont utilisés que 1/2300e du temps

Une carte Arduino pour le pilotage du pont tournant

Jean-Luc — 2014-01-18T11:26:20Z

Comme le prototypage pour le pilotage du pont tournant a été fait avec un Arduino, j'ai décidé de faire 2 cartes de pilotage. Une première intégrant un Arduino Nano [1] et une DRV8824 et une seconde intégrant un PIC 18F26K80 et la même DRV8824. La première carte servira de carte de développement des algorithmes et de matériel pédagogique pour les Arduino. Elle sera commandée via des poussoirs. Quand elle me sera devenue inutile, il est possible que je la vende. La seconde sera intégrée sur mon réseau, permettant ainsi de piloter le pont via le bus CAN des accessoires.

La carte est tirée et il me reste à percer les trous pour placer et souder les composants. J'ai eu un petit soucis de gravure, j'utilise deux transparents superposés qui malheureusement se sont mal superposés sur cette insolation [2], mais j'ai pu récupérer les pistes collées avec un couteau de modéliste. Ce n'est pas très joli mais l'isolation électrique est bonne.

Un article de description de cette carte suivra, bien entendu.

[1] L'Arduino Uno est trop grand pour se loger sous un pont tournant en N à côté du moteur pas-à-pas. L'Arduino Nano choisi est fabriqué par Funduino, (voir le produit sur dx.com). La version officielle de Gravitech est hors de prix.

[2] Il est préférable d'utiliser des transparents polyester qui ne se déforment pas à la chaleur de l'imprimante laser

L'algorithme de rotation du pont tournant

Jean-Luc — 2014-01-01T12:12:33Z

Après avoir présenté le matériel nécessaire au pilotage du moteur pas-à-pas par µPas et le choix de la DRV8824 de Pololu pour sa meilleure résolution et la fluidité de mouvement qui en résulte, il est temps de se pencher sur l'algorithme qui permet de décider du sens de rotation et de la décomposition du mouvement en phase d'accélération, en régime permanent et en phase de décélération.

Calcul du sens de rotation pour le plus court chemin

Le pont est bien évidemment orienté. C'est à dire que les positions p et p+180° sont différentes. Avec la DRV8824, nous avons 12800 positions possibles que nous allons numéroter de 0 à 12799. Partant de la position courante, le pont devant aller dans une nouvelle position, il faut décider dans quel sens tourner pour minimiser la distance parcourue. C'est à dire que partant de la position courante 12799 et allant à la position 0, il n'y a qu'un µPas à effectuer et non 12799.

On va distinguer deux cas :

La position à atteindre à un numéro > à la position courante ;
La position à atteindre à un numéro < à la position courante.

Par convention, on va également décider qu'un déplacement positif se fait dans le sens horaire et un déplacement négatif dans le sens trigonométrique.

La position à atteindre à un numéro supérieur à la position courante

Ce cas correspond à la figure ci-dessous :

chemin 1 se calcule en soustrayant la position courante à la position destination : chemin 1 = position destination — positition courante.
Il est bien positif, la rotation pour parcourir chemin 1 se fait dans le sens horaire.

chemin 2 doit être négatif puisque la rotation de fait dans le sens trigonométrique et il se décompose en deux : d'une part la portion entre la position courante et 0 et d'autre part la portion entre 12800 et la position destination.
On a donc chemin 2 = — (positition courante + 12800 — position destination)

La position à atteindre à un numéro inférieur à la position courante

Ce cas correspond à la figure ci-dessous :

chemin 1 se calcule également en soustrayant la position courante à la position destination : chemin 1 = position destination — positition courante.
Comme la position courante est plus grande que la position destination, il est bien négatif, la rotation pour parcourir chemin 1 se fait dans le sens trigonométrique.

chemin 2 doit être positif et se décompose en deux : d'une part la portion entre la position courante et 12800 et d'autre part la portion entre 0 et la position destination.
On a donc chemin 2 = 12800 — positition courante + position destination.

Pour choisir le chemin, il suffit de comparer les valeurs absolues de chemin 1 et chemin 2 et de choisir le chemin ayant la plus petite. Le signe du chemin donne le sens de rotation.

Le code correspondant est le suivant :

int chemin1 = positionDestination - positionCourante; int chemin2; if (positionDestination > positionCourante) chemin2 = - (positionCourante + 12800 - positionDestination); else chemin2 = 12800 - positionCourante + positionDestination; int chemin; int dir; if (abs(chemin1) > abs(chemin2)) chemin = chemin2; else chemin = chemin1; /* Si chemin < 0, la direction est mise à 1 */ if (chemin < 0) dir = HIGH; else dir = LOW;

Le nombre de µPas à parcourir sera mis dans une variable distance calculée comme suit : distance = abs(chemin);.

Vitesse de rotation, accélération et décélération

La vitesse de rotation d'un pont tournant est assez faible. On peut par exemple voir dans cette vidéo qu'il faut environ 2 minutes (entre 45" et 2'45") pour que la 141TD 740 fasse son demi-tour, ce qui donne 4 minutes pour un tour.

La 141TD 740 s'engage sur le pont tournant et fait un demi-tour

Dans notre cas, il faut donc passer 12800 µPas en 4 minutes soit 240s, ce qui donne un délai de 18 à 19ms entre deux µPas. Pour clarifier le code, ce délai va être mis dans une variable delaiInterMicropas, ce qui permettra aussi de changer la vitesse de rotation sans avoir à modifier le code.

Si on ne se soucie pas d'avoir des phases d'accélération et de décélération, le code est très simple :

for (microPas = 0; microPas < distance; microPas++) { digitalWrite(stepPin, LOW); delay(1); digitalWrite(stepPin, HIGH); delay(delaiInterMicroPas - 1); }

Mais le mouvement a une allure artificielle. Il est donc préférable de simuler une petite phase d'accélération et de décélération.

Les phases d'accélération vont être réglées en nombre de µPas passés à accélérer et à décélérer. On va donc avoir 2 variables microPasAcceleration et microPasDeceleration pour régler ces phases.

Un mouvement d'une position courante à une position de destination consiste donc à parcourir microPasAcceleration µPas avec un délai variable et décroissant puis à parcourir distance - microPasAcceleration - microPasDeceleration µPas avec un délai delaiInterMicropas et enfin parcourir microPasDeceleration µPas avec un délai variable croissant.

Bien entendu, il ne faut pas que microPasAcceleration + microPasDeceleration soit supérieur à distance. En pratique les phases d'accélération et de décélération seront courte et la distance est supérieur à l'écartement de la voie utilisée. Par exemple pour un pont en N de 150mm de diamètre, les 9mm d'écartement correspondent à 245 µPas.

Le délai initial de la phase d'accélération est calculé est ajoutant microPasAcceleration à delaiInterMicropas. On va ensuite boucler microPasAcceleration fois en diminuant le délai de 1 à chaque tour pour donc terminer sur un délai égal à delaiInterMicropas. Comme ceci :

int delai = delaiInterMicroPas - 1 + microPasAcceleration; for (microPas = 0; microPas < microPasAcceleration; microPas++) { digitalWrite(stepPin, LOW); delay(1); digitalWrite(stepPin, HIGH); delay(delai); delai-- ; }

Le mouvement a vitesse maximum est accompli par la boucle suivante :

for (microPas = 0; microPas < (distance - microPasAcceleration - microPasDeceleration); microPas++) { digitalWrite(stepPin, LOW); delay(1); digitalWrite(stepPin, HIGH); delay(delaiInterMicroPas - 1); }

Enfin, la phase de décélération consiste à boucler microPasDeceleration fois en augmentant le délai de 1 à chaque tour, delai est initialisé à la valeur delaiInterMicropas. Comme ceci :

for (microPas = 0; microPas < microPasDeceleration; microPas++) { digitalWrite(stepPin, LOW); delay(1); digitalWrite(stepPin, HIGH); delay(delai); delai ++; }

Tout cela est mis dans une fonction allerAPosition(...).

Sketch de démonstration

Voici le câblage :

Et le sketch de l'application de démonstration. Il contient la fonction allerAPosition(...) et l'exécution d'un scénario de mouvement.

Sketch de démonstration du pont tournant

Mise en œuvre de la DRV8824 pour un pont tournant

Jean-Luc — 2013-12-24T10:05:34Z

Pour les essais de la DRV8824, le moteur reste le même que celui employé dans « Mise en œuvre de l'EasyDriver v4.4 pour un pont tournant » avec 400 pas par tour. La latte de bois a été remplacée par un tasseau d'un longueur un peu plus faible dans le but de pouvoir charger le pont avec une masse équivalente à celle d'une locomotive en H0 [1] afin d'observer le comportement en charge.

Les possibilités offertes par la DRV8824

En combinant les 400 pas par tour du moteur et les 32µPas du Ti DRV8824, on arrive à 12800 µPas par tour ce qui est considérable. Pour un pont tournant à l'échelle H0, disons de 30cm de diamètre, cela donne un déplacement de moins de 0,075mm par µPas en bout de pont. Avec un pont à l'échelle N on tombe à 0,037mm en bout de pont. Un déplacement de moins d'1/10e de millimètre est imperceptible.

La connexion de la DRV8824 est presque aussi simple que celle de l'EasyDriver, il y a juste quelques broches supplémentaires à connecter à la masse ou au +5V car l'état par défaut qu'elles adoptent lorsqu'elles sont en l'air ne convient pas.

Il faut donc connecter les broches DIR et STEP comme pour l'EasyDriver mais en plus connecter la broche SLEEP à 5V, la broche ENABLE à 0V et les broches M0, M1 et M2 à 5V pour disposer de 32 µPas. J'ai choisi de piloter la broche RESET avec la broche 4 de l'Arduino. En effet, à l'allumage du système, les entrées/sorties numériques de l'Arduino étant en entrée, RESET est en l'air et, par conséquent, le Ti DRV8824 est maintenu dans l'état RESET. Cela évite de faire faire au moteur des mouvements involontaires dus aux transitoires sur les entrées DIR et STEP. Lorsque le programme démarre, la broche 4 est mise en sortie et RESET est mis à l'état haut après que les états de DIR et STEP aient été fixés. De cette manière le moteur ne bronche pas à la mise sous tension.

Un autre point important est le condensateur chimique qui permet d'absorber les transitoires de la mise sous tension. Transitoires qui pourraient détruire le composant. J'ai donc implanté sur la breadboard un condensateur de 470µF 35V.

La tension moteur est fixée à 12V. Les alimentations sont séparées comme pour le montage de l'EasyDriver.

Réglages de la DRV8824

Le potentiomètre de montage sur la DRV8824 permet de régler la tension V_ref qui fixe le courant maximum. Comme V_ref = I_max ×5R_s, avec R_s = 0,33Ω, un I_max ≤ 300mA donne un V_ref ≤ 0,5V. En tâtonnant, une valeur de 0,47V donne le meilleur comportement [2].

Voici le résultat obtenu avec ce réglage.

La plus haute résolution du Ti DRV8824 par rapport à l'Allegro A3967 qui équipe l'EasyDriver donne un bien meilleur résultat mais ce n'est pas encore parfait.

Deux pistes d'amélioration existent. La première concerne le V_ref. En effet, la valeur de V_ref nécessaire pour le moteur choisi est en deçà de ce qui est préconisé par Texas Instruments mais augmenter V_ref demanderait de remplacer les résistance de capture de courant de 0,33Ω pas des résistances de 2,2Ω. De cette manière le V_ref maximum de 3,3V correspondrait à un courant maximum de 300mA.

Se lancer dans cette modification est un peu risqué et une autre piste a été privilégiée : le changement du DECAY car comme on avait pu le voir dans « Mise en œuvre de l'EasyDriver v4.4 pour un pont tournant », son influence est importante. Malheureusement, comme on l'a vu dans « La DRV8824 de Pololu », le DECAY n'est pas disponible sur les broches de la DRV8824. Il faut aller le chercher sur la broche 19 du Ti DRV8824. En mettant cette broche à la GND, on sélectionne le Slow Decay et en la mettant à +5V, on sélectionne le Fast Decay.

En Slow Decay le comportement est moins bon avec un net pompage qui apparaît.

En Fast Decay le comportement est bien meilleur. La vibration, présente quand le pont est chargé, disparaît.

Il se trouve que la broche 19 voisine avec la broche 18, FAULT, qui a l'énorme avantage d'être à l'état haut en temps normal [3]. Il suffit donc de déposer une goutte de soudure pour réunir ces deux broches et sélectionne le Fast Decay. Relier DECAY à GND aurait été beaucoup plus sportif car il aurait fallu souder un fil volant entre DECAY et le GND qui se trouve à une dizaine de mm de là.

Modification de la DRV8824

Soudage des broches DECAY et FAULT ensemble de manière à mettre DECAY à l'état haut.

Il reste malgré tout un très léger pompage qui est résolu par la diminution du V_ref de manière à obtenir un courant entre 200mA (pont chargé en H0) et 150mA (pont lège en N). Le résultat est excellent, même dans les phases d'accélération et de décélération, comme en atteste la vidéo ci-dessous.

Le logiciel

La commande de la DRV8824 étant identique à celle de l'EasyDriver le logiciel reste, dans les grandes lignes, identique à celui décrit dans « Mise en œuvre de l'EasyDriver v4.4 pour un pont tournant ». Evidemment, comme il y a 4 fois plus de micro-pas il faut diminuer le délai entre le passage de 2 micro-pas. Sur l'EasyDriver, le délai avait été fixé à 37ms. Ici il est fixé à 16ms. Un tour est donc accompli en 12800 × 16ms = 3 minutes et 25 secondes environ, ce qui est presque conforme à la réalité.

Durée du STEP

Le Ti DRV8824 est moins tolérant que l'Allegro A3967. STEP doit resté au même état au moins 1,9µs alors que sur le A3967 nous avions 1µs. Si comme précédemment, on écrit :

void loop() { digitalWrite(pinMicroPas, LOW); digitalWrite(pinMicroPas, HIGH); delay(16); }

On risque de na pas satisfaire cette condition entre les deux digitalWrite(...). Les 16ms sont par exemple répartis comme ceci :

void loop() { digitalWrite(pinMicroPas, LOW); delay(8); digitalWrite(pinMicroPas, HIGH); delay(8); }

Conclusion

La DRV8824 de Pololu est donc retenue pour la mise en œuvre du pont tournant. Le prochain article portera sur l'algorithme du choix du plus court chemin.

[1] Certes, je construis un réseau à l'échelle N mais je pense aussi à mes petits camarades H0istes.

[2] Lorsque le Mixed Decay est sélectionné.

[3] Si FAULT passe à l'état bas, le composant est en erreur et la valeur à laquelle DECAY est mis n'a pas d'importance.

Mise en œuvre de l'EasyDriver v4.4 pour un pont tournant

Jean-Luc — 2013-12-09T12:33:38Z

Voici le compte rendu de quelques essais de mise en œuvre avec l'objectif de motoriser un pont tournant.

Le matériel

Afin d'avoir la meilleure résolution possible, le moteur pas-à-pas bipolaire choisi est un moteur 400 pas par tour vendu par Selectronic. Il s'agit de ce modèle.

Ce moteur est prévu pour être alimenté en 12V. Les bobines ont une résistance de 40Ω et par conséquent chaque bobine consomme 300mA. Le couple de maintien est de 3,5 kg/cm.

J'ai fixé sur l'arbre une latte en bois de 40 cm de longueur et donc un rayon de 20cm. Cette longueur est de 30% supérieure à la longueur d'un pont tournant en H0 et plus de 2 fois plus long qu'un pont tournant en N. Cela permet de visualiser la rotation et plus particulièrement les défauts.

Montage d'essai du moteur pas-à-pas

En combinant les 400 pas par tour du moteur et les 8 µpas de l'EasyDriver, on arrive à 3200 positions sur le cercle. Avec un diamètre de 30cm, typiquement un pont tournant en H0, cela nous donne un pas d'environ 0,3mm en bout de pont. Avec un diamètre de 15cm qui correspond au pont tournant PECO en N, cela nous donne un pas de 0,15mm en bout de pont.

La connexion de l'Arduino à l'EasyDriver est particulièrement simple. Comme on la vu dans « L'Easydriver v4.4 », la plupart des broches de l'EasyDriver ont la configuration adéquate quand on les laisse tout simplement non connectées.

Les sorties numériques 2 et 3 de l'Arduino sont employées pour piloter le moteur. On garde les alimentations séparées. L'EasyDriver est alimenté en 12V continu et, pour les essais, l'Arduino reste alimenté via l'USB.

Connexion de l'Arduino à l'EasyDriver

Influence de la limitation de courant

Plus le courant maximum I_max, c'est à dire le courant correspondant à 100% d'alimentation d'une bobine, est élevé et plus le passage d'un µPas au suivant est rapide et franc. Comme on veut le passage le plus doux possible, il faut régler le courant maximum à la valeur la plus basse possible.

Les indications de sens de rotation du potentiomètre sur l'EasyDriver 4.4 sont fausses. La valeur minimum correspond en fait à une rotation dans le sens trigonométrique (à gauche) et la valeur maximum à une rotation dans le sens horaire (à droite).

D'après la schématique, le I_max minimum possible est de 166mA pour V_ref = 1V, ce qui correspond à la valeur minimum que l'on trouve dans la documentation de l'Allegro A3967. En réalité, le V_ref minimum mesuré est de 1,59V au lieu des 1V annoncés. Par ailleurs, j'ai mesuré une valeur de 1,2Ω pour les résistances de capture de courant au lieu des 0,75Ω annoncés dans la schématique. Le rapport V_ref / R_s est quasiment le même et le I_max pour V_ref = 1,59V est donc bien de 166mA.

Voici une vidéo montrant l'influence de la limitation de courant sur la fluidité de la rotation pour les valeurs suivantes de I_max : 280mA (V_ref = 2,69V), 224mA (V_ref = 2,15V) et 166mA (V_ref = 1,59V). La vitesse de rotation est de 1 tour en 2 minutes.

On voit effectivement que le réglage I_max au minimum donne le meilleur résultat en terme de fluidité de mouvement même si la vidéo gomme les petites vibrations qui sont observables à des I_max plus élevés. Le couple reste largement suffisant.

Le logiciel

La pilotage du moteur pas-à-pas est très facile. La broche 2 de l'Arduino connectée à l'entrée DIR de l'EasyDriver permet de fixer le sens de rotation et la broche 3 connectée à l'entrée STEP de l'EasyDriver permet d'avancer d'un µPas. Ces deux broches sont donc mises en sortie dans setup() comme ceci.

const int pinSens = 2; const int pinMicroPas = 3; void setup() { pinMode(pinSens, OUTPUT); pinMode(pinMicroPas, OUTPUT); }

Le jeu consiste ensuite à choisir un sens de rotation en mettant pinSens à HIGH ou LOW puis à enchaîner à une certaine cadence des HIGH et des LOW sur pinMicroPas.

La cadence est déterminée par le délai d'attente entre deux bagottages sur pinMicroPas. Par exemple, si l'on veut que le pont accomplisse un tour complet en 2 minutes, soit 120 s, on calcule ce temps d'attente de la manière suivante : 3200 µPas en 120 s donne un délai de 120/3200 = 37,5 ms ≃ 37 ms.

Ainsi le programme le plus simple possible consiste à faire tourner le moteur en permanence dans loop().

void loop() { digitalWrite(pinMicroPas, LOW); digitalWrite(pinMicroPas, HIGH); delay(37); }

Voici une vidéo qui montre l'exécution d'une séquence de déplacement : positionnement en 100, puis 300, puis 200, puis 800, puis 1600, puis 1000 et enfin 2400. Dans la première partie, un délai de 36ms entre deux µPas est utilisé. Les µPas ne sont pas visibles. Dans la seconde on passe à un délai de 99ms, les µPas deviennent visibles. Enfin dans la 3e partie, le mouvement d'une position à l'autre a une phase d'accélération pendant 0,5s en passant d'un délai de 78ms à 36ms par décrément de 3ms et une phase de décélération pendant 0,75s en passant d'un délai de 36ms à 99ms par incrément de 3. Les phases d'accélération et de décélération sont légèrement hachées.

L'EasyDriver remplit son office mais montre quelques limites pour les très faibles vitesses qui sont utilisées dans les phases d'accélération et de décélération. D'autres breakout boards existent et la prochaine fois, nous verrons celle développée par Pololu qui utilise un Texas Instruments DRV8824 permettant 32 µPas.

L'Easydriver v4.4

Jean-Luc — 2013-12-07T15:25:42Z

Cet article fait suite à mes premiers essais de pilotage des moteurs pas-à-pas pour construire un point tournant qui n'avaient pas été couronnés de succès.

Pour rappel, l'objectif est de mettre en œuvre la motorisation d'un pont tournant avec un moteur pas-à-pas bipolaire sans réduction mécanique. On trouve dans le commerce des moteurs pas-à-pas à 200 pas ou 400 pas par tour. Vous trouverez les informations de base dans l'article Wikipédia mais surtout dans cet excellent article de Nicolas Marchildon que je trouve particulièrement didactique. le pilotage de tels moteurs n'est pas compliqué à condition de disposer d'un carte à microcontrôleur. En effet, passer d'un pas au suivant est réalisé en envoyant une séquence de tensions sur les deux bobines du moteur. Plus les séquences sont rapides et plus le moteur tourne vite.

Dans « Moteur pas-à-pas et pont tournant », j'avais essayé de piloter le moteur par micro-pas en pilotant chaque bobine par une PWM à 20KHz, dont la rapport cyclique évoluait en sinus, les deux PWM étant décalées de ∏/2. L'expérience avait eu un succès mitigé. En effet, les micro-pas sont définis par le courant dans chaque bobine du moteur pas-à-pas et en pilotant via une PWM, on pilote le courant en aveugle sans aucune garantie que lui même évolue en sinus.

Or, des circuits intégrés qui pilotent directement le courant, en le mesurant et en le régulant afin de permettre un mouvement par micro-pas précis, existent. L'un des spécialistes est Allegro Microsystems qui propose toute une gamme de circuits dédiés au moteurs pas-à-pas bipolaires avec un nombre de micro-pas pouvant aller jusqu'à 16. Un deuxième acteur majeur est Texas Instruments avec la gamme de circuits DRV88xx avec un nombre de micro-pas pouvant aller jusqu'à 32. Enfin, Toshiba propose également des composants dans la série TD65xx dont certains montent à 32 micro-pas.

Présentation de l'EasyDriver v4.4

L'EasyDriver v4.4 est une breakout board en OpenHardware conçue en coopération entre SparkFun et Brian Schmalz. Une breakout board est une carte minimaliste dont le but est de faciliter l'intégration d'un composant : alimentation, résistances, condensateurs indispensables au fonctionnement et boches au pas de 2,54mm pour pouvoir la mettre en œuvre sur une breadboard. Elle est donc peu chère, une dizaine d'Euros en France.

Le composant central est un Allegro A3967, dont voici la datasheet, qui permet 8 micro-pas. Ce n'est pas ce qui se fait de mieux et les essais montreront si, oui ou non, 8 micro-pas suffisent. Deux choses qu'il faut savoir :

Lorsque l'ensemble est sous tension, le moteur est alimenté et sa position est fermement tenue ;
Il ne faut en aucun cas débrancher le moteur en laissant l'EasyDriver sous tension, il pourrait en résulter la destruction de l'Allegro.

La carte mesure 49 mm sur 21 mm et se présente comme ceci :

Le régulateur 5V fournit le 5V à la logique de l'Allegro à partir de la tension d'alimentation du moteur ;
Le potentiomètre permet de régler le courant maximum. Plus le courant est élevé et plus le moteur a de couple mais moins le mouvement d'un micro-pas au suivant sera doux ;
Pour connaître la valeur de ce courant, il suffit de mesurer la tension de référence V_ref au point de mesure d'une part, et la résistance de capture de courant R_s d'autre part. Le courant maximum I_max est donné par la formule : I_max = V_ref / 8R_s ;
Enfin la carte est munie d'un condensateur de filtrage de 47µF qui protège l'Allegro des transitoires lors de la mise sous tension.

La carte est prévue pour s'enficher sur une carte mère où sur une breadboard. Elle possède 17 connexions dont le rôle est donné à la figure ci-dessous.

Le moteur pas-à-pas est connecté via les 4 broches en haut à gauche ;
L'alimentation du moteur est connectée sur les deux broches en haut à droite (entre 7V et 30V). Il est possible d'alimenter le moteur avec une tension plus élevée que celle qu'il supporte à condition de régler le courant à une valeur inférieure ou égale au courant supporté par le moteur ;
Les différentes masses sont reliées entre elles et l'une au moins devra être connectée à la masse de la carte microcontrôleur employée (Arduino ou autre) ;
RESET, ENABLE et SLP (pour SLEEP) permettent respectivement de faire une réinitialisation de l'Allegro, de l'activer ou de le mettre en veille ;
- RESET doit être amené à 0 puis à 1 pour réinitialiser l'Allegro. Les deux bobines sont alimentées à 70,71% et le rotor se place sur un demi-pas. L'EasyDriver tire le RESET à 5V via une résistance de 10kΩ. On peut donc laisser cette broche en l'air sans soucis ;
- ENABLE doit être constamment à l'état 0 (bas) pour que l'Allegro pilote les bobines du moteur. L'EasyDriver tire ENABLE à 0V via une résistance de 10kΩ. On peut donc aussi laisser cette broche en l'air sans soucis ;
- Enfin SLP peut être mise à l'état bas pour désactiver la majeure partie de la circuiterie interne de l'Allegro. Ici encore, l'EasyDriver tire SLP à 5V via une résistance de 10kΩ. On peut également laisser cette broche en l'air sans soucis.
MS1 et MS2 permettent de fixer le nombre de micro-pas entre 2 pas selon la table suivante. Ici aussi l'EasyDriver tire MS1 et MS2 à 5V par l'intermédiaire de réistances de 10kΩ. Par conséquent, en laissant ces broches en l'air, la résolution de 8 micro-pas par pas est sélectionnée ;

MS2	MS1	Mode
0	0	Pas entiers
0	1	1/2 pas
1	0	4 micro-pas
1	1	8 micro-pas

PFD règle la vitesse à laquelle le courant est réduit. Par défaut cette réduction est lente (slow decay). À priori ce réglage convient aux vitesses lentes et d'après le schéma du EasyDriver, il n'est nécessaire de s'en occuper que pour augmenter les performances dans le cas d'une vitesse de rotation élevée ;
DIR fixe le sens de rotation du moteur. Nous allons donc piloter cette broche pour notre application ;
STEP permet de faire avancer le moteur au micro-pas suivant. Une transition de 0 à 1 provoque cette avance. Cette broche sera également pilotée.

Équipons l'engin

L'EasyDriver arrive nu, il faut donc le munir de connecteurs pour l'utiliser. J'ai choisi des connecteurs avec détrompeurs et verrouillage pour le moteur et l'alimentation du moteur et des barrettes de broches pour les autres. Le tout au pas de 2,54mm. Utiliser un connecteur digne de ce nom pour la connexion vers le moteur garantit qu'il n'y aura pas de déconnexion intempestive par arrachage de fil et donc pas de destruction de l'Allegro.

Il reste maintenant à connecter tout cela à un moteur et à un Arduino pour faire quelques essais.

Moteur pas-à-pas et pont tournant

Jean-Luc — 2013-08-05T06:56:24Z

J'ai commencé à bricoler avec un moteur pas-à-pas prêté par Philippe [1]. Je ne vais pas entrer dans les détails de fonctionnement de ce type de moteur, d'autres le font bien mieux que je ne le ferais.

Les moteurs pas-à-pas sont typiquement employés pour des applications qui nécessitent un positionnement précis et pour lesquelles on préfère réaliser une commande en boucle ouverte [2] généralement pour des raison économiques. Par exemple, le positionnement d'un chariot d'imprimante entre dans cette catégorie.

Classiquement, la commande d'un moteur pas-à-pas se fait par pas entier ou par demi-pas. Dans mon cas, je ne veux pas mettre de réduction pour garder un système mécaniquement simple et bon marché. Dans ces conditions une rotation par pas entiers ou par demi-pas est inappropriée car la giration du pont tournant ressemblerait à celle de l'aiguille des secondes sur une horloge comme présenté dans la vidéo ci dessous.

Pour obtenir un mouvement doux, il faut faire ce que l'on appelle du microstepping. Au lieu de commander le passage d'un pas au suivant en « tout ou rien », on va progressivement baisser la courant sur la bobine du pas que l'on quitte pendant qu'on l'augmente progressivement celui de la bobine du pas que l'on gagne. La loi qui gouverne l'évolution du courant sur la bobine est un sinus.

En pratique, on applique sur les bobines une PWM dont le rapport cyclique évolue en sinus et « ça devrait marcher ».

Comme on le voit, ça marche presque. Il y a une petite pause à chaque pas. À suivre donc ...

[1] Un de mes deux complices, Philippe est le roi de la récupération !

[2] C'est à dire une commande qui est appliquée sans mesurer la réaction du système. En l'occurrence, la position n'est pas mesurée.