Tutoriel Arduino Motor Shield

Le blindage du moteur Arduino vous permet de contrôler facilement la direction et la vitesse du moteur à l'aide d'un Arduino. En vous permettant d'adresser simplement les broches Arduino, il est très simple d'incorporer un moteur dans votre projet. Il vous permet également d'alimenter un moteur avec une alimentation séparée jusqu'à 12v. Mieux encore, le bouclier est très facile à trouver. Pour toutes ces raisons, l'Arduino Motor Shield est un peu cool à avoir dans votre arsenal pour un prototypage rapide et des expérimentations générales.

Étape 1: installer

Les broches du blindage officiel du moteur Arduino ne s'aligneront qu'avec Arduino Uno Rev.3.

Afin de le faire fonctionner avec les anciennes versions de l'Arduino, vous devrez couper quelques broches du blindage du moteur. Cependant, ce n'est pas du tout recommandé.

Insérez les broches du blindage du moteur dans la prise de l'Arduino Uno.

Étape 2: Caractéristiques du bouclier

Le blindage du moteur a 2 canaux, ce qui permet de contrôler deux moteurs à courant continu ou 1 moteur pas à pas.

Il dispose également de 6 en-têtes pour la connexion des entrées, sorties et lignes de communication Tinkerkit. L'utilisation de ces broches est quelque peu limitée et n'est donc pas traitée dans ce didacticiel.

Avec une alimentation externe, le blindage du moteur peut fournir en toute sécurité jusqu'à 12 V et 2 A par canal de moteur (ou 4 A à un seul canal).

Il y a des broches sur l'Arduino qui sont toujours utilisées par le bouclier. En adressant ces broches, vous pouvez sélectionner un canal de moteur à initier, spécifier la direction du moteur (polarité), régler la vitesse du moteur (PWM), arrêter et démarrer le moteur et surveiller l'absorption de courant de chaque canal.

La répartition des broches est la suivante:

Une fonctionCanal ACanal B
DirectionNumérique 12Numérique 13
Vitesse (PWM)Numérique 3Digital 11
FreinNumérique 9Numérique 8
Détection de courantAnalogique 0Analogique 1

Pour plus d'informations sur les spécifications techniques, consultez la page officielle du bouclier moteur sur le site Arduino.

Étape 3: programme

Branchez l'Arduino sur le port USB de votre ordinateur et ouvrez l'environnement de développement Arduino.

Pour que la carte fasse quoi que ce soit, vous devez initialiser le canal du moteur en basculant trois paramètres:

  1. Vous devez d'abord définir la direction du moteur (polarité de l'alimentation) en la réglant soit HAUT soit BAS.
  2. Ensuite, vous devez désengager l'axe de frein pour le canal du moteur en le réglant sur LOW.
  3. Enfin, pour que le moteur démarre, vous devez régler la vitesse en envoyant une commande PWM (analogWrite) à la broche appropriée.

Si vous ne faites pas ces trois choses, le moteur ne s'allumera pas.

Dans les étapes suivantes, vous trouverez quelques exemples courants de configurations de moteur courantes.

Étape 4: un moteur

Pour contrôler un moteur à l'aide du blindage du moteur Arduino, branchez d'abord le fil positif (rouge) du moteur dans la borne + du canal A sur le blindage du moteur, et le fil de terre (noir) du moteur dans la borne - du canal A sur le blindage.

Une alimentation externe n'est pas toujours nécessaire, mais elle améliore considérablement les performances du moteur. Il est recommandé de toujours en utiliser un.

Pour connecter votre alimentation externe, connectez le fil positif (rouge) de l'alimentation à la borne "Vin" et le fil de terre (noir) à la borne "GND".

Enfin, téléchargez le code pour contrôler le bouclier moteur sur l'Arduino.

Voici le code pour contrôler un moteur:
 / ************************************************* ************ Motor Shield 1-Channel DC Motor Demo par Randy Sarafan Pour plus d'informations, voir: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ **** ************************************************** ******* / void setup () {// Configuration du canal A pinMode (12, OUTPUT); // Lance le canal du moteur A pin pinMode (9, OUTPUT); // Initie le canal de freinage A pin} boucle vide () {// avant @ pleine vitesse digitalWrite (12, HIGH); // Établit la direction avant du canal A digitalWrite (9, LOW); // Désengagez le frein du canal A analogWrite (3, 255); // Fait tourner le moteur sur le canal A à pleine vitesse (3000); digitalWrite (9, HIGH); // Engagez le frein pour le retard du canal A (1000); // en arrière @ demi-vitesse digitalWrite (12, LOW); // Établit la direction arrière du canal A digitalWrite (9, LOW); // Désengagez le frein du canal A analogWrite (3, 123); // Fait tourner le moteur sur le canal A avec un retard de demi-vitesse (3000); digitalWrite (9, HIGH); // Engagez le frein pour le retard du canal A (1000); } 

Étape 5: Deux moteurs

L'interfaçage avec deux moteurs est à peu près la même chose que l'interfaçage avec un moteur. Branchez simplement le moteur sur le canal B.

La seule différence au niveau du code est que vous devez engager un deuxième canal pour contrôler le deuxième moteur.

Voici le code pour contrôler deux moteurs:
 / ************************************************* ************ Motor Shield 2-Channel DC Motor Demo par Randy Sarafan Pour plus d'informations, voir: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ **** ************************************************** ******* / void setup () {// Configuration du canal A pinMode (12, OUTPUT); // Lance le canal du moteur A pin pinMode (9, OUTPUT); // Lance la broche du canal A de freinage // Configuration du mode pin du canal B (13, OUTPUT); // Lance le canal du moteur A pin pinMode (8, OUTPUT); // Lance la broche du canal de frein A} boucle vide () {// Moteur A avant @ digitalWrite à pleine vitesse (12, HIGH); // Établit la direction avant du canal A digitalWrite (9, LOW); // Désengagez le frein du canal A analogWrite (3, 255); // Fait tourner le moteur sur le canal A à pleine vitesse // Moteur B vers l'arrière @ demi-vitesse digitalWrite (13, LOW); // Établit la direction arrière du canal B digitalWrite (8, LOW); // Désengagez le frein du canal B analogWrite (11, 123); // Fait tourner le moteur sur le canal B avec un retard de demi-vitesse (3000); digitalWrite (9, HIGH); // Engagez le frein du canal A digitalWrite (9, HIGH); // Engagez le frein pour le retard du canal B (1000); // Moteur A avant @ digitalWrite à pleine vitesse (12, BAS); // Établit la direction arrière du canal A digitalWrite (9, LOW); // Désengagez le frein du canal A analogWrite (3, 123); // Fait tourner le moteur sur le canal A à mi-vitesse // Moteur B avant @ pleine vitesse digitalWrite (13, HIGH); // Établit la direction avant du canal B digitalWrite (8, LOW); // Désengagez le frein du canal B analogWrite (11, 255); // Fait tourner le moteur sur le canal B à pleine vitesse (3000); digitalWrite (9, HIGH); // Engagez le frein du canal A digitalWrite (9, HIGH); // Engagez le frein pour le retard du canal B (1000); } 

Étape 6: moteur pas à pas

Il existe différents types de moteurs pas à pas, mais dans ce didacticiel, nous aborderons spécifiquement les moteurs pas à pas bipolaires. Les moteurs pas à pas bipolaires ont généralement 4 broches, ce qui correspond à deux bobines. Pour utiliser un stepper, vous devez alimenter ces deux bobines en phase avec une polarité alternée.

Pour déterminer quelles deux broches composent une seule bobine, insérez une LED dans deux broches de sa prise et faites tourner l'arbre du moteur. Si la LED s'allume, vous avez trouvé une bobine. Les deux autres broches doivent constituer l'autre bobine.

Pour faire tourner un moteur bipolaire:

  1. Alimentez la première bobine.
  2. Ensuite, alimentez la deuxième bobine avec une polarité inversée.
  3. Ensuite, alimentez la première bobine avec une polarité inversée.
  4. Enfin, alimentez la deuxième bobine.

Pour inverser la direction du moteur d'un moteur pas à pas bipolaire, il suffit d'inverser la polarité de la deuxième bobine.

Voici le code pour faire tourner le stepper dans une direction:
 / ************************************************* ************ Démo du moteur pas à pas du bouclier par Randy Sarafan Pour plus d'informations, voir: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ ******** ************************************************** *** / int delaylegnth = 30; void setup () {// établir les axes de basculement de la direction du moteur pinMode (12, OUTPUT); // CH A - HIGH = en avant et LOW = en arrière ??? pinMode (13, SORTIE); // CH B - HIGH = en avant et LOW = en arrière ??? // établir les broches de frein moteur pinMode (9, OUTPUT); // frein (désactiver) CH A pinMode (8, OUTPUT); // frein (désactiver) CH B} boucle vide () {digitalWrite (9, LOW); // ACTIVER CH A digitalWrite (8, HIGH); // DESACTIVER CH B digitalWrite (12, HIGH); // Définit la direction de CH A analogWrite (3, 255); // Déplace CH A delay (delaylegnth); digitalWrite (9, HIGH); // DÉSACTIVER CH A digitalWrite (8, LOW); // ACTIVER CH B digitalWrite (13, LOW); // Définit la direction de CH B analogWrite (11, 255); // Déplace le retard CH B (delaylegnth); digitalWrite (9, LOW); // ACTIVER CH A digitalWrite (8, HIGH); // DÉSACTIVER CH B digitalWrite (12, LOW); // Définit la direction de CH A analogWrite (3, 255); // Déplace CH A delay (delaylegnth); digitalWrite (9, HIGH); // DÉSACTIVER CH A digitalWrite (8, LOW); // ACTIVER CH B digitalWrite (13, HIGH); // Définit la direction de CH B analogWrite (11, 255); // Déplace le retard CH B (delaylegnth); } 

Voici le code pour faire tourner le stepper dans la direction opposée:
 / ************************************************* ************ Démo du moteur pas à pas du bouclier par Randy Sarafan Pour plus d'informations, voir: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ ******** ************************************************** *** / int delaylegnth = 30; void setup () {// établir les axes de basculement de la direction du moteur pinMode (12, OUTPUT); // CH A - HIGH = en avant et LOW = en arrière ??? pinMode (13, SORTIE); // CH B - HIGH = en avant et LOW = en arrière ??? // établir les broches de frein moteur pinMode (9, OUTPUT); // frein (désactiver) CH A pinMode (8, OUTPUT); // frein (désactiver) CH B} boucle vide () {digitalWrite (9, LOW); // ACTIVER CH A digitalWrite (8, HIGH); // DESACTIVER CH B digitalWrite (12, HIGH); // Définit la direction de CH A analogWrite (3, 255); // Déplace CH A delay (delaylegnth); digitalWrite (9, HIGH); // DÉSACTIVER CH A digitalWrite (8, LOW); // ACTIVER CH B digitalWrite (13, HIGH); // Définit la direction de CH B analogWrite (11, 255); // Déplace le retard CH B (delaylegnth); digitalWrite (9, LOW); // ACTIVER CH A digitalWrite (8, HIGH); // DÉSACTIVER CH B digitalWrite (12, LOW); // Définit la direction de CH A analogWrite (3, 255); // Déplace CH A delay (delaylegnth); digitalWrite (9, HIGH); // DÉSACTIVER CH A digitalWrite (8, LOW); // ACTIVER CH B digitalWrite (13, LOW); // Définit la direction de CH B analogWrite (11, 255); // Déplace le retard CH B (delaylegnth); } 

Articles Connexes