View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Shield Arduino Motor Shield V3 par Arduino Team

MATERIEL - Shield – Par X.HINAULT - Créé le 28/05/2012.

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,255-i); // 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,255-i); // 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