> >

L298P motor Shield Utilisation d'un Motor Shield | L298P ⚡👨‍💻


comment piloter un moteur pas à pas avec un shield moteur L298P

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.

Motor Shield compatible Arduino Uno et Mega
Motor Shield | Compatible Arduino
Ajouter la fonction moteur à l'Arduino
Ajouter un Shield moteur sur votre Arduino

Sommaire :

Découverte du Motor Shield Deek-Robot
Le Motor Shield avec un moteur à courant continu
Le Motor Shield avec un moteur pas à pas
        Avec un Moteur bipolaire
        Avec un Moteur unipolaire


principe de fonctionnement de la photorésistance Découverte du Motor Shield Deek-Robot :

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).
Motor Shield | Deek-Robot (Recto) - L298P
Motor Shield | Deek-Robot (Recto)
Motor Shield | Deek-Robot (Verso) - L298P
Motor Shield | Deek-Robot (Verso)

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 :
Circuit intégré L298P motor Shield
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.
Bornes raccordements à vis Motor Shield pour un moteur à courant continu (DC motor)
Bornes à vis du Motor Shield pour Moteur DC
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+
Bornes raccordements à vis Motor Shield pour un moteur pas à pas
Bornes à vis du Motor Shield pour Moteur Pas à pas


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)
Affectation des broches Arduino pour Motor Shield | Deek-Robot
Affectation des broches de l'Arduino pour le Motor Shield
Il est donc possible de connaître le courant délivré par le Motor Shield, pour cela, il faut lire les bornes analogiques A0 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 :

map(Intensite_mesuree, 0, resolution, Intensite_Min, Intensite_Max)

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 2000mA
Intensite = Intensite / 1000  // Mappage de l'intensité sur la résolution 255 et valeur max 2000mA
Mesure de l'intensité du courant délivré par le motor Shield
Mesure de l'intensité du moteur

Le circuit intégré L298P est équipé de 20 broches permettant de piloter les moteurs.
Broches du circuit intégré L298P
Affectation des broches du circuit intégré L298P


principe de fonctionnement de la photorésistance 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é.
Actionneur linéaire, vérin électrique
Actionneur linéaire 12V

Cet actionneur linéaire est actionné par un moteur à courant continu, son raccordement est donc identique.
Branchement de l'actionneur linéaire électrique sur shield motor
Raccordements de l'actionneur linéaire électrique

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.
Branchement du moteur shield avec un moteur à courant continu
Raccordements du Motor Shield avec un moteur à courant continu

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
}

Affichage du courant du moteur DC
Affichage de la consommation du moteur

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.
Branchement du moteur shield avec deux moteurs à courant continu
Raccordements du Motor Shield avec deux moteurs à courant continu

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
}





principe de fonctionnement de la photorésistance 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 ou stepper motor

Découverte du moteur pas à pas et son utilisation avec une Arduino.

Tutoriel fabrication d'une porte de poulailler automatique

Comment fabriquer une porte de poulailler automatique avec un moteur pas à pas.

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 :
mesure à l'ohmmètre pour identifier les bobines d'un moteur pas à pas bipolaire
Le circuit est ouvert le premier bobinage n'est pas encore localisé
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.
mesure au multimètre pour localiser les bobines du moteur pas à pas bipolaire
Le circuit est fermé avec une résistance de 8,46Ω le premier bobinage est localisé
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.
identification des enroulements du moteur pas à pas bipolaire
Repérage des 4 conducteurs d'un moteur pas à pas bipolaire
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+.
câblage d'un moteur pas à pas bipolaire 4 fils sur le motor Shield
Raccordements du moteur pas à pas bipolaire à 4 fils

Programmation Arduino pour moteur Bipolaire

   

Programme Moteur 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-|.
séquence pour faire tourner le moteur bipolaire
Séquence d'alimentation des bobines pour un déplacement de 4 pas dans le sens normal du moteur bipolaire

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.
Branchement du moteur shield avec un moteur pas à pas unipolaire 5 fils
Câblage du Motor Shield avec un moteur pas à pas Unipolaire

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.
   

Programme Moteur 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-.

séquence pour faire tourner le moteur sur 4 pas
Séquence alimentation des bobines pour un déplacement de 4 pas dans le sens normal

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+
Shield moteur et bornier moteur pas à pas unipolaire
Correspondance entre le bornier moteur et le Shield Moteur

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);
}


   

Programme Moteur 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.
Séquence Full Step commande moteur pas à pas unipolaire
Chronogramme de la séquence full step | Moteur pas à pas unipolaire

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);
}


Réseau sociaux
Recherche personnalisée
Si vous aimez les articles, n'hésitez pas à faire vos achats sur Amazon via ce lien, ils me permettront de recevoir une commission grâce au programme Partenaires Amazon EU.