Fabrication d'un pilote pour moteur pas à pas

Je vous présente aujourd'hui un petit compte rendu de la réalisation d'un pilote de moteur pas à pas: vous y branchez un moteur et une alimentation, et il s'agit d'appuyer sur quelques boutons pour faire tourner le moteur dans un sens ou dans l'autre, modifier sa vitesse de rotation, etc.

Cet appareil peut se révéler utile lorsque vous désirez vérifier si un moteur pas à pas fonctionne correctement, ou pour utiliser un moteur pas à pas de façon manuelle, sans que son fonctionnement soit automatisé par des capteurs.

À la base de notre circuit:  le traditionnel duo Arduino/L293D, dont j'avais déjà parlé dans ce blog il y a quelques années déjà.  Mais cette fois, puisque je veux un produit autonome, j'ai choisi d'utiliser un circuit intégré Atmega 328 plutôt qu'une carte Arduino complète.

Un petit cahier des charges:

• Une seule alimentation permet d'alimenter à la fois le moteur pas à pas et les circuits intégrés Atmega et L293D.  Ces circuits intégrés nécessitent une tension de 5 V, alors que les moteurs requièrent souvent une plus grande tension:  un régulateur de tension est donc nécessaire.
• Un bouton poussoir  marche/arrêt permet de mettre le moteur en marche, ou de l'arrêter. Une LED s'allume pour indiquer si ce bouton  est à l'état "marche".
• Un bouton poussoir "marche inverse" permet d'inverser le sens de rotation du moteur.  Lui aussi est accompagné d'une LED indiquant si le mode "marche arrière" est en fonction.
• Un potentiomètre permet de modifier la vitesse de rotation du moteur.
• Un dernier bouton permet de faire tourner le moteur d'un seul pas à la fois.

Premier prototype, comportant une carte Arduino Uno

Même si le but final était de produire un circuit autonome comportant un microcontrôleur Atmega 328, j'ai tout de même commencé, dans une première phase de développement et de débogage, par un prototype sur platine d'essai branché à une carte Arduino Uno.

À cette étape, la carte Arduino fournit l'alimentation du circuit intégré, mais le moteur est alimenté par une source de tension externe.

Pour les 3 boutons, j'ai choisi d'utiliser les résistances pull-up interne de l'Arduino.  C'est pour cette raison que mes boutons ne comportent pas de résistance pull-up ou pull-down visible sur le circuit.

Le schéma ci-dessous montre où brancher chaque pin du L293D.

Et voici un schéma du circuit complet...

Sketch

Le sketch utilise la bibliothèque "stepper" qui est fournie avec l'IDE Arduino.  Puisque j'utilise les résistances pullup internes, digitalRead retourne "0" quand les boutons sont enfoncés, et "1" quand ils ne le sont pas.

	/**********************************************************
	Pilote de moteur pas à pas.
	Un bouton permet de mettre le moteur en marche et de
	l'arrêter. Un autre bouton permet d'inverser le sens
	de rotation. Un potentiomètre contrôle la vitesse de
	rotation. Un dernier bouton permet de faire tourner
	le moteur d'un seul pas.
	http://electroniqueamateur.blogspot.ca/2017/01/fabrication-dun-pilote-pour-moteur-pas.html
	**********************************************************/
	#include <Stepper.h>
	// initialisation de la bibliothèque stepper
	// 200 est une valeur bidon pour le nombre de pas par révolution
	// (ça dépend du moteur).
	Stepper myStepper(200, 8, 9, 10, 11); // les pins 8, 9, 10, 11 sont reliés au L293D
	const int boutonMarche = 7; // bouton marche-arrêt branché à la pin 7
	const int ledBoutonMarche = 6; // LED qui indique si le bouton marche-arrêt est enfoncé ou non
	const int boutonReverse = 5; // bouton marche arrière branché à la pin 5
	const int ledBoutonReverse = 4; // LED qui indique si le bouton marche arrière est enfoncé ou non
	const int bouton1Pas = 3; // bouton qui fait tourner le moteur d'un seul pas branché à la pin 3
	bool enMarche = 0, boutonAvant = 1, boutonMaintenant = 1;
	bool reverse = 0, boutRevAvant = 1, boutonRevMaintenant = 1;
	int vitesse;
	void setup() {
	pinMode(boutonMarche, INPUT); // pin 7 sera une entrée
	digitalWrite(boutonMarche, HIGH); // on active sa résistance pull-up interne
	pinMode(ledBoutonMarche, OUTPUT); // LED indicatrice
	pinMode(boutonReverse, INPUT); // pin 4 sera une entrée
	digitalWrite(boutonReverse, HIGH); // on active sa résistance pull-up interne
	pinMode(ledBoutonReverse, OUTPUT); // LED indicatrice
	pinMode(bouton1Pas, INPUT); // pin 3 sera une entrée
	digitalWrite(bouton1Pas, HIGH); // on active sa résistance pull-up interne
	}
	void loop() {
	// le bouton marche-arrêt est-il enfoncé?
	boutonMaintenant = digitalRead(boutonMarche);
	// si le bouton est enfoncé et qu'il ne l'était pas la dernière
	// fois qu'on a vérifié, alors on change l'état de la variable enMarche.
	if (boutonAvant && !boutonMaintenant)
	{
	enMarche = !enMarche;
	}
	// le bouton de marche arrière est-il enfoncé?
	boutonRevMaintenant = digitalRead(boutonReverse);
	// si le bouton est enfoncé et qu'il ne l'était pas la dernière
	// fois qu'on a vérifié, alors on change l'état de la variable reverse.
	if (boutRevAvant && !boutonRevMaintenant)
	{
	reverse = !reverse;
	}
	// si le bouton "1 seul pas" est enfoncé, alors
	// on fait tourner le moteur d'un seul pas
	if (!digitalRead(bouton1Pas)) {
	if (reverse) {
	myStepper.step(-1);
	}
	else {
	myStepper.step(1);
	}
	// on attend un peu, pour éviter de tourner de plusieurs pas
	// si le bouton reste enfoncé un peu trop longtemps
	delay(300);
	}
	// pour le prochain passage dans la boucle:
	boutonAvant = boutonMaintenant;
	boutRevAvant = boutonRevMaintenant;
	// mise à jour des LEDs
	digitalWrite(ledBoutonMarche, enMarche);
	digitalWrite(ledBoutonReverse, reverse);
	if (enMarche) {
	// lecture du potentiomètre de contrôle de vitesse
	vitesse = 1023 - analogRead(A0);
	// on tourne d'un pas
	if (reverse) {
	myStepper.step(-1);
	}
	else {
	myStepper.step(1);
	}
	// une pause pour contrôler la vitesse
	delay(1 + vitesse);
	}
	}

view raw pilote_pas_a_pas.ino hosted with ❤ by GitHub

Deuxième prototype, comportant un Atmega 328 sur breadboard

Rien ne vous empêche de vous arrêter à cette étape du circuit et, par exemple, en faire un shield pour votre carte Arduino.  Mais comme je le mentionnais au début de l'article, je préférais produire un circuit pouvant fonctionner de façon parfaitement autonome.

L'étape suivante consistait donc à graver le bootloader sur un Atmega 328 vierge, puis à y graver mon sketch. Pour une marche à suivre détaillée, je vous invite à consulter mon vieil article intitulé "Fabriquer son propre Arduino sur une breadboard".

Il restait ensuite à migrer les connexions de la carte Uno vers l'Atmega, d'ajouter un quartz de 16 MHz, ainsi qu'un régulateur de tension LM7805.

Le schéma ci-dessous indique où est branchée chaque pin de l'Atmega 328.

Du côté, du L293, ça demeure la même chose que dans le circuit précédent:

Les deux circuits intégrés demandent des tension d'alimentation de 5 V, alors que notre moteur pas à pas en exigera peut-être plus, d'où l'utilisation d'un régulateur linéaire  LM7805 qui abaissera la tension de départ (7 V ou plus) en une tension de 5 V.  J'en ai profité pour ajouter une LED qui indique que la carte est alimentée.

Et voici le schéma complet du circuit...

Le produit fini 

Voici le circuit proprement soudé sur une plaque pastillée.  Tout fonctionne tel que désiré.

Yves Pelletier   (Twitter, Facebook)