Enrouleur contrôlé par Arduino

Utilisation du shield moteur Arduino et d'un moteur pas à pas pour enrouler des fils de longueur donnée sur des bobines.

Dans l'article Contrôle de moteur pas à pas Arduino, j'ai expliqué ce qu'était un moteur pas à pas, son fonctionnement et les différents types possibles. J'ai également connecté un moteur pas à pas au shield moteur Arduino que j'avais au préalable monté sur une carte Arduino Uno et créé un schéma fonctionnel.

Le moteur utilisé pour mon projet avait des engrenages et, par conséquent, ne tournait pas aussi vite que je le voulais pour ce projet. Dans cet article, je vais utiliser un moteur pas à pas différent pour enrouler du fil sur une bobine en bois. Je vais également ajouter des commutateurs pour contrôler la quantité de fil à enrouler.

Vitesse maximale du moteur

J'ai connecté le nouveau moteur pas à pas avec un fil par canal sur la carte et utilisé à nouveau le schéma qui avait fait ses preuves dans l'article précédent, en modifiant uniquement le nombre de pas par révolution pour le nouveau moteur, et tout semble fonctionner correctement.

Le nouveau moteur semblait fonctionner beaucoup plus rapidement que le moteur pas à pas utilisé dans mon article précédent. J'ai supposé que c'était dû au fait qu'il n'avait pas d'engrenages. Quoi qu'il en soit, si sa vitesse était bien supérieure au moteur précédent, il n'en restait pas moins très lent. Pour y remédier, j'ai commencé par modifier la vitesse dans le programme, en la faisant changer de 5 à 10, ce qui a produit des rotations plus rapides et fluides, mais ne donnait toujours pas une vitesse suffisante. J'ai donc fait passer la vitesse à 50 et le moteur a suivi sans problème, mais semblait pouvoir aller encore plus vite.

J'ai donc poussé la vitesse jusqu'à 200, ce qui était très rapide, et j'ai voulu déterminer la vitesse maximale avant d'aller plus loin. Lorsque j'ai atteint la vitesse de 300, le moteur n'a plus tourné du tout et, par conséquent, j'ai estimé que la vitesse maximale devait se situer quelque part entre 200 et 300. J'ai donc procédé de façon empirique pour trouver la vitesse maximale exacte :

250 donnait de bons résultats,
275 faisait tourner le moteur de façon incomplète, sur uniquement 20 degrés environ.
260 fonctionnait correctement
265 ne donnait que des rotations sur 180°

À ce stade, j'ai conclu que la vitesse maximale du moteur devait être de 265, mais je me suis cantonné à 250 pour éviter les mauvaises surprises. Une fois la vitesse maximale du moteur établie, j'ai pu m'attaquer à la définition du nombre de rotations nécessaires pour l'enroulement du fil.

Déterminer le brochage des commutateurs

Les commutateurs que j'ai choisis étaient de type 1NO, à bouton-poussoir miniature, (momentanés), intégrant une LED. Quatre broches sont disponibles : deux pour la LED et deux pour le commutateur. La fiche technique de ces commutateurs comporte des marques précisant la répartition de ces broches, mais je ne les ai pas retrouvées sur la partie inférieure du commutateur.

J'ai trouvé les contacts du commutateur en utilisant un multimètre réglé sur la mesure de continuité, en appuyant sur le commutateur et en le relâchant.

Je suis ensuite revenu à la fiche technique pour connaître la tension nominale de chaque LED de couleur, de sorte que je puisse les mettre sous tension pour trouver l'anode et la cathode. J'avais un commutateur pour le rouge et un autre pour le vert. Par conséquent, j'ai utilisé une alimentation de table et l'ai réglée sur 2,1 V en limitant le courant à 20 mA pour le rouge et sur 1,95 V et 20 mA pour le vert. Il ne me restait plus qu'à attendre que la LED s'allume pour déterminer l'orientation des broches et reporter des marques sur l'anode, de façon à éviter tout problème lors du câblage. Dans notre exemple, les broches de LED étaient les deux plus longues.

Une fois les broches identifiées, j'ai dû trouver deux entrées libres pour les boutons et deux sorties pour les LED sur le module Arduino. En consultant les schémas du shield moteur Arduino, j'ai constaté que les broches 10, 7, 4 et 2 étaient libres, ainsi que les deux connexions TinkerKit orange (broches 5 et 6), broche 1 (Tx) et broche 0 (Rx). J'ai décidé d'utiliser les broches 10 et 4 comme entrées pour les boutons, et les broches 7 et 2 comme sorties pour les LED. J'ai donc ajouté des résistances de démarrage sur les entrées, de sorte que ces dernières ne soient jamais dans un état flottant, en complément des résistances correspondantes requises pour les LED.

Pour commencer, j'ai câblé un commutateur avec LED pour m'assurer que mon hypothèse était correcte, puis j'ai ajouté cela au schéma. Le schéma ci-dessous illustre comment j'ai câblé un bouton et une LED.

Après quelques tâtonnements, je suis parvenu à une version fonctionnelle, avant de connecter le deuxième ensemble bouton et LED de la façon suivante :

Voici le schéma de montage de mon circuit.

Mise en oeuvre d'une machine d'état

Lorsque le bouton est actionné, la LED doit s'allumer et le moteur effectuer trois tours. Cette opération a fonctionné, mais pas tout à fait comme prévu. En effet, lorsque le bouton était activé, il commençait sur la partie haute de l'appui (ovale rouge), alors que je voulais une activation pendant que le bouton était enfoncé (ovale vert). Après discussion avec un collègue, j'ai dû inclure une machine d'état dans mon code.

Une machine d'état est "un dispositif qui peut être dans l'un des états stables définis en fonction de son état précédent et des valeurs présentes de ses entrées". L'idée générale étant que si l'état du bouton est bas, alors qu'il était haut précédemment, la LED s'allume et le moteur commence à tourner.

Après avoir mis en oeuvre ma machine d'état, mon prototype a fonctionné comme je le souhaitais et j'ai pu passer à la conception d'une plaque pour monter le module Arduino, le moteur et la bobine.

Conception robuste

Je voulais obtenir quelque chose d'un peu plus permanent qu'un montage expérimental et pour cela, j'ai utilisé un shield Arduino de prototypage à monter simplement sur le shield moteur de la carte Uno. Après avoir cartographié les connexions des commutateurs et des résistances sur le shield, j'ai soudé tous les composants concernés avant de passer à la conception de la plaque de montage. Le résultat était beaucoup plus compact et ordonné que la version expérimentale du circuit, ce qui signifiait également que je pouvais câbler les commutateurs choisis directement sur le shield.

Conception mécanique

J'ai conçu la plaque acrylique pour monter les pièces dans Inkscape. Cette plaque sera ensuite coupée au laser, puis chauffée et pliée à l'avant pour accueillir les boutons-poussoirs.

Une fois cette plaque conçue, j'en ai découpé un prototype dans du contreplaqué, afin de m'assurer que tout était à sa place et que la taille des perçages était adéquate. Malheureusement, parce que ce prototype était en contreplaqué, je n'ai pas pu plier l'avant du panneau comme cela devait être le cas avec une plaque en acrylique.

Tout était à sa place sur le prototype et correspondait à l'idée que je m'en faisais, à l'exception du rebord impossible à reproduire en contreplaqué. Dans la mesure où tout était à sa place, j'ai découpé la base de montage dans une plaque en acrylique transparente de 3 mm et relevé le bord pour monter les commutateurs.

Ensuite, j'ai pu assembler les commutateurs. J'ai utilisé les quatre broches pour lier la cathode de la LED et l'une des broches du commutateur afin de former un circuit GND commun, puis j'ai connecté l'anode de la LED à l'embase du prototype de shield Arduino. Cette opération a été répétée pour les deux commutateurs, ce qui a donné un total de six fils depuis le shield de prototypage.

Les cartes Arduino, le moteur pas à pas et la bobine de fil étaient tous fixés solidement sur la carte, et les commutateurs ont été insérés sur le rebord. Une fois cette opération terminée, j'ai testé l'ensemble, qui a fonctionné exactement comme prévu.

Modifications envisageables a posteriori

Je ne changerais que deux choses si je devais revoir la conception de la platine de montage. La première étant l'orientation des cartes Arduino, dans la mesure où les fiches jack et les adaptateurs USB situés à droite des câbles sont trop tassés et qu'il faut dévisser l'adaptateur USB de la platine pour connecter le module Arduino. Une meilleure solution serait de ménager plus d'espace entre le module Arduino et le moteur pas à pas. Néanmoins, il faudrait un écart considérable pour pouvoir y glisser des doigts et procéder à la connexion. Malheureusement, je n'ai pas su anticiper ce problème sur la platine de montage du prototype.

La seule autre chose que je changerais serait la bobine, car elle a beaucoup de jeu et, lorsqu'elle tournait sur la plaque de contreplaqué, elle était très encombrante. Je pense que c'est dû au manque de résistance de la bobine, qui continue à dévider le fil une fois le moteur arrêté par inertie. Ce problème pourrait probablement être résolu en écartant la bobine du moteur ou en ajoutant davantage de panneaux en acrylique avec des perçages pour le fil à différentes hauteurs, afin de donner plus de résistance à la bobine.

En dehors de ces deux modifications mineures, je suis très satisfait de mon enrouleur contrôlé par Arduino ! Je trouve l'acrylique transparent très esthétique et pratique pour le montage des composants. J'ai également beaucoup appris sur les moteurs pas à pas au cours de ce processus, et je suis passé d'un stade de simple découverte au décryptage de leur mode de codage, et à l'utilisation du shield moteur Arduino. Je suis vraiment très content des résultats de ce projet.