Catégories
Electronique

Piloter un moteur pas-à-pas PART 1 : l’électronique

Ce projet va permettre de piloter un moteur pas-à-pas avec l’utilisation de l’arbre flexible DREMEL pour faciliter son usage avec des vitesses plus faibles.

Suite à mon précédent article sur la création d’un adaptateur pour relier un moteur pas-à-pas à un arbre flexible DREMEL (https://fabdiy.fr/remplacer-une-dremel-par-nimporte-quel-moteur/), il faut piloter ce moteur. Ce point va donc se décomposer en deux parties.

La première partie concernera la partie électronique en tant que telle. Tandis que la seconde partie concernera la programmation du bloc de pilotage qui est présenté ici. Ceci fera l’objet d’un autre article.

Sans plus tardé, rentrons dans le vif du sujet.

Vue générale

Pour faire simple, on sait que le moteur a besoin d’une alimentation en 12V DC. Notre carte de commande (ici une Arduino NANO), d’une alimentation 5V DC. Le moteur est commandé par l’Arduino via un driver. Enfin, il est prévu d’avoir un afficheur LCD et un encodeur rotatif, pour afficher et gérer la vitesse du moteur.

Ces différents éléments présentés, j’ai généré le diagramme suivant avec PlantUML, afin que vous ayez une vue d’ensemble.

Vue générale du montage

On va affiner ce diagramme pour aboutir à un schéma plus précis de l’ensemble du montage (protection, shield à installer, choix techniques ….)

Alimentation du système

Pour faire fonctionner notre montage, on va avoir besoin de deux étages d’alimentations. Un premier pour passer du réseau EDF vers du 12V DC. Et un second du 12V vers 5V.

On peut prévoir la consommation du moteur avec environ 3A et une tension de 12V, soit 36W. J’ai choisi de m’orienter vers une alimentation de ce type :

alimentation industrielle 12V 3A

Toutefois, j’ai constaté une différence de prix minime entre l’alimentation 36W et 60W. Du coup je me suis rabattu vers la 60W pour prévoir un changement pour un moteur plus gourmand si nécessaire.

A cette alimentation, il faut ajouter un connecteur d’alimentation et un fusible de protection. J’ai choisi de m’orienter vers ce connecteur pour me simplifier la vie.

Connecteur d’alimentation avec bouton à bascule et fusible de protection

Avec ces deux éléments, on a traité le rectangle correspondant à l’alimentation principale du circuit.

Concernant la deuxième partie de l’alimentation du circuit, on va utiliser le régulateur de tension présent sur la carte Arduino. Celui-ci sur la documentation officielle de l’Arduino NANO utilise le composant LM1117IMPX-5.0.

envers de l’Arduino NANO et vue sur le régulateur de tension LM1117IMPX-5.0

Ce composant est capable de débiter un courant de 800mA minimum. Donc notre deuxième alimentation du système est réglée.

En effet, nous n’avons pas de grand consommateur de courant qui seront rattachés à l’Arduino. On peut donc se servir de son régulateur de 5V sans inquiétude.

Les entrées/sorties de l’Arduino

Sur ce projet, on souhaite afficher la vitesse de rotation du moteur grâce à un affichage LCD. Celui-ci est piloté via I2C. Nous aurons donc besoin d’utiliser les lignes SCL et SDA présentes respectivement sur les bornes A4 et A5.

arrière de l »affichage LCD
On voit la carte supplémentaire qui fait la conversion I2C vers l’affichage LCD
face avant de l’afficheur LCD

D’autre part, un encodeur rotatif avec un switch intégré, sera utilisé pour contrôler certains paramètres (vitesse max, vitesse courante, etc…). Cet encodeur rotatif est le module KY-040. La documentation détaillée sur son fonctionnement et sa mise en place est disponible avec le lien suivant :

https://www.handsontec.com/dataspecs/module/Rotary%20Encoder.pdf

Encodeur rotatif KY-040

Le problème de l’encodeur rotatif est qu’il faut utiliser trois lignes d’interruption. Deux pour déterminer le sens de rotation, et une pour détecter l’appui sur le switch. Or, sur l’Arduino NANO, nous n’en avons que deux de disponibles (INT0 et INT1). Il va falloir ruser…

Après quelques recherches en ligne, le site locoduino.fr à consacrer un article à l’utilisation d’autres lignes d’interruptions de l’ARDUINO (https://www.locoduino.org/spip.php?article64).

Je me permets ici de reprendre le tableau du lien qui présente les différentes interruptions disponibles.

SourceRôle
INT0Interruption externe sur la broche 2
INT1Interruption externe sur la broche 3
PCINT0Interruption externe sur les broches 8 à 13
PCINT1Interruption externe sur les broches A0 à A5
PCINT2Interruption externe sur les broches 0 à 7
Tableau de résumé des différentes lignes d’interruption.
Source : https://www.locoduino.org/spip.php?article64

Pour la dernière interruption dont nous avons besoin, il nous reste à disposition les lignes PCINT0 et PCINT2. Locoduino nous donne la réponse de la ligne à utiliser ici. En effet, INT0 et INT1 sont dans la plage couverte par PCINT2. Donc je vais choisir la ligne PCINT0 pour la troisième interruption dont j’ai besoin. Soit dans mon cas, la broche 8 (aussi appelé D8 dans la documentation Arduino). Ceci nous permettra d’avoir un programme ne fonctionnant qu’avec des interruptions.

Le dernier point à traiter avec l’Arduino est : quelles sont les broches dont nous allons avoir besoin pour piloter le moteur pas-à-pas ?

Ici, je vais utiliser le module suivant :

module popolu A4988
source : https://www.pololu.com/product/1182

Il s’agit d’un composant très répandu en impression 3D pour commander les moteurs pas-à-pas.

Nous allons avoir besoin d’une seule broche pour son pilotage. En effet, la documentation pololu (https://www.pololu.com/product/1182) indique qu’il faut deux broches minimums. Une pour le pas, une autre pour la direction. Vu que nous tournons dans un seul sens, on va utiliser une broche capable de générer des signaux PWM. Je vais ici retenir la broche D6.

Synthèse

Après avoir présenté les différents éléments retenus, on peut résumer les broches retenues et leurs rôles avec ce tableau :

Broche sur l’ArduinoaliasRôle
D2INT0gérer l’encodeur rotatif (DA)
D3INT1gérer l’encodeur rotatif (DT)
D8PCINT0gérer l’appui sur le switch de l’encodeur rotatif
D6/envoyer les pas au driver
A4SDAgérer les données sur le bus I2C (affichage lcd)
A5SCLgérer l’horloge du bus I2C (affichage lcd)
tableau résumé des broches retenues

Avec ce tableau, j’ai fait le schéma suivant avec EAGLE :

schéma simplifié des connexions à l’Arduino NANO

On peut y voir une partie des différents éléments que j’ai évoquée plus haut. Ce schéma va nous permettre de réaliser le programme. Le montage étant principalement fait avec des modules pré-assemblés, je n’ai pas développé l’ensemble des éléments et en cas de modification sur le montage final, aucune difficulté particulière n’est à noter.

Le seul point potentiel où une modification aura lieu, est sur le sens du pilotage du moteur pas-à-pas. C’est-à-dire la pin DIR du module POLOLU qui devra potentiellement être alimenté en +5V.

La partie électronique étant prête, il faut réaliser le programme. C’est le but du second article sur ce projet.

https://fabdiy.fr/piloter-un-moteur-pas-a-pas-part-2-:-le-programme/

Une réponse sur « Piloter un moteur pas-à-pas PART 1 : l’électronique »

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.