top of page

LE MODULE COMMANDE MOTEUR I2C

Le module commande moteur I2C comporte une interface de puissance L298 capable de piloter en vitesse et en direction deux moteurs à courant continu ou un moteur pas à pas bipolaire 4 fils.

La tension d'alimentation des moteurs doit être comprise  entre 6 et 15 V et le courant admissible est de 0,5 A.

Une led indique que le module est sous tension et quatre autres led indiquent le sens de rotation des deux moteurs à courant continu ou la séquence d'alimentation des phases du moteur pas à pas.

Ce module doit être relié à un connecteur I2C de la base et son adresse est paramétrable grâce à 4 micro-interrupteurs, ce qui permet de relier plusieurs modules pour commander plus de deux moteurs.

​

Si nous alimentons le module avec une alimentation externe, il faut retirer le cavalier J4.

Ce module ne possède pas de bibliothèque, ce qui rend sa mise en oeuvre plus difficile que la plupart des modules "Grove". Une étude de sa documentation s'impose.

Le protocole de communication I2C de ce module est le suivant. La carte Arduino doit envoyer dans l'ordre :

  • l'adresse de ce module configurable par 4 micro-switches

  • l'adresse du registre de fonction (voir tableau ci-dessous)

  • l'argument sous forme de deux octets

Dans le programme Arduino, nous allons créer des fonctions permettant d'exploiter ces adresses I2C.

​

#define Registre_Vitesse_Moteurs           0x82
#define Registre_Frequence_MLI             0x84
#define Registre_Direction                        0xAA
#define Registre_Moteur_1                       0xA1
#define Registre_Moteur_2                       0xA5
#define Argument_Vide                             0x00
#define Adresse_Module_Grove               0x0F


void Vitesse_Moteur_1_et_2(unsigned char Vitesse_Moteur_1 , unsigned char Vitesse_Moteur_2)  
{
  Vitesse_Moteur_1=map(Vitesse_Moteur_1,0,100,0,255);                    // on change l'échelle
  Vitesse_Moteur_2=map(Vitesse_Moteur_2,0,100,0,255);                    // on change l'échelle
  Wire.beginTransmission(Adresse_Module_Grove);                              // on communique avec le module Moteur Grove
  Wire.write(Registre_Vitesse_Moteurs);                                                 // on modifie la vitesse des moteurs  
  Wire.write(Vitesse_Moteur_1);                                                               // on envoie la vitesse du moteur 1
  Wire.write(Vitesse_Moteur_2);                                                               // on envoie la vitesse du moteur 2
  Wire.endTransmission();                                                                         // on stoppe la communication avec le module Moteur Grove
}

void Frequence_MLI(unsigned char Frequence)  
{    
  Wire.beginTransmission(Adresse_Module_Grove);                            // on communique avec le module Moteur Grove
  Wire.write(Registre_Frequence_MLI);                                                  // on modifie la fréquence de la MLI  
  Wire.write(Frequence);                                                                          // on envoie la fréquence
  Wire.write(Argument_Vide);                                                                  // on envoie l'argument vide (voir tableau)
  Wire.endTransmission();                                                                       // on stoppe la communication avec le module Moteur Grove
}

void Direction_Moteur(unsigned char Direction)  
{     
  Wire.beginTransmission(Adresse_Module_Grove);                            // on communique avec le module Moteur Grove
  Wire.write(Registre_Direction);                                                            // on modifie la fréquence de la MLI  
  Wire.write(Direction);                                                                            // on envoie la fréquence
  Wire.write(Argument_Vide);                                                                 // on envoie l'argument vide (voir tableau)
  Wire.endTransmission();                                                                       // on stoppe la communication avec le module Moteur Grove
}

​

L' alimentations externe est reliée au bornier entouré en VERT. Le cavalier entouré en BLEU doit être retiré.

Les moteurs à courant continu sont reliés au bornier entouré en ROUGE.

Le moteur pas à pas est relié aux broches entourées en JAUNE.

Les micro-interrupteurs entouré en ORANGE permettent de configurer l'adresse du module (0x0F lorsque les micro-interrupteurs sont en haut)

Exemple :

Nous souhaitons faire tourner un moteur dans les deux sens de rotation avec une phase d'accélération pour les deux sens.

Liste du matériel :

Câblage :​

Module "Grove"

​

Module

commande moteur

​

Connecteur Base

​

I2C

​

​

​

​

​

Programme :​

/* Moteur_Grove est un programme qui commande une accélération d'un moteur à courant continu à l'aide d'un module Commande Moteur I2C Grove */
 
#include <Wire.h>                                                                                       // appel de la bibliothèque

#define Registre_Vitesse_Moteurs           0x82
#define Registre_Frequence_MLI             0x84
#define Registre_Direction                        0xAA
#define Registre_Moteur_1                       0xA1
#define Registre_Moteur_2                       0xA5
#define Argument_Vide                             0x00
#define Adresse_Module_Grove               0x0F


void Vitesse_Moteur_1_et_2(unsigned char Vitesse_Moteur_1 , unsigned char Vitesse_Moteur_2)  
{
  Vitesse_Moteur_1=map(Vitesse_Moteur_1,0,100,0,255);                    // on change l'échelle
  Vitesse_Moteur_2=map(Vitesse_Moteur_2,0,100,0,255);                    // on change l'échelle
  Wire.beginTransmission(Adresse_Module_Grove);                             // on communique avec le module Moteur Grove
  Wire.write(Registre_Vitesse_Moteurs);                                                 // on modifie la vitesse des moteurs  
  Wire.write(Vitesse_Moteur_1);                                                               // on envoie la vitesse du moteur 1 
  Wire.write(Vitesse_Moteur_2);                                                               // on envoie la vitesse du moteur 2
  Wire.endTransmission();                                                                        // on stoppe la communication avec le module Moteur Grove
}

void Frequence_MLI(unsigned char Frequence)  
{    
  Wire.beginTransmission(Adresse_Module_Grove);                             // on communique avec le module Moteur Grove
  Wire.write(Registre_Frequence_MLI);                                                   // on modifie la fréquence de la MLI  
  Wire.write(Frequence);                                                                           // on envoie la fréquence
  Wire.write(Argument_Vide);                                                                   // on envoie l'argument vide (voir tableau)
  Wire.endTransmission();                                                                         // on stoppe la communication avec le module Moteur Grove
}

void Direction_Moteur(unsigned char Direction)  
{     
  Wire.beginTransmission(Adresse_Module_Grove);                            // on communique avec le module Moteur Grove
  Wire.write(Registre_Direction);                                                             // on modifie la fréquence de la MLI  
  Wire.write(Direction);                                                                             // on envoie la fréquence
  Wire.write(Argument_Vide);                                                                  // on envoie l'argument vide (voir tableau)
  Wire.endTransmission();                                                                        // on stoppe la communication avec le module Moteur Grove
}

void setup() 
{
 Wire.begin();
 delay(10);
 Vitesse_Moteur_1_et_2(0,0);                                                                   // on stoppe le moteur
 delay(10);
}

void loop()
{
 for (int i=0; i <= 100; i++)                                                                         // on augmente la vitesse du moteur par pas de 1
 {
  Vitesse_Moteur_1_et_2(i,0);
  delay(10);
  Direction_Moteur(0b0010);                                                                   // on fait tourner le moteur dans un sens
  delay(100);
 }
 delay(1000);
 for (int i=0; i <= 100; i++)                                                                        // on augmente la vitesse du moteur par pas de 1
 {
  Vitesse_Moteur_1_et_2(i,0);
  delay(10);
  Direction_Moteur(0b0001);                                                                  // on fait tourner le moteur dans l'autre sens
  delay(100);
 }
}

Mise à jour :

Une bibliothèque a été mise en ligne récemment et est téléchargeable ici et ses principales fonctions sont :

  • Motor.begin(Adresse_I2C). Cette fonction permet d'initialiser le module avec l'adresse I2C spécifiée par les micro-interrupteurs du module.

  • Motor.speed(moteur, vitesse). Cette fonction permet de faire tourner le moteur 1. Le paramètre moteur (MOTOR1 ou MOTOR2) permet de sélectionner le moteur que nous souhaitons et le paramètre vitesse doit être compris entre -100 et 100.

  • Motor.stop(moteur). Cette fonction permet d'arrêter un des moteurs grâce au paramètre moteur (MOTOR1 ou MOTOR2).

  • Motor.StepperRun(pas). Cette fonction permet de faire tourner un moteur pas à pas d'un nombre de pas défini par le paramètre pas compris entre -1024 et 1024.

bottom of page