ModelleisenbahN

Découpeuse et graveuse laser

Jean-Luc — 2024-05-23T06:48:37Z

Une découpeuse et graveuse laser est probablement la machine-outil la plus intéressante pour le modélisme ferroviaire. Elle permet de réaliser ses propre kits de bâtiment avec des matières première très peu chère et une mise en œuvre plutôt aisée.

J'ai découvert cette technologie dans un FabLab. On trouve habituellement installées dans les FabLabs des machines professionnelles d'une puissance élevées, de grand format, 1m² ou plus, encombrantes et de coût non négligeable ; On parle de plusieurs milliers d'euros. Ces machines sont équipées d'un laser CO2 et permettent la découpe de matériaux épais. Un laser à CO2 émet de la lumière à environ 10µm de longueur d'onde, c'est à dire dans l'infrarouge pas si proche que ça.

Les machines pour les particuliers

Les machines accessibles aux particuliers utilisent une technologie différente et moins chère, la diode laser. Ici la longueur d'onde se situe entre 500 et 900 nm [1], donc dans le visible ou le très proche infrarouge. Dans cette catégorie on trouve des machines allant d'environ 150€ à 600-700€ selon la puissance, la taille et le degré de sophistication et d'équipement. La puissance démarre à 5W et monte à 40W. Toutes ces machines ont des architectures similaires :

Un cadre en profilé d'aluminium (axe Y) ;
Un portique en profilé d'aluminum sur lequel se déplace le laser (axe X) ;
Un laser réglable en hauteur pour que la focale soit centrée sur le matériau à découpé ;
Un moteur pas-à-pas pour le déplacement du portique le long de l'axe Y ;
Un moteur pas-à-pas pour le déplacement du laser sur le portique le long de l'axe X ;
Une carte de commande pilotant la puissance du laser et les deux moteurs pas-à-pas et reliée à un ordinateur.

On peut aussi avoir quelques fonctions supplémentaires comme le Wifi pour transférer des fichiers sur la machine et découper de manière autonome.

Contrairement aux machines professionnelles, rien n'est prévu de base pour l'extraction des fumées et il faudra se débrouiller pour concevoir et fabriquer un système d'extraction. La figure ci-dessous montre la machine que j'ai choisie, une Longer Ray5 10W.

Découpeuse/graveuse laser Longer Ray5

Cette machine a une surface de découpe de 400x400mm mais j'ai également acheté l'extension de l'axe Y qui porte cette dimension à 850mm.

Le martyr

Comme on ne va pas découper directement sur la table, il faut prévoir un support adapté. Placer sous les pièces à découper une planche de bois n'est pas la meilleure idée car le dessous de la pièces sera brulé. Le mieux est d'acheter un support en aluminium en nid d'abeille prévu pour la découpe laser, un LaserBed. Des supports de grande taille sont plus rares mais la société MECPOW vend un nid d'abeille de 400x800mm de surface utile. Tant pis pour les 50mm perdus sur l'axe Y. Dans le kit, on a également une plaque en inox qui se place sous le nid d'abeille.

Le LaserBed MECPOW 400x800mm

L'Air Assist

Lorsque le laser découpe un matériau, des gaz et des fumées s'en échappent. Les fumées vont venir diffracter le laser et baisser son efficacité. Les gaz ont tendance à s'enflammer. Ce n'est pas réellement dangereux tant que l'on ne respire pas les émanations [2] mais cela provoque des flashs de brûlure sur la surface du matériau. L'Air Assist est une pompe qui envoie un jet d'air dans l'axe du laser ; les gaz sont dispersés et la fumée est soufflée sous le matériau et dans le LaserBed. Le résultat est une découpe très propre et plus rapide. Cette option est indispensable pour le maquettiste.

Air Assist pour la Longer Ray5

En pratique

La préparation des pièces

La production de pièces découpées au laser commence par le dessin de celles-ci. Un simple logiciel de dessin vectoriel 2D suffit. Inkscape en est un mais on peut aussi utiliser un logiciel de CAO comme FreeCAD pour des pièces complexes qui seront plus difficiles, voire impossible, à faire avec un logiciel de dessin 2D. Pour ma part, j'utilise Graphic et FreeCAD. Une fois la pièce dessinée, il faut l'exporter dans un format permettant de l'importer dans ...

Le logiciel de découpe

Ma découpeuse laser nécessite la version GCode de Lightburn. Lightburn permet l'importation du SVG, du PDF (incidemment car c'est le format d'Adobe Illustrator) et du DXF. Les différents tracés peuvent se voir affecter une couleur et à chaque couleur, on fait correspondre un mode de découpe/gravure : trait ou remplissage, une vitesse de déplacement du laser et une puissance du laser.

Le couple vitesse/puissance donne l'énergie associé à la découpe ou au remplissage. Plus on va vite et moins le matériau est entamé, Plus la puissance du laser est importante et plus le matériau est entamé. Lightburn propose un générateur d'essais qui trace ou remplit une matrice de carrés en faisant varier vitesse et puissance dans des intervalles.

Les opérations sont effectués dans l'ordre de classement des couleurs. Typiquement, si une pièce comprend une partie de gravure par remplissage (couleur A) et une découpe (couleur B), on fera d'abord la couleur A puis la couleur B afin que la gravure ne se fasse pas sur une pièce déjà découpée et qui peut donc bouger.

Pour les petites pièces découpées dans un matériau fin, comme du bristol, Lightburn peut pour chaque couleur engendrer automatiquement des pattes de fixation afin d'éviter que la pièce ne s'envole ou ne tombe dans une maille du LaserBed.

Il va sans dire que lors de la découpe on doit constamment superviser la machine. Il ne s'agirait pas d'aller faire autre chose et de se retrouver avec la maison incendiée.

Quels matériaux

Les matériaux privilégiés sont le bois et ses dérivés. Plus précisément, pour le modélisme ferroviaire, on trouve le MDF qui existe en différentes épaisseurs mais aussi les différents papiers plus ou moins forts, plus ou moins texturés. Il est également possible de découper du plastique mais pas n'importe lequel. Certains se découpent mal car ils fondent et forme un bourrelet disgracieux comme le polystyrène ou l'ABS. D'autres, comme le PVC, diffusent des gaz nocifs comme le chlore lorsque le laser les brûle. On ne pourra pas découper un plastique transparent avec un laser à diode car il est aussi transparent à la longueur d'onde du laser. Ce n'est pas le cas pour un laser CO2. On peut découper pour nos usages de l'acrylique (ou PMMA ou Plexiglas).

Pour conclure

D'autres questions restent bien entendu en suspens comme la manière de combiner tous ces matériaux pour réaliser un modèle, la finesse qu'il est possible d'atteindre ou encore la manière de rendre un effet voulu sur un modèle ou encore l'utilisation de Lightburn. Ces questions seront prochainement abordées au fur et à mesure sur mon blog.

[1] Du moins si j'en crois l'offre disponible chez TME.

[2] Malgré tout j'ai un extincteur de voiture de 1kg à proximité.

Les LED WS2812B

Jean-Luc — 2014-06-02T18:54:06Z

Ces composants ont été déjà succinctement présentés dans trois articles : « Test des LED RGB WS2812B », « Évolution de l'architecture électronique du TCO » et « Dernières réflexions avant la réalisation du TCO ». Voici une présentation plus détaillée.

Ces LED sont très différentes des LED tricolores classiques. Une LED tricolore classique intègre 3 LED, une rouge, une verte et une bleue, et possède donc 4 broches. Il existe deux organisations pour les 4 broches. Dans la première les LED sont reliées entre elles par la cathode (1 broche) et les 3 autres broches correspondent aux anodes des 3 LED. Dans la seconde, les LED sont reliées entre elles par l'anode et les 3 autres broches correspondent aux cathodes des 3 LED. On préfère généralement les LED à cathode commune car le point commun est relié à la masse.

Caractéristiques des LED WS2812B

Les WS2812B sont des composants en boîtier 5050, boîtier plat de 5mm de côté et destiné à être soudé en surface [1]. Elles intègrent évidemment 3 LED mais aussi un circuit intégré logique destiné à piloter les LED. Ce circuit intégré gère chacune des LED via une PWM [2] avec une résolution de 8 bits, soit 256 niveau par couleur, pour un total de 16 millions de couleur possibles. Sur le cliché ci-dessous, on peut voir l'implantation des LED et du circuit de pilotage dans le composant.

LED WS2812B en gros plan

À gauche le circuit de gestion des LED et de la communication. Superbe cliché d'Adafruit distribué sous licence CC BY-NC-SA 2.0. Accéder au cliché original.

Le circuit de pilotage gère également la communication. En effet, ces LED sont autonomes et disposent de deux broches de communication permettant de leur envoyer une valeur de PWM pour chacune des 3 couleurs, soit 24 bits de données. La première broche de communication est l'entrée DI (Data In) et la seconde DO (Data Out). Les LED sont conçues pour être chaînées, le DO de la LED amont est connecté au DI de la LED aval.

Le mode opératoire

À l'état de repos, c'est à dire si aucune information ne doit être envoyée à la LED, le signal DI est maintenu à l'état bas. Le passage de DI à l'état haut indique à la LED le début d'une transmission d'une série de bits. Les bits sont transmis à une fréquence de 800kHz, soit 1,25µs par bit. Il n'y a pas de signal d'horloge séparé, la LED se base sur le signal transportant les données pour se synchroniser.

Un bit à 0 est codé en laissant DI à l'état haut pendant 400ns puis à l'état bas pendant 850ns. Un bit à 1 est codé en laissant DI à l'état haut pendant 800ns et à l'état bas pendant 450ns. Dans le chronogramme example ci-dessous, 4 bits sont transmis.

Example de transmission de 4 bits de données, 0110

La tolérance sur les durées est de 150ns.

Le micro-contrôleur n'est connecté qu'à la première LED d'une chaîne. Le mode opératoire consiste à envoyer à cette première LED autant de séries de 24 bits qu'ils y a de LED dans la chaîne. Chaque LED prend pour elle les 24 premiers bits qu'elle reçoit et transmet les suivants à la LED suivante de la chaîne. De fil en aiguille chaque LED reçoit les 24 bits qui lui sont destinés.

Après la transmission, DI est maintenu à l'état bas pendant 50µs afin de réinitialiser le mécanisme de transmission de l'information de LED en LED. De cette manière, à la prochaine transmission, l'échantillonnage des 24 premiers bits reçus sera de nouveau effectué par chaque LED de la chaîne.

24 bits demandent une temps de transmission de 1,25µs x 24, soit 30µs. L'envoi des données à une chaîne de 100 LED demande donc 3ms.

Datasheet des LED WS2812B

La mise en œuvre

Adafruit a publié plusieurs recommandations pour la mise en œuvre de ces LED. On retiendra le fait de monter sur l'alimentation un condensateur de 1000µF pour absorber les pics de tension à la mise en route et l'ajout éventuel d'une résistance d'environ 500Ω en série entre le micro-contrôleur et la LED de tête lorsque le fil est long pour empêcher le signal de se réfléchir et de perturber la transmission.

Une résistance de 10kΩ entre DI et GND garantit également que la LED de tête ne reçoit pas un signal incohérent alors que la broche du micro-contrôleur n'a pas encore été programmée en sortie.

La bibliothèque NeoPixel d'Adafruit

Ecrire le programme de rafraichissement d'une chaîne de LED est un exercice assez difficile. En effet, il est nécessaire de garantir les caractéristiques temporelles du signal de manière précise. Cette garantie ne peut être atteinte qu'en connaissant la durée de chaque instruction employée dans le programme de rafraîchissement et disqualifie donc le langage C. L'emploi de l'assembleur est de fait obligatoire.

La bibliothèque NeoPixel d'Adafruit tombe donc à point nommé pour m'épargner cette tâche. Elle offre une classe C++ représentant la chaîne de LED dans la mémoire de l'Arduino, une série de méthode pour manipuler les couleurs et bien sûr une méthode pour rafraîchir la chaîne.

Chaque LED occupe 3 octets en mémoire SRAM. On peut donc piloter une ou plusieurs chaînes avec un Arduino Uno et de manière générale tous les modèles équipé d'un ATMega328 [3] à condition que le nombre total de LED ne dépasse pas 600 [4].

Une fois la bibliothèque installée à l'emplacement adéquat, elle est utilisable dans un croquis.

#include

Il faut ensuite instancier un objet de type Adafruit_NeoPixel. Comme ceci.

Adafruit_NeoPixel leds = Adafruit_NeoPixel(94, PIN, NEO_GRB + NEO_KHZ800);

94, le premier argument, est le nombre de LED dans la chaîne. Ici 94 correspond au nombre de LED dans la chaîne de la gare de Messingrohrstadt. PIN est le numéro de broche d'entrée/sortie numérique où le DIN de la première LED de la chaîne est connecté. Comme d'habitude, on évitera les broches 0 et 1 qui servent à téléverser le programme sur l'Arduino et incidemment à établir une liaison série avec la console de l'IDE Arduino à des fins de debug. On évitera également la broche 13 sur laquelle est câblée une LED présente sur la carte Arduino et dont la charge pourrait perturber la transmission.

NEO_GRB + NEO_KHZ800 permet de spécifier le modèle de LED employé. NEO_GRB indique l'ordre des couleurs dans les 24 bits transmis à chaque LED. Pour les WS2812B, l'ordre est vert, rouge, bleu. NEO_KHZ800 fixe la fréquence de transmission soit 800kHz.

La méthode begin()

Une fois l'objet leds instancié, on peut appeler ses méthodes. La première chose à faire est d'activer la chaîne de LED en invoquant la méthode begin() qui a pour effet de programmer la broche en sortie et de la mettre à l'état bas. L'appel à begin() sera fait dans setup().

Les méthodes setPixelColor(...)

La seconde méthode importante est setPixelColor(...). Elle permet de spécifier la couleur d'une LED de la chaîne. Deux versions, où la couleur est indiquée de manière différente, sont disponibles. Quelque soit la version, le premier argument est le numéro de la LED concernée, de 0 au nombre de LED moins 1. Dans la première version, les composantes rouge, vert et bleu sont données séparément et dans cet ordre. Par exemple :

leds.setPixelColor(10, 100, 150, 200);

réglera la couleur de la LED 10 à 100 (sur 255) pour le rouge, 150 pour le vert et 200 pour le bleu.

Dans la seconde version, un seul argument, un entier 32 bits qui regroupe les 3 composantes. La méthode Color(...) permet de construire un tel entier à partir des composantes et peut être employé directement dans setPixelColor(...)

leds.setPixelColor(10, leds.Color(100, 150, 200));

À quoi cela avance-t-il me direz vous ? À stocker des couleurs prédéfinies dans des entiers 32 bits au lieu de les disperser dans 3 octets chacune.

La méthode setBrightness(...)

La méthode setBrightness(...) permet de changer la luminosité des LED. Les composantes de chaque LED sont ajustées en mémoire. Comme les calculs sont faits en nombre entiers, une augmentation de luminosité ne donne pas un résultat exact. Notamment diminuer la luminosité et la remettre au niveau initial ne redonnera pas la même couleur. Il est donc nécessaire, après un setBrightness(...) de mettre à jour la couleur de la totalité des LED de la chaîne via setPixelColor(...).

La luminosité programmée est appliquée lors du setPixelColor(...). setBrightness(...) prend pour argument une valeur de 0 à 255. 0 correspond à l'extinction des LED et 255 à la luminosité maximum qui est aussi la valeur par défaut à l'initialisation.

leds.setBrightness(127); // luminosité moitié

La méthode show()

Surnommée aussi « méthode que l'on oublie systématiquement d'appeler », show() opère un rafraichissement de la chaîne de LED en envoyant les couleurs stockées en mémoire. Elle doit donc suivre les modification de couleur ou de luminosité effectuées par les fonctions vues précédemment.

leds.show();

Conclusion

D'une très grande facilité de mise en œuvre, offrant beaucoup de possibilités graphiques et une grande souplesse d'emploi, ces LED sont extrêmement intéressante pour la construction d'un TCO. Construction qui sera exposée dans un prochain article.

[1] Un composant monté en surface est soudé sur le cuivre sans que ses broches traversent le circuit imprimé. Sur un CI simple face, il est donc monté côté cuivre. Un composant traversant a ses broches qui traversent le CI et qui sont donc soudées de l'autre côté.

[2] Modulation de largeur d'impulsion.

[3] La taille de la SRAM de l'ATMega328 est de 2ko.

[4] 684 en fait mais il faut compter avec la mémoire nécessaire aux autres variables et à la pile.

Cartes de développement pour PIC sur breadboard

Jean-Luc — 2014-03-22T10:50:36Z

Inspiré par les diverses cartes de développement sur breadboard que l'on trouve dans le monde Arduino, comme ce produit d'Adafruit, j'ai décidé de concevoir 2 cartes de ce type pour faciliter les développements.

La carte pour PIC 18F46K80 en action

Le principe est de rassembler sur une petite carte enfichable sur une breadboard l'ensemble minimum de composants nécessaires au fonctionnement du micro-contrôleur ainsi que l'électronique et le connecteur nécessaire pour programmer le micro-contrôleur in-situ. De cette manière le câblage sur la breadboard est simplifié car les composants indispensables sont présents sur la carte et le développement du logiciel est accéléré car il n'est plus nécessaire de retirer le micro-contrôleur de la breadboard pour téléverser un nouveau programme.

Il suffit ensuite d'ajouter sur la breadboard les composants spécifiques à la carte électronique en cours de conception.

En ce qui concerne les développements de cartes électroniques à base de micro-contrôleurs PIC que nous effectuons, l'ensemble de composants minimum inclut un transceiver CAN.

Description des cartes

2 cartes semblables ont été conçues, la première permet de mettre en œuvre un PIC 18F26K80 28 broches et la seconde un PIC 18F46K80 40 broches. Les deux platines comprennent :

une alimentation régulée 5V ;
un strap (A) permettant d'isoler l'alimentation du reste de la carte ;
une diode témoin d'alimentation ;
un connecteur ICSP pour brancher un PIC-KIT 3 ;
un bouton reset ;
un support DIP28 ou DIP40 pour le micro-contrôleur ;
un strap (B) permettant de couper l'alimentation du générateur d'horloge et du transceiver CAN ;
une paire de straps permettant de connecter le transceiver aux broches 17 et 18 ou bien aux broches 23 et 24 sur le 18F26K80 et aux broches 25 et 26 ou bien aux broches 35 et 36 sur le 18F46K80 ;
un support DIP8 pour le générateur d'horloge ;
et enfin un support DIP8 pour le transceiver CAN.

La carte pour PIC 18F26K80

La carte pour PIC 18F46K80

Voici le dossier complet décrivant les cartes, leur schémas et les typons.

Dossier de description des cartes

Détection du zéro du pont tournant

Jean-Luc — 2014-01-07T23:18:15Z

Un moteur pas-à-pas employé seul ne permet pas de connaître sa position à la mise sous tension du système. Nous allons examiner les solutions qui s'offrent à nous pour connaître la position du pont. Dans ce qui suit, le Z est le zéro du pont, ceci afin de ne pas la confondre avec la valeur 0.

Quelques remarques préliminaires sur les moteurs pas-à-pas

Un moteur pas à pas bipolaire, si on le pilote par pas entiers, accomplit sa rotation via l'application sur ses bobines d'un courant positif ou négatif selon la séquence suivante (mode deux phases à la fois) :

Étape	Courant bobine A	Courant bobine B
0	+	+
1	+	–
2	–	–
3	–	+

Une fois à l'étape 3, on recommence à l'étape 0. Pour inverser le sens de rotation, on inverse la séquence. Au lieu de faire 0, 1, 2, 3, on fait 3, 2, 1, 0. À chaque étape correspond le franchissement d'un pas.

À l'allumage du système, on doit décider quelle est l'étape initiale. Par exemple l'étape 0. Par conséquent, bien que ne connaissant pas la position du moteur en général, on connaît sa position au sein d'un groupe de 4 pas.

Ceci reste vrai avec un fonctionnement par µPas. Que ce soit l'EasyDriver ou la DRV8824, à l'allumage et après un RESET, le courant dans les bobines est fixé à +70,71%, état appelé le Home State et cet état se retrouve bien entendu après avoir franchi 4 pas entiers ou 32µPas pour l'EasyDriver et 128 µPas pour la DRV8824.

Donc, avec un moteur 400 pas par tour, il suffit d'être capable de détecter 100 positions ou bien d'en détecter 1 sur 100 pour savoir où est le moteur.

Cette caractéristique facilite énormément la détection du 0 du pont. En effet, dans le cas de la DRV8824, si il avait fallu détecter la position au µPas près, il aurait fallu disposer d'un capteur capable de distinguer deux positions séparées de 0,028125°, soit de 0,037mm en bout de pont pour un pont de 150mm de diamètre, ce qui n'est pas une mince affaire. En réalité le capteur doit être capable de distinguer deux positions séparées de 128µPas, c'est à dire 4,71mm en bout de pont, ce qui est très facile à réaliser.

La solution sans capteur

Voici une première solution qui m'a été suggérée par Pierre59 sur le forum de Loco-Revue.

Il s'agit de faire le Z à la main une première fois. On allume l'électronique de commande et le pont est positionné, au moyen de poussoirs ou un autre moyen d'interaction avec l'électronique, sur un Z arbitraire qui correspond à une des voies de sortie. Le µPas à l'intérieur du bloc de 128 où se trouve le Z est mémorisé dans l'EEPROM du micro-contrôleur (ce qui revient à ne garder que les 7 bits de poids faible) sachant que la valeur 0 correspond au Home State.

À chaque mouvement ultérieur du pont, le numéro de bloc de 4 pas courant est également mémorisé en EEPROM afin de conserver de manière non volatile la position courante du pont quand on arrête le système.

En cas de coupure brutale de l'alimentation, il est nécessaire de garantir que le pont est dans un bloc de 4 pas connu. En effet si la coupure d'alimentation intervient à l'instant de passage d'un bloc au suivant, il se peut que le programme estime être dans le bloc suivant alors que l'arrêt effectif s'est produit dans le bloc courant. L'inverse est aussi possible d'ailleurs. De plus l'écriture en EEPROM alors que l'alimentation du micro-contrôleur se coupe peut être incertaine.

Il est donc nécessaire de disposer d'une petite réserve d'énergie et d'une détection de la coupure d'alimentation afin d'effectuer les opérations ultimes assurant que l'état est stable au moment de l'extinction.

Avantage pas de capteur.

Inconvénients procédure manuelle pour faire le Z, matériel de gestion de la coupure d'alimentation, pas de possibilité de détecter un mouvement manuel du pont lorsque le système est éteint.

Solution avec un capteur de position Zéro

La seconde solution consiste à assujettir à l'axe du moteur un ergot dont on sera capable de détecter la position en utilisant, par exemple, un capteur optique. Ce type de capteur est constitué d'une fourche entre les branches de laquelle un faisceau infrarouge est établi. Il s'agit donc de détecter la coupure du faisceau par l'ergot.

Capteur TCST2103 de Vishay Semiconductors

Comme expliqué à la fin du paragraphe sur les moteurs pas-à-pas, la précision n'a pas à être extraordinaire. En plaçant l'ergot à 40mm de l'axe du moteur, deux blocs successifs de 128µPas sont distants de 2,5mm.

Afin d'expérimenter cette solution, j'ai ajouté à mon banc d'essai un plateau sur lequel est fixé le moteur et le capteur.

La recherche du Z n'est pas très compliquée. Il suffit de faire tourner le moteur dans un sens quelconque jusqu'à ce que l'ergot soit détecté. Dans cette phase, il n'est pas nécessaire de respecter une vitesse de rotation réaliste. L'important est que le temps de recherche du zéro soit le plus court possible sans risquer de faire valdinguer une éventuelle locomotive stationnée sur le pont. Il faut aussi se prémunir d'un dysfonctionnement éventuel du capteur et n'effectuer qu'un tour complet.

Il vient donc la fonction suivante :

boolean chercheZero() { int microPas; int blocPas; boolean zTrouve = false; /* Allume la LED indiquant que la recherche est en cours */ digitalWrite(ledPin, LOW); /* * Boucle de recherche. On effectue un tour complet * (parcours de 100 blocs de 4 pas. Un bloc est constitué de * 128 micropas). Pour chaque bloc, on parcoure 128 micro-pas * à raison de 1,1ms par micro-pas. Soit 14s pour le tour * complet * * zTrouve permet de savoir si on est sortit de la boucle en * trouvant Z ou non. */ for (blocPas = 0; blocPas < 100; blocPas++) { if (digitalRead(sensorPin) == 0) { /* Z est trouvé */ zTrouve = true; break; } /* Avance de 128 micro-pas */ for (microPas = 0; microPas < 128; microPas++) { digitalWrite(stepPin, LOW); delayMicroseconds(100); digitalWrite(stepPin, HIGH); delay(1); } } /* Signale le fait que Z a été trouvé ou non */ if (zTrouve) { /* Eteint la LED de recherche */ digitalWrite(ledPin,HIGH); } else { /* problème, on fait clignoter rapidement la LED */ int i; for (i = 0; i < 20; i++) { digitalWrite(ledPin,HIGH); delay(50); digitalWrite(ledPin,LOW); delay(50); } } /* * Si on a trouvé Z, on met à 0 la position actuelle */ positionActuelle = 0; /* retourne true si on a trouvé Z */ return zTrouve; }

Cette solution peut être améliorée en stockant la position atteinte en EEPROM. En cas de coupure intempestive de l'alimentation, il sera nécessaire de refaire le Z. Ceci peut être détecté automatiquement sans ajouter de matériel. En effet, il suffit à chaque mouvement du pont, de mettre un octet de l'EEPROM à 0 au début puis de le mettre à 1 à la fin. Si au démarrage du système cet octet est trouvé à 0, cela signifie que l'alimentation a été coupée alors que le pont était en mouvement et que le logiciel n'avait pas encore écrit sa nouvelle position en EEPROM. Il n'y a par contre pas de moyen de détecter une rotation manuelle du pont alors que le systèmes est éteint.

Avantage Procédure automatique pour trouver Z.

Inconvénients Procédure disgracieuse pour trouvez Z.

Solution avec un codeur absolu

Cette dernière solution consiste à mettre en œuvre un codeur absolu. Il s'agit d'une roue codeuse divisée en autant de secteurs qu'il y a de positions. Sur chaque secteur, on dispose radialement des zones noires ou blanches. Une zone code un 0 ou un 1 binaire. Les N zones disposées sur un secteur codent donc un nombre sur N bits.

Dans notre cas, nous avons 100 positions pour le moteur et il faut donc 100 secteurs. Le nombre N de bits est de 7 car ils faut être capables de coder au moins 100 valeurs différentes. Or 2⁷ = 128. La roue codeuse a donc cet aspect :

Roues codeuse absolue 100 positions.

Le diamètre extérieur est de 110mm. Le bit de poids fort est à l'intérieur, celui de poids faible à l'extérieur. Une zone blanche est un 0 et une noire un 1.

Cette roue est assujettie à l'axe du moteur pas-à-pas et 7 capteurs IR réflectifs sont employés pour lire les 7 bits codant la position du moteur.

Il faut que le capteur soit relativement petit pour que la roue codeuse tienne facilement sous un pont tournant à l'échelle N. Mes investigations m'ont conduit à examiner deux capteurs IR réflectifs : le KTIR0711S de Kingbright et l'EE-SY193 d'Omron. Dans les deux cas il s'agit de composants montés en surface d'une dimension de 3,3mm sur 2,7mm. Après discussion avec mes camarades, mon choix s'est porté sur le capteur d'Omron car il semble plus précis.

Avantage Position du pont connue à l'allumage sans procédure y compris en cas de rotation manuelle.

Inconvénients Capteurs plus compliqués à mettre en œuvre.

Cette solution a ma préférence car elle évite toute procédure de détection du Z, qu'elle soit automatique ou manuelle.

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.

La DRV8824 de Pololu

Jean-Luc — 2013-12-16T21:49:00Z

Les essais avec l'EasyDriver v4.4 n'ont pas donné entière satisfaction. En effet, 8 micros-pas par pas ne semblent pas suffisants pour un mouvement fluide à très faible vitesse. Nous examinons aujourd'hui une seconde breakout board qui donnera peut-être de meilleurs résultats.

Présentation de la DRV8824 de Pololu

La DRV8824 de Pololu est une autre candidate pour le pilotage des moteurs pas-à-pas par micro-pas. Cette Breakout Board intègre un circuit intégré Texas Instruments DRV8824 ainsi que les composants permettant de le mettre en œuvre. Voici la datasheet du DRV8824. Cette Breakout Board porte donc le même nom que le composant qu'elle intègre ce qui ne va pas me faciliter la description. Dans la suite je vais donc utiliser DRV8824 quand il s'agit de la Breakout Board et Ti DRV8824 quand il s'agit du composant de Texas Instruments

Le Ti DRV8824 permet 32 µPas au maximum là où l'Allegro A3967 n'en permettait que 8. Cette meilleure résolution devrait permettre une plus grande fluidité de mouvement. Comme on va le voir le principe d'utilisation est quasiment identique entre les deux circuits.

Pololu recommande également de ne jamais débrancher le moteur en laissant la DRV8824 sous tension, il pourrait en résulter la destruction du Ti DRV8824.

La DRV8824 est une carte beaucoup plus petite que l'EasyDriver. Elle ne mesure que 20,5mm sur 15,5mm. On peut la voir comme un composant 16 broches avec deux lignes de 8 broches au pas de 2,54mm écartées de 12,7mm. On la trouve pour une douzaine d'Euros. Elle se présente comme ceci :

Le Ti DRV8824 est aussi plus petit avec des broches au pas de 0,65mm. Contrairement à l'EasyDriver, il n'y a pas de régulateur de tension car il est inutile. En effet, le Ti DRV8824 intègre son propre régulateur de tension pour générer le 3,3V nécessaire à partir de la tension du moteur.

Il n'y a pas non plus de condensateur chimique de filtrage. Par conséquent, il est nécessaire d'en prévoir un en externe sur l'alimentation du moteur. Ce condensateur dont la valeur doit être au moins de 47µF est indispensable pour filtrer les transitoires à l'allumage qui risqueraient d'endommager le Ti DRV8824. Pololu met en garde à ce sujet.

Comme sur l'EasyDriver, nous retrouvons un potentiomètre de réglage du courant maximum. La valeur de ce courant est également fixée par la tension de référence V_ref au point de mesure et la résistance de capture de courant R_s. Le courant maximum I_max est donné par la formule : I_max = V_ref / 5R_s. Contrairement à l'EasyDriver la valeur minimum de V_ref n'est pas de 1V mais de 0V, ce qui théoriquement permet de descendre plus bas. En pratique, la documentation du Ti DRV8824 indique que les performances sont moindres si V_ref est en dessous de 1V.

Le rôle des 16 broches est indiqué au verso de la carte.

Le moteur pas-à-pas est connecté via les A1 et A2 pour la première bobine et B1 et B2 pour la seconde. ;
L'alimentation du moteur est connectée sur les deux broches VMOT et GND (entre 8,2V et 45V). Il est également 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 deux 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 du Ti DRV8824, de l'activer ou de le mettre en veille ;
- RESET doit être amené à 0 puis à 1 pour réinitialiser le Ti DRV8824. Les deux bobines sont alimentées à 70,71% et le rotor se place sur un demi-pas. Le Ti DRV8824 tire RESET à 0 via une résistance interne de 100kΩ. Il est donc nécessaire de connecter RESET au 5V pour que que le RESET ne soit pas actif.
- ENABLE doit être constamment à l'état 0 (bas) pour que le Ti DRV8824 pilote les bobines du moteur et que ça logique soit opérationnelle. Cette entrée est tirée à 0V via une résistance interne de 100kΩ. On donc peut laisser cette broche en l'air ;
- Enfin SLP peut être mise à l'état bas pour mettre le Ti DRV8824 en veille. Cette entrée est tirée à 0V via une résistance interne de 1MΩ. Il faut donc raccorder cette broche au 5V pour que le pilote reste actif.
M0, M1 et M2 permettent de fixer le nombre de micro-pas entre 2 pas selon la table suivante. Le Ti DRV8824 tire ces broches 0V via des résistances internes de 100kΩ avec pour conséquence un mouvement par pas entiers si ces elles sont laissées en l'air. Il est donc nécessaire de les relier conformément à la table ;

M2	M1	M0	Mode
0	0	0	Pas entiers
0	0	1	1/2 pas
0	1	0	4 micro-pas
0	1	1	8 micro-pas
1	0	0	16 micro-pas
1	0	1	32 micro-pas
1	1	0	32 micro-pas
1	1	1	32 micro-pas

DIR fixe le sens de rotation du moteur ;
STEP permet de faire avancer le moteur au micro-pas suivant. Une transition de 0 à 1 provoque cette avance.
Enfin le Ti DRV8824 met FAULT à 0 si un courant excessif ou une température trop élevée est détectée.

Par rapport à l'EasyDriver, la broche permettant de sélectionner la manière dont le courant décroît est manquante. Elle est bien présente sur le Ti DRV8824, il s'agit de la broche 19 : DECAY, mais n'est pas disponible sur le DRV8824 et est laissée en l'air. Cette configuration fixe la décroissance du courant à mixed.

Soudage des broches et carte de montage

Le DRV8824 est livré avec une barrette à broches que j'ai soudée sous la carte. Il n'y a absolument pas la place de l'équiper des mêmes connecteurs que ceux que j'ai utilisés pour l'EasyDriver.

Afin de pouvoir réutiliser ma connectique, j'ai bricolé une petite carte accueillant le DRV8824 et mon connecteur pour le moteur et s'enfichant dans la breadboard.

Le connecteur d'alimentation sera planté séparément sur la breadboard pour pouvoir ajouter le condensateur de filtrage préconisé par Pololu.

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.

Témoins de positions : la mise en œuvre

Jean-Luc — 2013-12-03T19:28:33Z

Nous avons vu la technique du Charlieplexing dans « Témoins de positions : le Charlieplexing », nous allons maintenant l'appliquer à un système à 5 broches de pilotage et 16 LED puis l'intégrer dans notre application.

Charlieplexing des 16 LED témoins [1]

Le schéma pour allumer 16 LED est le suivant.

Charlieplexing avec 5 broches et 16 LED

On peut noter que le schéma est incomplet. En effet, avec 5 broches, il est possible de piloter 20 LED. Ici les couples de broches 0-3 et 1-4 sont manquants et nous n'allons donc pas les placer dans notre table d'état des broches.

Voici donc la table d'état des broches pour chaque LED

	broche 0	broche 1	broche 2	broche 3	broche 4
D0	0	1	Z	Z	Z
D1	1	0	Z	Z	Z
D2	Z	0	1	Z	Z
D3	Z	1	0	Z	Z
D4	Z	Z	0	1	Z
D5	Z	Z	1	0	Z
D6	Z	Z	Z	0	1
D7	Z	Z	Z	1	0
D8	0	Z	1	Z	Z
D9	1	Z	0	Z	Z
D10	Z	Z	0	Z	1
D11	Z	Z	1	Z	0
D12	Z	0	Z	1	Z
D13	Z	1	Z	0	Z
D14	0	Z	Z	Z	1
D15	1	Z	Z	Z	0

Nous allons donc construire cette table en C comme nous l'avons fait pour la Charlieplexing avec 3 broches de commande.

const byte etatSortiePourLED[16][5] = { { OUT0, OUT1, INZ, INZ, INZ }, /* D0 */ { OUT1, OUT0, INZ, INZ, INZ }, /* D1 */ { INZ, OUT0, OUT1, INZ, INZ }, /* D2 */ { INZ, OUT1, OUT0, INZ, INZ }, /* D3 */ { INZ, INZ, OUT0, OUT1, INZ }, /* D4 */ { INZ, INZ, OUT1, OUT0, INZ }, /* D5 */ { INZ, INZ, INZ, OUT0, OUT1 }, /* D6 */ { INZ, INZ, INZ, OUT1, OUT0 }, /* D7 */ { OUT0, INZ, OUT1, INZ, INZ }, /* D8 */ { OUT1, INZ, OUT0, INZ, INZ }, /* D9 */ { INZ, INZ, OUT0, INZ, OUT1 }, /* D10 */ { INZ, INZ, OUT1, INZ, OUT0 }, /* D11 */ { INZ, OUT0, INZ, OUT1, INZ }, /* D12 */ { INZ, OUT1, INZ, OUT0, INZ }, /* D13 */ { OUT0, INZ, INZ, INZ, OUT1 }, /* D14 */ { OUT1, INZ, INZ, INZ, OUT0 } /* D15 */ };

La fonction programmeBroche(...) reste la même par contre la fonction gereLED(...) doit être modifiée puisque l'on passe de 3 à 5 broches de commande.

void gereLED(int num) { if (etatLED[num] == ALLUME) { programmeBroche(8,etatSortiePourLED[num][0]); programmeBroche(9,etatSortiePourLED[num][1]); programmeBroche(10,etatSortiePourLED[num][2]); programmeBroche(11,etatSortiePourLED[num][3]); programmeBroche(12,etatSortiePourLED[num][4]); } else { programmeBroche(8,INZ); programmeBroche(9,INZ); programmeBroche(10,INZ); programmeBroche(11,INZ); programmeBroche(12,INZ); } }

Et le tableau etatLED doit être agrandi pour contenir 16 éléments.

Intégration dans l'application

Pour intégrer l'allumage des témoins dans l'application il faut tout d'abord insérer l'appel à gereLED() dans loop(). Nous faisons face à un premier problème. Pour que les servomoteurs pivotent suffisamment lentement, l'attente est de 5ms. Cela conduit à un balayage des 16 LED en 80ms ce qui est trop lent pour que la persistance rétinienne opère. Il faudrait balayer au moins 4 fois plus souvent. Par conséquent, le délai dans loop() va être réduit à 1ms et la gestion des poussoirs et des servomoteurs sera appelée toutes les 5 fois alors que la gestion des LED sera appelée toutes les fois. Nous allons donc ajouter un compteur compteurGestionServos initialisé à 0. Comme ceci.

void loop() { compteurGestionServos++; if (compteurGestionServos == 5) { compteurGestionServos = 0; ... /* code de gestion des servos et des poussoir à l'identique */ ... } gereLED(numLED); numLED++; if (numLED == 16) numLED = 0; delay(1); }

Il suffit ensuite de changer l'état des LED en ALLUME ou ETEINT dans le tableau etatLED en fonction des événements. Deux fonctions membre de la classe DescripteurServo sont concernées : evenementServo(...) où on va éteindre la LED de la position que l'on quitte et gereServo() où on va allumer la LED de la position que l'on atteint. Dans le tableau etatLED, les LED sont alternativement rouges et vertes et par conséquent la paire de LED correspondant à un servomoteur est à la position numéro de servo × 2 (angle minimum) et numéro de servo × 2 + 1 (angle maximum).

void evenementServo() { cptArret = -1; switch (etatServo) { case SERVO_A_ANGLE_MIN: etatLED[numServo * 2] = ETEINT; objetServo.attach(pin); case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN: vitesse = 1; etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX; break; case SERVO_A_ANGLE_MAX: etatLED[numServo * 2 + 1] = ETEINT; objetServo.attach(pin); case SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX: vitesse = -1; etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN; break; } }

Dans la fonction membre gereServo(), la partie qui s'occupe du passage de la vitesse à 0 quand les angles minimum ou maximum sont atteint est modifiée comme suit :

if (! reglageEnCours || etatServo == SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN || etatServo == SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX) { if (angle > angleMax) { angle = angleMax; arreteServo(); etatServo = SERVO_A_ANGLE_MAX; etatLED[numServo * 2 + 1] = ALLUME; } else if (angle < angleMin) { angle = angleMin; arreteServo(); etatServo = SERVO_A_ANGLE_MIN; etatLED[numServo * 2] = ALLUME; } }

Il ne faut pas oublier d'allumer la LED correspondant à l'angle minimum dans la fonction membre connecte(...)

/* allume la LED correspondante */ etatLED[numServo * 2] = ALLUME;

Nous sommes parvenus au bout de ce développement. Voici le sketch de l'application complète à télécharger.

Sketch de l'application complète

mis à jour en version 1.1. La position des servos est désormais mémorisée dans l'EEPROM.

Dessin du montage complet

Attention : le montage montre les 8 servomoteurs alimentés par l'Arduino. Ce n'est pas possible en pratique et il est nécessaire d'avoir une alimentation 5V séparée pour les servomoteurs

Dessin du montage complet à télécharger en PDF

Attention : le montage montre les 8 servomoteurs alimentés par l'Arduino. Ce n'est pas possible en pratique et il est nécessaire d'avoir une alimentation 5V séparée pour les servomoteurs

Ainsi qu'une vidéo de démonstration.

Démonstration de l'application complète et terminée

[1] On peut noter que plus le nombre de LED est important, plus le temps d'allumage sur un cycle de balayage devient faible. En pratique, la luminosité n'est pas beaucoup plus faible avec 16 LED. Pour un plus grand nombre de LED, il peut être nécessaire de diminuer la valeur des résistances sans toutefois dépasser les capacités des entrées/sorties du micro-contrôleur