TP1 : Identification d’un

moteur à courant continu

Objectifs :
Prendre en main le matériel. Réaliser des essais sur le moteur électrique afin d’obtenir
ces les paramètres de son modèle de comportement (1er ordre).

Description du matériel

Fig1. Description du Système

• Megapi = Arduino Mega 2560 avec la connectique appropriée.

• Arduino = carte à base de microcontrôleur avec un environnement de

programmation simplifié (Arduino IDE à installer sur vos machines).

• Microcontrôleur = micro ordinateur Connecté au monde extérieur via des

périphériques d’entée/sortie intégrés.

• Utilisation d’entrée/sortie TOR(Tout ou Rien).

 Fig2. Megapi

• Motor Driver TB6612FNG :

Deux Entrées BI1 et BI2 pour activer ou désactiver les bras du pont (changer de
polarité). Un seul bras doit être actif à la fois (sinon court-circuit).

Une Entrée PWM pour moduler la tension de sortie du bras du moteur.

Fig3. Driver Moteur

• Moteur à courant continu 9V + Encodeur :

Réducteur intégré pour améliorer le couple au détriment de la vitesse
(caractéristiques indiquées sur l’étiquette).

Encodeur incrémental (quadrature) 8CPR, 2 bornes d’alimentation (+5V, GND), 2

bornes de mesures (NE1 et NE2) tout ou rien. (Nécessite une résistance de pull-
up).
 Fig4. MCC 9V + Encodeur

Configuration d’Arduino IDE

Installer Arduino IDE

Ouvrir un nouveau sketch

Fig5. Interface Arduino IDE

Sélectionner le ‘board’
 Fig6. Choix de la carte

Connecter le MegaPi
Sélectionner le port

Fig7. Connexion du Port

Tester la connexion à la carte en compilant et en téléversant le code dans la carte. Aucun
message d’erreur ne doit s’afficher dans la console du compilateur.
Configuration des E/S
Définition des pins :

#define ENC_A 31 // entrée encodeur voie A

#define ENC_B 18 // entrée encodeur voie B
#define PWM 12 // sortie pwm
#define BI1 34 // sortie sens
#define BI2 35 // sortie sens

configuration des pins :

pinMode(PWM, OUTPUT);
pinMode(BI1, OUTPUT);
pinMode(BI2, OUTPUT);
pinMode(ENC_A,INPUT_PULLUP);
pinMode(ENC_B,INPUT_PULLUP);

Un programme arduino est composé d’au moins deux fonctions :

• setup() qui ne sera exécutée qu’une seule fois au démarrage
• loop() qui sera exécutée indéfiniment.

Intégrer dans la fonction setup() la configuration des pins.

Alimentation du moteur
Attention le moteur doit être alimenté en 9V maximum. La carte électronique peut
alimenter jusqu 12V et peut donc potentiellement endommager le matériel.

La carte Megapi ne dispose pas de sortie analogique de puissance. Afin d’alimenter le

moteur, nous avons recours au composant TB6612FNG qui est un pont en H avec la
logique de commutation intégrée.
 Fig3. Driver Moteur
Les pins BI1 et BI2 permettent de sélectionner les transistors qui vont être actifs et donc
choisir le sens (c.f. figure 3). Ces transistor seront fermés lorsque la pin PWMB est en
état logique haut. Afin de moduler la tension aux bornes du moteur, on utilise le
périphérique pwm du atmega pour créer un rapport cyclique α entre les états haut et les
états bas. Ceci permet de créer une tension aux bornes du moteur égale à α*12V.

La fonction analogWrite(pwm_b,rapport_cyclique) permet de contrôler ce périphérique

afin d’appliquer le rapport cyclique voulu sous la forme d’un nombre entier compris
entre 0 et 255.

Calculer la valeur maximale admissible à envoyer à la fonction analogWrite(...) pour le

système.

Décrire la fonctionnalité du code ci-dessous et le compléter si besoin.

void moteur(int valeur)

{
if(valeur>0)
{
digitalWrite(BI2,0);
digitalWrite(BI1,1);
} else {
digitalWrite(BI1,0);
digitalWrite(BI2,1);
}
analogWrite(PWM,constrain( abs(valeur) ,0,MAX_PWM));
}

Modifier la fonction afin quelle en prenne en argument un flottant représentant la tension en

volts et l’applique au moteur.

Écrire un programme arduino permettant d’appliquer 5 Volts au moteur.

Communication avec la console Arduino

Serial.begin(115200); // a mettre dans le setup pour initialiser la

communication

Serial.println(valeur) ; // pour envoyer la valeur vers la console et

revenir à la ligne

Ouvrir le moniteur ou le traceur série et mettre la vitesse sur 115200.

On peut se servir de ce mécanisme pour importer des données issues des capteurs sous
matlab.

Ecrire un programme retournant la valeur de la fonction ‘millis()’ dans la console.

Mesure de la vitesse du moteur

Principe de l’encodeur incrémental :

L’encodeur est souvent composé d’un disque troué et de photo-capteurs (voies A,B et Z).
Lorsque le disque tourne, les voies A et B génèrent un signal carré. Un front montant ou
descendant indique déplacement d’une unité (8 fronts montants de la voie B = 1 tour) et
le déphasage entre les deux voies indique le sens du déplacement. La fréquence des
fonts montants indique la vitesse.
Afin de détecter les impulsions (et d’éviter d’en rater), on utilise le mécanisme
d’interruptions du micro-contrôleur. Lorsqu’un front est détecté sur la pin dédiée, le
processeur met en suspend les tâches en cours et exécute la fonction d’interruption.
Une fois que celle-ci est terminée, il reprend le programme là où il a été interrompu.

Remarque : Cette solution n’est pas optimale car des impulsions ‘fantômes’ peuvent être
comptées involontairement si le moteur vibre ou si les signaux de l’encodeur sont
bruité. D’autres solutions plus complexes existent pour éviter ce phénomène mais
demandent plus de ressources processeur (très limitées dans notre cas) ou un
périphérique dédié au comptage.

#include <util/atomic.h> // this library includes the ATOMIC_BLOCK

macro..
volatile int deltaT=0;

setup(){
...
attachInterrupt(digitalPinToInterrupt(ENC_B), OnRisingEdge,
RISING); // Activation du mécanisme d’interruption. sur un front
montant de la voie B de l’encodeur, OnRisingEdge() sera exécutée
immédiatement.
...
}

void OnRisingEdge()
{
static long lastTime;
long t = micros();
deltaT = t-lastTime;
lastTime = t;
}
Comme la donnée est modifiée de façon asynchrone, la donnée doit être protégée
lorsque l’on cherche à l’utiliser. Pour cela on indique au compilateur la nature ‘volatile’ de
cette information et on suspend tout mécanisme d’interruption lors de la copie de cette
donnée.

float getSpeed()
{
int deltaT_temp;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
{ deltaT_temp = deltaT; }
if(deltaT_temp>0) // divide by 0 ?
return 1000000.0/deltaT_temp;
else
return 0;
}

Créer un code permettant de récupérer la vitesse angulaire en sortie du réducteur en radians

par secondes.

Cadencer le code

Il existe deux solutions afin de cadencer le code (avoir un échantillonnage régulier des
mesures). La première consiste à créer une boucle d’attente, la deuxième d’utiliser les
périphériques ‘timers’. L’utilisation de la fonction ‘delay’ est à proscrire car le
comportement est indéfini dans certaines situations. Afin de simplifier l’implémentation,
on choisit la première solution.

#define DT 5

void loop() {
static long lastSampleTime;
while(millis()-lastSampleTime<DT)
{ }
lastSampleTime = millis();
// code à exécuter toutes les DT ms
}

Ecrire un code permettant de récupérer la vitesse de l’arbre en sortie du réducteur (en

radians par secondes).

Importer les données sous Matlab

Faire un essai sous 5 Volts et tracer la réponse sous Matlab.

Approximer le comportement du système à l’aide d’une fonction de transfert du premier

ordre.