L'Arduino Motor Shield est un module qui s'imbrique sur la carte Arduino facilitant le contrôle des moteurs à courant continu ou les moteurs pas à pas.
Dans ce tutoriel, vous découvrirez les schémas pour alimenter des moteurs à courant continu ou un moteur pas à pas unipolaire avec le Shield Motor R3 de la marque Deek-Robot. Découvrez les plans de raccordement et les
programmes Arduino pour piloter vos moteurs.
Le Motor Shield utilisé dans l'article est celui de marque Deek-Robot équipé d'un circuit intégré L298P. Ce module s'ajoute par-dessus l'Arduino Uno ou Arduino Mega pour simplifier les raccordements. En effet, aucune liaison supplémentaire n'est nécessaire
pour relier l'Arduino au Shield moteur. Cette carte permet de piloter des moteurs, ainsi, il sera possible de commander jusqu'à deux moteurs à courant continu ou un seul moteur pas à pas.
Les raccordements entre l'Arduino et le module sont réalisés lors de la superposition des cartes (pas de connexion supplémentaire contrairement au module L293D utilisé dans de ce tutoriel).
Circuit intégré L298P
L'Arduino Motor Shield Rev3 dispose d'un circuit intégré L298P qui est un driver moteur équipé d'un double pont en H 2x2A qui supporte une tension d'alimentation
jusqu'à 46V.
Il permet d'alimenter et de piloter de nombreuses charges tels que des charges inductives de type relais, des solénoïdes,
des moteurs à courant continu et des moteurs pas à pas.
Vous trouverez ci-dessous la documentation ou datasheet du circuit intégré L298P :
Voici la documentation ou datasheet du circuit intégré L298P équipant l'Arduino Motor Shield rev3 :
Borniers à vis pour l'alimentation et les moteurs
Afin d'alimenter le Shield Moteur, il faut utiliser les vis repérées VIN et GND placées à droite du bornier.
Les bornes repérées A+ et A- permettent de connecteur un premier moteur à courant continu sur la voie A ou Channel A.
Les bornes à vis identifiées B+ et B- correspondent
au Channel B pour le raccordement d'un second moteur à courant continu.
Pour un moteur pas à pas, il faut raccorder les 4 bornes repérées A+ A- B+ B-. Chacune de ces bornes alimente l'une des bobines du moteur et permet au final de le faire tourner.
Pour l'alimentation d'un moteur pas à pas unipolaire (voir plus bas), j'utilise la convention suivante :
• Bobine 1 ➡️ Borne B-
• Bobine 2 ➡️ Borne B+
• Bobine 3 ➡️ Borne A-
• Bobine 4 ➡️ Borne A+
Broches Arduino réservées pour le Motor Shield
Vous vous demandez peut-être quels sont les pins Arduino utilisés pour la commande du Shield moteur.
En effet, pour pouvoir utiliser ce driver moteur avec l'Arduino, il est nécessaire de connaître les pins réservées.
Eh bien, voici ci-dessous les broches réservées à la commande du Motor Shield : Pour le moteur A
• Pin n°12 (broche digitale pour la direction)
• Pin n°3 (broche PWM pour la vitesse)
• Pin n°9 (broche digitale pour le Frein)
• Pin n°A0 (broche analogique pour la Consommation) Pour le moteur B
• Pin n°13 (broche digitale pour la direction)
• Pin n°11 (broche PWM pour la vitesse)
• Pin n°8 (broche digitale pour le Frein)
• Pin n°A1 (broche analogique pour la Consommation)
Il est donc possible de connaître le courant délivré par le Motor Shield, pour cela, il faut lire les bornes analogiquesA0 et A1.
La valeur envoyée sur les bornes analogiques est codée sur 8 bits soit une valeur maximale de 255 qui correspond à la valeur maximale du courant délivré par le Shield moteur soit 2 Ampères.
Pour calculer l'intensité consommée par un moteur, il faut réaliser un produit en croix : 2 × Valeur / 255 = Mesure Intensité (A)
Avec l'Arduino, il est possible d'utiliser la fonction map() pour calculer l'intensité absorbée par le moteur :
Pour récupérer les décimales, je convertis 2A -> 2000mA et le résultat final sera divisé par 1000,
pour obtenir un résultat à dont l'unité est Ampère.
Intensite = map(Intensite_mesuree, 0, 255, 0, 2000)// Mappage de l'intensité sur la résolution 255 et valeur max 2000mAIntensite = Intensite / 1000// Mappage de l'intensité sur la résolution 255 et valeur max 2000mA
Le circuit intégré L298P est équipé de 20 broches permettant de piloter les moteurs.
Le Motor Shield avec un moteur à courant continu :
Câblage du Motor Shield avec un actionneur linéaire (12VDC)
L'actionneur linéaire est un vérin à commande électrique. L'action du vérin est réalisée à l'aide d'un moteur à courant continu 12V dans mon cas. Celui que j'utilise
pour la porte automatique de poulailler à une course de 30 cm, vous pouvez vous le procurer en suivant ce lien.
L'actionneur linéaire permet de transformer le mouvement de rotation du moteur en mouvement linéaire. Il développe un couple élevé et permet l'ouverture de trappe, d'une porte ou d'un portail,
le suivi solaire pour les panneaux photovoltaïque, l'élévation de chariot ou de lit médicalisé.
Cet actionneur linéaire est actionné par un moteur à courant continu, son raccordement est donc identique.
Câblage du Motor Shield avec un seul Moteur DC
Pour alimenter un moteur à courant continu avec le Shield moteur, vous devrez choisir entre la voie A ou B.
Voici le plan de raccordement d'un moteur DC sur la voie A du Motor Shield.
Programmation Arduino du Motor Shield avec un moteur DC
Commande Moteur Channel A (A- A+)
Rotation dans le sens normal à pleine vitesse du moteur sur le canal A :
void setup() {
//Configuration du Canal A
pinMode(12, OUTPUT); // Broche Arduino réservée pour le sens de rotation du moteur A
pinMode(9, OUTPUT); // Broche Arduino réservée pour le freinage du moteur A
}
void loop(){
digitalWrite(12, HIGH); // Le moteur A tourne dans le sens normal
digitalWrite(9, LOW); // Désactivation du frein moteur A
analogWrite(3, 255); // Vitesse maximale pour le moteur A
}
Rotation dans le sens inverse à pleine vitesse du moteur sur le canal A :
void setup() {
//Configuration du Canal A
pinMode(12, OUTPUT); // Broche Arduino réservée pour le sens de rotation du moteur A
pinMode(9, OUTPUT); // Broche Arduino réservée pour le freinage du moteur A
}
void loop(){
digitalWrite(12, LOW); // Le moteur A tourne dans le sens inverse
digitalWrite(9, LOW); // Désactivation du frein moteur A
analogWrite(3, 255); // Vitesse maximale pour le moteur A
}
Rotation dans le sens normal à demie vitesse du moteur sur le canal A :
void setup() {
//Configuration du Canal A
pinMode(12, OUTPUT); // Broche Arduino réservée pour le sens de rotation du moteur A
pinMode(9, OUTPUT); // Broche Arduino réservée pour le freinage du moteur A
}
void loop(){
digitalWrite(12, LOW); // Le moteur A tourne dans le sens normal
digitalWrite(9, LOW); // Désactivation du frein moteur A
analogWrite(3, 127); // Demie vitesse pour le moteur A
}
Rotation dans le sens inverse à pleine vitesse du moteur sur le canal A et mesure de la consommation avec affichage sur le moniteur série :
float Intensite=0;
void setup() {
Serial.begin(9600); // Ouverture du port série et débit de communication fixé à 9600 bauds
//Configuration du Canal A
pinMode(12, OUTPUT); // Broche Arduino réservée pour le sens de rotation du moteur A
pinMode(9, OUTPUT); // Broche Arduino réservée pour le freinage du moteur A
}
void loop(){
digitalWrite(12, LOW); // Le moteur A tourne dans le sens inverse
digitalWrite(9, LOW); // Désactivation du frein moteur A
analogWrite(3, 255); // Vitesse maximale pour le moteur A
Intensite=analogRead(A0); // Lecture de l'entrée analogique A0
Intensite=map(Intensite, 0, 255, 0, 2000); // Mappage de l'intensité en milliAmpère
Intensite=Intensite/1000; // Convertion de l'intensité en Ampère
Serial.print("Consommation ="); // Affichage du texte
Serial.println(Intensite); // Affichage de l'intensité conosmmée par le moteur connecté sur la voie A
}
Rotation dans le sens normal à pleine vitesse du moteur sur le canal A pendant 10 secondes puis freinage du moteur pour l'arrêter pendant 5 secondes :
void setup() {
//Configuration du Canal A
pinMode(12, OUTPUT); // Broche Arduino réservée pour le sens de rotation du moteur A
pinMode(9, OUTPUT); // Broche Arduino réservée pour le freinage du moteur A
}
void loop(){
digitalWrite(12, HIGH); // Le moteur A tourne dans le sens normal
digitalWrite(9, LOW); // Désactivation du frein moteur A
analogWrite(3, 255); // Vitesse maximale pour le moteur A
delay (10000); // Attente de 10 secondes
digitalWrite(9, HIGH); // Activation du freinage du moteur A
delay (5000); // Attente de 5 secondes
}
Câblage du Motor Shield avec deux Moteurs DC
Le Motor Shield permet également d'alimenter deux moteurs à courant continu. Le premier moteur DC est câblé
sur la voie A et le second sera relié sur la voie B.
Programmation Arduino du Motor Shield avec deux moteurs DC
Commandes des Moteurs Channel A & B (A- A+ B- B+)
Rotation dans le sens normal à pleine vitesse du moteur sur la voie A et
rotation dans le sens inverse à demie vitesse pour le moteur sur la voie B :
void setup() {
//Configuration du Canal A
pinMode(12, OUTPUT); // Broche Arduino réservée pour le sens de rotation du moteur A
pinMode(9, OUTPUT); // Broche Arduino réservée pour le freinage du moteur A
pinMode(13, OUTPUT); // Broche Arduino réservée pour le sens de rotation du moteur B
pinMode(8, OUTPUT); // Broche Arduino réservée pour le freinage du moteur B
}
void loop(){
digitalWrite(12, HIGH); // Le moteur A tourne dans le sens normal
digitalWrite(9, LOW); // Désactivation du frein moteur A
analogWrite(3, 255); // Vitesse maximale pour le moteur A
digitalWrite(13, LOW); // Le moteur B tourne dans le sens normal
digitalWrite(8, LOW); // Désactivation du frein moteur B
analogWrite(11, 127); // Demie vitesse pour le moteur B
}
Le Motor Shield avec un moteur pas à pas :
Il est possible d'utiliser le Motor Shield pour commander un moteur pas à pas également appelé Stepper Motor.
Que ce soit un moteur bipolaire ou un moteur unipolaire, vous pourrez le commander via le circuit intégré L298P.
Le principe de raccordement changera en fonction du nombre de conducteurs de votre moteur pas à pas 4 fils ou 5 fils.
Pour en savoir plus sur le principe de fonctionnement d'un moteur pas à pas, les schémas électriques et les séquences pour
la commande d'alimentation des bobines du moteur vous pouvez
consulter cet article.
Découverte du moteur pas à pas et son utilisation avec une Arduino.
Câblage du Motor Shield avec un moteur pas-à-pas bipolaire
Dans le cas d'un moteur pas à pas bipolaire, vous disposez de 4 fils à raccorder au Shield Moteur.
Vous devez dans un premier temps localiser les bobines du moteur bipolaire à l'aide
d'un ohmmètre.
Le moteur pas à pas utilisé est équipé de 4 conducteurs repérés des couleurs Rouge | Bleu | Jaune | Blanc. L'objectif est de trouver les paires de conducteurs
entre lesquelles se trouvent les bobines du moteur.
Recherche des bobines d'un moteu pas à pas bipolaire avec un ohmmètre :
La première mesure se fait entre les conducteurs bleu et le blanc. Le multimètre affiche OL (Over Load), la valeur mesurée est trop grande, le circuit est donc ouvert. Il n'y a donc pas de continuité de bobine entre ces deux fils.
La seconde mesure est faite entre les conducteurs jaune et le blanc. Le multimètre affiche 8,46Ω, la valeur mesurée correspond à un bobinage moteur. On vient d'identifier les bornes A et C du moteur.
Les mesures précédentes ont permises de localiser les enroulements du moteur.
Ainsi entre les conducteurs Jaune et Blanc se trouve le premier enroulement à raccorder sur A- et A+, et le second enroulement correspond
aux conducteurs rouge et bleu à relier sur B- et B+.
Programmation Arduino pour moteur Bipolaire
ProgrammeMoteur bipolaire | Mode Wave :
La commande en Mode Wave d'un moteur bipolaire nécessite 4 broches de l'Arduino :
• Broche n°3 en sortie Digitale PWM
• Broche n°11 en sortie Digitale PWM
• Broche n°12 en sortie Digitale
• Broche n°13 en sortie Digitale
Retrouvez ci-dessous, le chronogramme qui correspond à la séquence d'alimentation des bobines du moteur. Les bornes utilisées sur le Shield Moteur sont A+|A-|B+|B-|.
Dans le programme ci-dessous, les pas du moteur sont exécutés toute les 40 ms : delay(40), pour réduire la vitesse ou pour l'augmenter, il suffit de changer la valeur contenue dans le delay(XX).
void setup() {
pinMode(3, OUTPUT); // Déclaration de la broche n°3 en sortie Digitale PWM
pinMode(11, OUTPUT); // Déclaration de la broche n°11 en sortie Digitale PWM
pinMode(12, OUTPUT); // Déclaration de la broche n°12 en sortie Digitale
pinMode(13, OUTPUT); // Déclaration de la broche n°13 en sortie Digitale
}
void loop(){
// Commande moteur pas à pas Bipolaire 4 fils en Mode Wave | Sens Normal// Pas n°1 | Sortie B- du Shield Moteur -> Bobine A du moteur pas à pas
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
analogWrite(3, 0);
analogWrite(11, 255);
delay(40);
// Pas n°2 | Sortie A- du Shield Moteur -> Bobine C du moteur pas à pas
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
analogWrite(3, 255);
analogWrite(11, 0);
delay(40);
// Pas n°3 | Sortie B+ du Shield Moteur -> Bobine B du moteur pas à pas
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
analogWrite(3, 0);
analogWrite(11, 255);
delay(40);
// Pas n°4 | Sortie A+ du Shield Moteur -> Bobine D du moteur pas à pas
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
analogWrite(3, 255);
analogWrite(11, 0);
delay(40);
}
Vous trouverez ci-dessous la séquence pour faire tourner le moteur pas à pas bipolaire dans le sens inverse. Ce bout de
code doit être inséré dans une boucle while() ou for() ou la boucle fonction loop() de l'Arduino.
// Commande moteur pas à pas Bipolaire 4 fils en Mode Wave Sens inverse// Pas n°1 | Sortie A+ du Shield Moteur -> Bobine D du moteur pas à pas
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
analogWrite(3, 255);
analogWrite(11, 0);
delay(200);
// Pas n°2 | Sortie B+ du Shield Moteur -> Bobine B du moteur pas à pas
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
analogWrite(3, 0);
analogWrite(11, 255);
delay(200);
// Pas n°3 | Sortie A- du Shield Moteur -> Bobine C du moteur pas à pas
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
analogWrite(3, 255);
analogWrite(11, 0);
delay(200);
// Pas n°4 | Sortie B- du Shield Moteur -> Bobine A du moteur pas à pas
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
analogWrite(3, 0);
analogWrite(11, 255);
delay(200);
Câblage du Motor Shield avec un moteur pas-à-pas unipolaire
Si vous disposez d'un moteur pas à pas unipolaire 5 fils voici le schéma électrique permettant de le raccorder
au Shield Moteur.
Le câblage d'un moteur pas à pas sur le Motor Shield monopolise les 4 borniers |A+|A-|B+|B-|, il ne sera donc plus possible d'ajouter de moteur supplémentaire.
Programmation Arduino du Motor Shield (Stepper Motor)
Pour faire tourner le moteur pas à pas unipolaire, il est nécessaire d'alimenter à tour de rôle les bobines du moteur. Il faut repsecter une séquence propre à chaque
catégorie de moteur. Dans les programmes ci-dessous, vous découvrirez deux séquences d'alimentation qui sont le Mode Wave et le Full Step.
ProgrammeMoteur unipolaire| Mode Wave :
La commande en Mode Wave d'un moteur unipolaire monopolise 4 broches de l'Arduino :
• Broche n°3 en sortie Digitale PWM
• Broche n°11 en sortie Digitale PWM
• Broche n°12 en sortie Digitale
• Broche n°13 en sortie Digitale
Voici la séquence d'alimentation des bobines du moteur. Les bornes utilisées sur le Shield Moteur sont A+A-B+B-.
Par simplicité, j'ai gardé l'ordre repéré sur le borniers : B- B+ A- A+.
Par rapport à la séquence précédente, j'ai donc la correspondance suivante :
La bobine A est cablée sur B-
La bobine B est cablée sur B+
La bobine C est cablée sur A-
La bobine D est cablée sur A+
Voici le programme permettant de faire tourner un moteur pas à pas unipolaire
d'un pas toutes les 20 milliseconde, soit plus d'un tour complet ou 360° par seconde (moteur de 48 pas) :
void setup() {
pinMode(3, OUTPUT); // Déclaration de la broche n°3 en sortie Digitale PWM
pinMode(11, OUTPUT); // Déclaration de la broche n°11 en sortie Digitale PWM
pinMode(12, OUTPUT); // Déclaration de la broche n°12 en sortie Digitale
pinMode(13, OUTPUT); // Déclaration de la broche n°13 en sortie Digitale
}
void loop(){
// Commande moteur pas à pas Unipolaire 5 fils en Mode Wave// Pas n°1 | Sortie B- du Shield Moteur -> Bobine A du moteur pas à pas
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
analogWrite(3, 0);
analogWrite(11, 255);
delay(20);
// Pas n°2 | Sortie B+ du Shield Moteur -> Bobine B du moteur pas à pas
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
analogWrite(3, 0);
analogWrite(11, 255);
delay(20);
// Pas n°3 | Sortie A- du Shield Moteur -> Bobine C du moteur pas à pas
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
analogWrite(3, 255);
analogWrite(11, 0);
delay(20);
// Pas n°4 | Sortie A+ du Shield Moteur -> Bobine D du moteur pas à pas
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
analogWrite(3, 255);
analogWrite(11, 0);
delay(20);
}
ProgrammeMoteur unipolaire| Full Step :
La commande en pas complet ou "Full Step" d'un moteur unipolaire monopolise 6 broches de l'Arduino.
• Broche n°3 en sortie Digitale en PWM
• Broche n°8 en sortie Digitale
• Broche n°9 en sortie Digitale
• Broche n°11 en sortie Digitale en PWM
• Broche n°12 en sortie Digitale
• Broche n°13 en sortie Digitale
La commande à pas complet permet d'augmenter le couple du moteur
par rapport à la commande précédente (Mode Wave), par contre le courant absorbé est également plus élevé. Voici la séquence d'alimentation des bobines du moteur en Full Step.
Voici le programme permettant de faire tourner un moteur pas à pas unipolaire
d'un pas toutes les 20 milliseconde, soit plus d'un tour complet ou 360° par seconde (moteur de 48 pas) :
void setup() {
pinMode(3, OUTPUT); // Déclaration de la broche n°3 en sortie Digitale PWM
pinMode(8, OUTPUT); // Déclaration de la broche n°8 en sortie Digitale
pinMode(9, OUTPUT); // Déclaration de la broche n°8 en sortie Digitale
pinMode(11, OUTPUT); // Déclaration de la broche n°11 en sortie Digitale PWM
pinMode(12, OUTPUT); // Déclaration de la broche n°12 en sortie Digitale
pinMode(13, OUTPUT); // Déclaration de la broche n°13 en sortie Digitale
}
void loop(){
// Commande moteur pas à pas Unipolaire 5 fils en Full Step// Pas n°1 | Sorties B- et B+ du Shield Moteur -> Bobines A et B du moteur pas à pas
digitalWrite(8, HIGH); //Activation Pin n°8
digitalWrite(9, LOW); //Désactivation Pin n°9
digitalWrite(12, LOW); //Désactivation Pin n°12
digitalWrite(13, HIGH); //Activation Pin n°13
analogWrite(3,0); //Pin 3 PWM valeur 0
analogWrite(11, 255); //Pin 11 PWM valeur 255
delay(20);
// Pas n°2 | Sorties B+ et A- du Shield Moteur -> Bobines B et C du moteur pas à pas
digitalWrite(8, LOW); //Désactivation Pin n°8
digitalWrite(9, LOW); //Désactivation Pin n°9
digitalWrite(12, LOW); //Désactivation Pin n°12
digitalWrite(13, HIGH); //Activation Pin n°13
analogWrite(3, 255); //Pin 3 PWM valeur 255
analogWrite(11, 255); //Pin 11 PWM valeur 255
delay(20);
// Pas n°3 | Sorties A- et A+ du Shield Moteur -> Bobines C et D du moteur pas à pas
digitalWrite(8,LOW); //Désactivation Pin n°8
digitalWrite(9, HIGH); //Activation Pin n°9
digitalWrite(12, HIGH); //Activation Pin n°12
digitalWrite(13, LOW); //Désactivation Pin n°13
analogWrite(3,255); //Pin 3 PWM valeur 255
analogWrite(11, 0); //Pin 11 PWM valeur 0
delay(20);
// Pas n°4 | Sorties A+ et A- du Shield Moteur -> Bobines D et A du moteur pas à pas
digitalWrite(8, LOW); //Désactivation Pin n°8
digitalWrite(9, LOW); //Désactivation Pin n°9
digitalWrite(12, HIGH); //Activation Pin n°12
digitalWrite(13, LOW); //Désactivation Pin n°13
analogWrite(3, 255); //Pin 3 PWM valeur 255
analogWrite(11, 255); //Pin 11 PWM valeur 255
delay(20);
}
📌 Politique de Confidentialité |
Cet article peut inclure du contenu sponsorisé et rémunérédes, des liens d'affiliation, notamment des liens Amazon (programme Partenaire Amazon EU) me permettant de toucher une commission au pourcentage sur la vente des produits affiliés (sans augmentation de prix pour l'acheteur).
❤️💟 Si vous aimez les articles et pour soutenir le développement du site n'hésitez pas à partager sur les réseaux sociaux