Logo Mon Club Elec

Shield Arduino Motor Shield V3 par Arduino Team

Le Shield Arduino Motor Shield V3 par Arduino Team est un produit innovant qui permet aux utilisateurs de contrôler facilement des moteurs DC, des moteurs pas à pas et des servomoteurs. Il offre une solution simple et abordable pour les projets de robotique et d’automatisation. Ce produit est conçu pour être facile à utiliser et à configurer, et il est compatible avec la plupart des cartes Arduino. Avec ce produit, les utilisateurs peuvent facilement contrôler des moteurs DC, des moteurs pas à pas et des servomoteurs pour créer des projets de robotique et d’automatisation. Dans cet article, nous allons examiner en détail le Shield Arduino Motor Shield V3 et ses fonctionnalités.

Shield Arduino Motor Shield V3 par Arduino Team

CONSEIL D’AMI : TOUJOURS CONNECTER L’ALIMENTATION VIN DES MOTEURS AVANT CONNEXION AU PORT USB !

Synthèse

Description


Cette version la plus récente du Motor Shield livrée montée est basée sur un CI 298 (double pont en H) :

  • permet de contrôler 2 moteurs CC ou 1 moteur pas à pas
  • chaque moteur est contrôlé par une broche de sens et une broche de vitesse PWM
  • dispose de LEDs de fonctionnement et de diodes de protection + bouton reset
  • intensité maximale de 2A/ phase ou moteur (4A en tout)
  • dispose d’un capteur analogique d’intensité intégré (+++) (0V + 1,65V/A) pour chaque phase/moteur
  • dispose de connecteurs droits pour 2 entrées analogiques, 2 sorties PWM et TWI
  • alimentation entre 7 et 12V / 4000mA

Une interface IDEALE pour un robot mobile utilisant 2 moteurs CC puissants !

  • livrée montée
Notre Avis

  • Achetée et testée


Les + :

  • 2A par phase / moteur
  • livrée montée !
  • capteur analogique d’intensité pour chaque phase / moteur !
  • BP reset de surface
  • connecteurs droits Tinker Kit analog IN et OUT (PWM) potentiellement utiles

Les – :

  • Prix ? mais vu la finition du shield, çà semble correct.
  • Borniers à vis petits..
  • Trop de broches utilisées ?

Au total :

  • Une excellente interface pour un robot mobile utilisant 2 moto-réducteurs puissants
Fabricant

Liens utiles

Notre Note

Dispo chez :

Description

Cette version la plus récente du Motor Shield livrée montée est basée sur un CI 298 (double pont en H) :

  • permet de contrôler 2 moteurs CC ou 1 moteur pas à pas
  • chaque moteur est contrôlé par une broche de sens et une broche de vitesse PWM
  • dispose de LEDs de fonctionnement et de diodes de protection + bouton reset
  • intensité maximale de 2A/ phase ou moteur (4A en tout)
  • dispose d’un capteur analogique d’intensité intégré (+++) (0V + 1,65V/A) pour chaque phase/moteur
  • dispose de connecteurs droits pour 2 entrées analogiques, 2 sorties PWM et TWI
  • alimentation entre 7 et 12V / 4000mA

Une interface IDEALE pour un robot mobile utilisant 2 moteurs CC puissants !

Documentations utiles :

Comment çà marche ?

  • Chaque moteur est contrôlé par une broche numérique de sens, une broche de vitesse PWM et également une broche numérique de frein.
  • Cette interface dispose également d’un capteur analogique de courant sur les 2 phases moteurs connectés sur les broches A0 et A1.

Brochage

Chaque phase/moteur est contrôlé par :

  • une broche de sens ON/OFF
  • une broche de vitesse PWM
  • une broche de frein

Chaque moteur/phase dispose également d’une entrée analogique pour la mesure de l’intensité de fonctionnement telle que 1,65V/A

Par ailleurs, le shield dispose de :

  • 2 connecteurs droits 3 broches Tinker kit Analog OUT (PWM) connecté sur D5 et D6
  • 2 connecteurs droits 3 broches Tinker kit Analog IN connecté sur A2 et A3
  • 2 connecteurs droits 4 broches Tinker TWI

Pour mémoire, les connecteurs droits TinkerKit analog IN et OUT ont le brochage suivant : +5V / broche / 0V

Caractéristiques techniques

  • Compatible broche à broche avec une carte Arduino
  • intensité maximale de 2A/ phase ou moteur (4A en tout)
  • dispose d’un capteur analogique d’intensité intégré (+++) (1,65V/A) pour chaque phase/moteur
  • alimentation entre 7 et 12V / 4000mA

Les options du shield

  • BP reset de surface
  • Mesure de l’intensité pour chaque phase/moteur intégrée !

Fonctionnement

Fonctionnement classique d’une interface de contrôle de 2 moteurs CC, à savoir, pour chaque étage moteur :

  • la broche de sens fixe le sens de rotation (HIGH dans un sens, LOW dans l’autre sens)
  • la broche de vitesse (PWM) fixe la vitesse de rotation du moteur
  • la broche de frein stoppe le moteur : inactif sur niveau LOW, actif sur niveau HIGH

Note : si utilisation avec un moteur pas à pas bipolaire, pour chaque étage moteur :

  • Mettre broche vitesse PWM à HIGH
  • et mettre broche frein à LOW

En ce qui concerne la mesure de l’intensité intégrée :

  • sortie = 0V + 1,65V/A (soit 3,3V pour 2A) et donc une résolution de 2,92 mA / niveau !

Mise en oeuvre pratique

Path:?

Test

Le montage utilisé

Code utilisé

// — Programme Arduino —
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 2/5/2012.

// ——- Licence du code de ce programme —–
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// ——– Que fait ce programme ? ———
 /* Teste la rotation des moteurs.  */

// — Fonctionnalités utilisées —

// ——– Circuit à réaliser ———

// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…

// — Déclaration des constantes —

// — Inclusion des librairies —

// — Déclaration des constantes utiles —

// — Déclaration des constantes des broches E/S numériques —

const int vitesseMotA=3; // Constante pour la broche 3
const int sensMotA=12; // Constante pour la broche 12
const int freinMotA=9; // Constante pour la broche 9
const int intensiteMotA=A0; // intensité du moteur 0

const int vitesseMotB=11; // Constante pour la broche 11
const int sensMotB=13; // Constante pour la broche 13
const int freinMotB=8; // Constante pour la broche 8
const int intensiteMotB=A1; // intensité du moteur 1

// — Déclaration des constantes des broches analogiques —

//const int Voie[6]={0,1,2,3,4,5}; //declaration constante de broche analogique

// — Déclaration des variables globales —

// — Déclaration des objets utiles pour les fonctionnalités utilisées —

// ////////////////////////// 2. FONCTION SETUP = Code d’initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// — ici instructions à exécuter 1 seule fois au démarrage du programme —

// ——- Initialisation fonctionnalités utilisées ——-  

Serial.begin(115200);

// ——- Broches en sorties numériques ——-  
 pinMode (vitesseMotA,OUTPUT); // Broche vitesseMotA configurée en sortie
 pinMode (freinMotA,OUTPUT); // Broche freinMotA configurée en sortie
 pinMode (vitesseMotB,OUTPUT); // Broche vitesseMotB configurée en sortie
 pinMode (sensMotA,OUTPUT); // Broche sensMotA configurée en sortie
 pinMode (sensMotB,OUTPUT); // Broche senMotB configurée en sortie

// ——- Broches en entrées numériques ——-  

// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-  

// ——- Initialisation des variables utilisées ——-  

// ——- Codes d’initialisation utile ——-  
digitalWrite(vitesseMotA,LOW); // a l’arret
digitalWrite(sensMotA,LOW);
digitalWrite(freinMotA,LOW); // frein off

digitalWrite(vitesseMotB,LOW); // à l’arret
digitalWrite(sensMotB,LOW);  
digitalWrite(freinMotB,LOW); // frein off

} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension

void loop(){ // debut de la fonction loop()

//—— test initial du moteur A —-
//- sens 1
digitalWrite(sensMotA,LOW); // sens 1
digitalWrite(vitesseMotA, HIGH); // vitesse maximale
delay(2000); // 2 secondes
digitalWrite(vitesseMotA, LOW); // vitesse maximale

//- sens 2
digitalWrite(sensMotA,HIGH); // sens 2
digitalWrite(vitesseMotA, HIGH); // vitesse maximale
delay(1000); // 2 secondes
Serial.println(analogRead(intensiteMotA));
delay(1000); // 2 secondes
digitalWrite(vitesseMotA, LOW); // vitesse maximale

//—— test initial du moteur B —-
//- sens 1
digitalWrite(sensMotB,LOW); // sens 1
digitalWrite(vitesseMotB, HIGH); // vitesse maximale
delay(2000); // 2 secondes
digitalWrite(vitesseMotB, LOW); // vitesse maximale

//- sens 2
digitalWrite(sensMotB,HIGH); // sens 2
digitalWrite(vitesseMotB, HIGH); // vitesse maximale
delay(1000); // 2 secondes
Serial.println(analogRead(intensiteMotB));
delay(1000); // 2 secondes
digitalWrite(vitesseMotB, LOW); // vitesse maximale

//—- test vitesse variable moteur A —

for (int i=0; i<=255; i++) {
  analogWrite(vitesseMotA,i); // PWM croissant
  delay(50); // pause
  Serial.println(analogRead(intensiteMotA));

}

for (int i=0; i<=255; i++) {
  analogWrite(vitesseMotA,255i); // PWM décroissant
  delay(50); // pause
  Serial.println(analogRead(intensiteMotA));
}

//—- test vitesse variable moteur B —

for (int i=0; i<=255; i++) {
  analogWrite(vitesseMotB,i); // PWM croissant
  delay(50); // pause
  Serial.println(analogRead(intensiteMotB));

}

for (int i=0; i<=255; i++) {
  analogWrite(vitesseMotB,255i); // PWM décroissant
  delay(50); // pause
  Serial.println(analogRead(intensiteMotB));

}

while(1); // stop loop

} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
 

Résultats

  • Tout simplement simple et efficace !

Avis

Les + :

  • 2A par phase / moteur
  • livrée montée !
  • capteur analogique d’intensité pour chaque phase / moteur !
  • BP reset de surface
  • connecteurs droits Tinker Kit analog IN et OUT (PWM) potentiellement utiles

Les – :

  • Prix ? mais vu la finition du shield, çà semble correct.
  • Borniers à vis petits..
  • Trop de broches utilisées ?

Au total :

  • Une excellente interface pour un robot mobile utilisant 2 moto-réducteurs puissants

Applications possibles

  • Contrôle de 2 moteurs CC sur un robot mobile.
  • Contôle d’un moteur pas à pas bipolaire.

Exemples d’utilisation de cette interface

=> Liens vers autres pages perso utilisant cette interface

Articles similaires:

Noter cet article

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Archive Mon Club Elec

Articles populaires

Newsletter

Inscrivez-vous maintenant et bénéficiez d'un soutien continu pour réaliser vos travaux électriques en toute sécurité.