See

discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/314675618

FORMATION ARDUINO SIMULINK/ANDROID

Asservissement de vitesse d’un moteur à
courant continu à l’aide de la cart....

Technical Report · May 2015

DOI: 10.13140/RG.2.2.29193.24169

CITATIONS READS

0 2,013

1 author:

Nizar Chelly
Higher Institute of Technological Studies Sousse
7 PUBLICATIONS 1 CITATION

SEE PROFILE

Some of the authors of this publication are also working on these related projects:

FORMATION ARDUINO MATLAB/SIMULINK View project

All content following this page was uploaded by Nizar Chelly on 11 March 2017.

The user has requested enhancement of the downloaded file.

 CHELLY Nizar
CHARED Amine

FORMATION ARDUINO↔SIMULINK/ANDROID

Asservissement de vitesse d’un moteur à

courant continu à l’aide de la carte Arduino UNO

ISET Rades 2/3 Juin 2015

TABLE DES MATIÈRES TABLE DES MATIÈRES

Table des matières

1 Présentation de la carte Arduino 4
1.1 Le matériel : Arduino UNO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Le logiciel Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Structure d’un programme Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Présentation de la maquette 6

3 Commande du moteur à courant continu avec la carte Arduino 6

3.1 Présentation des sorties analogiques (mode PWM) . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 Présentation du schéma électronique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3 Exemples de programme pour la commande du moteur . . . . . . . . . . . . . . . . . . . . . . . . 8

4 Exploitation de l’encodeur optique avec la carte Arduino 8

4.1 Présentation du capteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2 Principe de fonctionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.2.1 Comptage du nombre d’impulsions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.3 Programme d’acquisition des impulsions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.3.1 l’instruction de base pour l’acquisition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.3.2 Code Arduino pour l’acquisition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

5 L’interfacage Arduino↔Matlab/Simulink 11
5.1 L’environnement Matlab/Simulink . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
5.2 ArduinoIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
5.2.1 Pré-chargement du programme dans la carte Arduino . . . . . . . . . . . . . . . . . . . . 12
5.2.2 Installation du package ArduinoIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5.2.3 Exploitation de la bibliothèque ArduinoIO sous Simulink . . . . . . . . . . . . . . . . . . 12
5.2.4 Exploitation du package ArduinoIO sous Matlab . . . . . . . . . . . . . . . . . . . . . . . 13
5.3 Arduino Target . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

6 Commande du moteur avec Arduino/Simulink 13

6.1 Utilisation du package ArduinoIO Libraray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

7 Exploitation de l’encodeur optique avec Arduino/Simulink 14

8 Modélisation du système 14
8.1 Présentation de l’étape d’identification avec Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . 14
8.2 Acquisition de la réponse indicielle du système . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
8.3 Détermination de la fonction de transfert G(z) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

9 Implémentation de la commande sur Simulink 19

9.1 Synthèse du régulateur numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
9.2 Implémentation de la commande sous Simulink . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

10 Implémentation de la commande sur la carte Arduino 23

10.1 Le régulateur PID Numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
10.2 L’implémentation du régulateur PID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

1
TABLE DES FIGURES TABLE DES FIGURES

Table des figures

1 Description de la Carte Arduino "Uno" . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 L’interface du logiciel Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3 Une vue de la maquette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4 Description du signal PWM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
5 Exemples de variation du rapport cyclique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
6 Branchement de la carte Arduino UNO avec un moteur DC . . . . . . . . . . . . . . . . . . . . . 7
7 Circuit interne du module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
8 Les deux signaux issues de l’encodeur optique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
9 ArduinoIO Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
10 Les Blocs d’ArduinoIO nécessaires pour la commande . . . . . . . . . . . . . . . . . . . . . . . . 12
11 Emplacement COM de la carte Arduino UNO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
12 Envoie de la commande PWM sous ArduinIO Library . . . . . . . . . . . . . . . . . . . . . . . . 14
13 acquisition des impulsions sous Arduino IO Library . . . . . . . . . . . . . . . . . . . . . . . . . . 14
14 L’utilisation de l’outil System Identification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
15 Modèle Simulink pour la détermination de la réponse indicielle . . . . . . . . . . . . . . . . . . . 15
16 L’interface de l’outil System identification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
17 Choix des types des données ”Time Domain Data” . . . . . . . . . . . . . . . . . . . . . . . . . . 16
18 Saisie des données relatives aux Input et Output du système . . . . . . . . . . . . . . . . . . . . . 16
19 Choix de la description du système à estimer”Tranfer Function” . . . . . . . . . . . . . . . . . . . 17
20 Choix du nombre des pôles et zéros de la fonction de transfert à estimer . . . . . . . . . . . . . . 17
21 Visualisation du résultat de l’estimation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
22 Récupération de la fonction de transfert estimée . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
23 Schéma synoptique de l’asservissement à implémenter . . . . . . . . . . . . . . . . . . . . . . . . 19
24 Emplacement de l’outil PID tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
25 Interface de l’outil ”PID tuning” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
26 Importation du modèle estimé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
27 Interface de l’outil ”Import Linear System” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
28 Choix du régulateur à implémenter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
29 Récupération des paramétrés du régulateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
30 Modèle Simulink d’asservissement de température . . . . . . . . . . . . . . . . . . . . . . . . . . 22
31 Saisie des paramétrés du régulateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
32 Schéma synoptique de l’asservissement à implémenter . . . . . . . . . . . . . . . . . . . . . . . . 23

2
Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

Formation Arduino ⇔ Simulink/Android

Asservissement de vitesse d’un moteur

à courant continu à l’aide de la carte
Arduino UNO

CHELLY, Nizar
Ingénieur en Électrique et Automatique
chellynizar@gmail.com
+216 50 48 00 27

CHARED, Amine
Ingénieur en Informatique
amineaby@gmail.com
+216 50 02 33 70

Nizar CHELLY-Amine CHARED 3 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

1 Présentation de la carte Arduino

Arduino est un projet créé par une équipe de développeurs, composée de six individus :
Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, David Mellis et Nicholas
Zambetti. Cette équipe a créé le "système Arduino". C’est un outil qui va permettre aux
débutants, amateurs ou professionnels de créer des systèmes électroniques plus ou moins
complexes.

1.1 Le matériel : Arduino UNO

C’est un circuit imprimé comportant tous les composants électroniques nécessaires pour faire
fonctionner un microcontrôleur (Atmega 328) associé à une interface USB lui permettant de
communiquer avec un ordinateur.

Figure 1 – Description de la Carte Arduino "Uno"

– Microcontroller : ATmega328
– Operating Voltage : 5v
– Input Voltage (recommended) : 7-12 v
– Input Voltage (limits) : 6-20 v
– DC Current per I/O Pin : 40mA
– DC Current for 3.3V Pin :50mA
– Flash Memory :32 KB
– Clock Speed : 16MHz
– Pins assignments :
– Analog read(A0-A5)
– Analog write[PWM] (3,5,6,9,10,11)
– Digital read(2-19)
– Digital write(2-19)

1.2 Le logiciel Arduino

Arduino IDE ( Integrated Development Environment ). Le logiciel est gratuit et open source
dont la simplicité d’utilisation est remarquable.Ce logiciel va nous permettre de programmer la
carte Arduino pour :
– Réaliser l’interfacage avec Matlab/simulink
– Implémenter la commande directement sur la carte.

Nizar CHELLY-Amine CHARED 4 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

Figure 2 – L’interface du logiciel Arduino

1.3 Structure d’un programme Arduino

Le langage de programmation Arduino dérive du langage C++ et il en respecte les règles de
syntaxe :
1. Une ligne qui commence par "//" est considérée comme un commentaire.
2. Un paragraphe qui commence par "/*" et qui se termine par "*/" est considéré comme un
commentaire
3. Toute ligne d’instruction de code doit se terminer par un point virgule " ;"
4. Un bloc d’instructions (définition d’une fonction, boucle "while" ou "if"/"else"...) doit être
délimité par des accolades ouvrantes "" puis fermantes "".
5. Toutes les variables doivent être déclarées, ainsi que leur type (int,float,...) avant d’être
utilisées.
Un programme (ou "sketch") Arduino est constitué de 2 fonctions distinctes :
1. La fonction de configuration "void setup" exécutée une seule fois au lancement du pro-
gramme.
2. La fonction "void loop" qui est ensuite exécutée indéfiniment en boucle.
Remarque : On peut relancer le programme en actionnant le bouton poussoir "reset" sur la carte.

Exemple : le programme "Blink" :

i n t DEL = 5 ;
void setup ( )
{
pinMode (DEL, OUTPUT) ;On i n i t i a l i s e l a borne 5 de l ’ Arduino
( n o m m e "DEL" ) comme une s o r t i e .
}
void loop ( )
{
d i g i t a l W r i t e (DEL, HIGH) ;On met l a borne 5 au n i v e a u
l o g i q u e haut (+5V) : l a d i o d e s ’ allume .
d e l a y ( 1 0 0 0 ) ; On a t t e n d un d e l a i de 1000ms ( s o i t 1 s ) .
d i g i t a l W r i t e (DEL, LOW) ;On met l a borne 5 au n i v e a u l o g i q u e bas ( 0V)

Nizar CHELLY-Amine CHARED 5 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

l a d i o d e s ’ teint .
d e l a y ( 1 0 0 0 ) ; On a t t e n d un d e l a i de 1000ms ( s o i t 1 s ) .
}
Et ainsi de suite tant que le circuit est alimenté.

2 Présentation de la maquette
La maquette est constituée d’un capteur de position ”encodeur optique ” et un moteur à
courant continu DC MOTOR.Le capteur et le moteur sont installés dans une maquette en bois.
La figure suivante schématise la connexion de la carte Arduino UNO avec l’entrée et la sortie
du système (DC MOTOR + encodeur optique). La figure ci dessous montre une vue réelle de la
maquette utilisée.

Figure 3 – Une vue de la maquette

3 Commande du moteur à courant continu avec la carte Arduino

3.1 Présentation des sorties analogiques (mode PWM)
La carte Arduino Uno dispose de 6 sorties (3,5,6,9,10 et 11) qui peuvent être utilisées en
mode PWM, c’est-à-dire en modulation de largeur d’impulsion.Ce sont des signaux logiques
binaires de fréquence constante (500Hz) mais de rapport cyclique variable.

Figure 4 – Description du signal PWM

Lorsqu’un moteur ou une lampe est alimenté par ce type de tension, tout se passe comme
si il était alimenté par une tension continue ajustable entre 0V (rapport cyclique= 0) et 5V
(rapport cyclique=255).Ces sorties doivent être initialisées comme des sorties digitales.

τo
Vout = Vs × ; avec : τc = 2ms (1)
τc

Nizar CHELLY-Amine CHARED 6 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

La syntaxe de l’instruction permettant de générer le signal PWM est la suivante : analog-

Write(pin, valeur) ;
– pin : la pin sur la quelle on souhaite envoyer le signal (3,5,6,9,10 ou 11).
– valeur : le rapport cyclique entre 0 et 255.

Figure 5 – Exemples de variation du rapport cyclique

3.2 Présentation du schéma électronique

Le circuit électronique ci-dessous permet de contrôler un moteur à courant continue à partir
des sorties PWM de la carte Arduino. Ce circuit doit amplifier le courant de sortie de la carte
Arduino avec la résistance de protection 1KΩ) et doit aussi supporter la variation du rapport
cyclique du signal PWM. Parmi les transistors pouvant satisfaire ces conditions on a choisit le
TIP121.
Les composants utilisés sont les suivants :

Figure 6 – Branchement de la carte Arduino UNO avec un moteur DC

– Le transistor TIP122 : C’est un transistor Darlington NPN qui d’après la fiche technique
permet d’amplifier le courant jusqu’à 5A avec son gain d’amplification ”au minimum”
β = 1000
– La diode 1N4004 : Dans une charge inductive (bobines), le courant ne peut pas se stopper
instantanément. Cette diode joue le rôle d’une diode de roue libre qui permet au courant
de s’arrêter progressivement.

Nizar CHELLY-Amine CHARED 7 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

3.3 Exemples de programme pour la commande du moteur

– Commande direct du moteur avec la carte Arduino
i n t cmd=90 ; //commande
void setup ( )
{
pinMode ( 6 ,OUTPUT) ; // C o n f i g u r a t i o n du p in 6 comme s o r t i e
}
void loop ( )
{
a n a l o g W r i t e ( 6 , cmd ) ; / / T r a n s f e r t de c e s donnees s u r l a pi n 6 pour g e n e r e r l e
}
– Changement de la commande avec la carte Arduino via le moniteur série
i n t cmd ; //commande
void setup ( )
{
S e r i a l . begin (9600) ;
// ouvre l e p o r t s e r i e , f i x e l e d e b i t 9600 bauds

}
void loop ( )
{
i f ( Serial . available ()) {
cmd=( S e r i a l . read () −48)∗100+( S e r i a l . read () −48)∗10+( S e r i a l . read () −48)∗1 ;
// l e c t u r e des donnees a r r i v e e s
a n a l o g W r i t e ( 5 , cmd ) ;
// T r a n s f e r t de c e s donnees s u r l a pi n 6 pour g e n e r e r l e s i g n a l PWM
S e r i a l . p r i n t l n (cmd ) ;
}
delay (100) ;
// d e l a i de 100ms avant l a n o u v e l l e a c q u i s i t i o n
}

4 Exploitation de l’encodeur optique avec la carte Arduino

4.1 Présentation du capteur
L’encodeur optique est un capteur de position extrêmement précis, il est constitué de deux
parties :
– un disque renferment des bandes opaques et transparentes sur sa périphérie.
– un module qui sert à acquérir les alternances (opaque/transparent) pour les produire en
formes d’ondes analogiques.
Le module contient un émetteur et un récepteur. La partie émettrice se compose :
– une diode luminescente LED(Light Emitting Diode).
– une lentille.
La lumière émise par la diode se transforme en faisceaux parallèles à l’aide de cette lentille
située directement devant la diode. A l’opposé de l’émetteur (LED +Lentille) on trouve la partie
réceptrice englobant les photodiodes et les comparateurs ayant comme sortie les chaines A et B.
Lorsque le moteur tourne, le disque solidaire l’axe du moteur permet l’alternance entre bandes
opaques et bandes transparents d’où l’interruption des faisceaux lumineux. Les photodiodes qui
détectent ces interruptions sont l’origine de la formation du signal de sortie.
Ces détecteurs sont également espacés de telle sorte que sur une paire de détecteurs une période

Nizar CHELLY-Amine CHARED 8 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

Figure 7 – Circuit interne du module

opaque (0 Volts) correspond à une période transparente (5 Volts) sur la paire adjacente. Deux
comparateurs reçoivent ces signaux et produisent les sorties finales pour les canaux A et B. Le
canal A est en quadrature de phase avec le canal B.

4.2 Principe de fonctionnement

L’encodeur optique fournit deux signaux carrés en quadrature, comme sur la capture ci-
dessous : Ces deux signaux permettent de mesurer à la fois la vitesse et le sens de rotation.

Figure 8 – Les deux signaux issues de l’encodeur optique

La mesure de la vitesse se fait simplement en comptant le nombre d’impulsions pendant un

temps fixe. La cadence d’échantillonnage utilisée pour l’asservissement sera de 0.01 s.

4.2.1 Comptage du nombre d’impulsions

Il suffit pour cela d’observer les courbes ci-dessus, obtenues alors que le moteur tourne dans
le sens positif. On constate que :
– Lorsque la voie A passe au niveau haut, la voie B est au niveau bas
– Lorsque la voie A passe au niveau bas, la voie B est au niveau haut
Quand le moteur tourne dans le sens positif, lors d’une interruption sur la voie A, les niveaux
de A et B sont donc inversés.
Si le moteur tourne dans le sens négatif. On constate que :
– Lorsque la voie A passe au niveau haut, la voie B est au niveau haut.
– Lorsque la voie A passe au niveau bas, la voie B est au niveau bas.

Nizar CHELLY-Amine CHARED 9 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

Quand le moteur tourne dans le sens négatif, lors d’une interruption sur la voie A, les niveaux
de A et B sont ont le même niveau. Le code correspondant sur l’Arduino est détaillé dans le
paragraphe suivant.

4.3 Programme d’acquisition des impulsions

4.3.1 l’instruction de base pour l’acquisition

Le programme d’acquisition des impulsions se base sur la fonction suivante :

a t t a c h I n t e r r u p t ( i n t e r r u p t i o n , f o n c t i o n , mode )
Lorsqu’une interruption externe survient cette instruction spécifie la fonction à appeler. La
plupart des cartes Arduino ont deux interruptions externes : interruption externe n°0 sur la
broche numérique 2 et interruption externe n°1 sur la broche numérique 3.
Les paramètres de cette fonction sont :
– interruption : le numéro de l’interruption (type int)
– fonction : la fonction à appeler quand l’interruption survient ; la fonction doit recevoir
aucun paramètres et ne renvoie rien. Cette fonction est également appelée une routine de
service d’interruption (ou ISR).
– mode : définit la façon dont l’interruption externe doit être prise en compte. Quatre
constantes ont des valeurs prédéfinies valables :
– LOW : pour déclenchement de l’interruption lorsque la broche est au niveau BAS
– CHANGE : pour déclenchement de l’interruption lorsque la broche change d’état
BAS/HAUT
– RISING : pour déclenchement de l’interruption lorsque la broche passe de l’état BAS
vers HAUT (front montant)
– FALLING : pour déclenchement de l’interruption lorsque la broche passe de l’état HAUT
vers l’état BAS (front descendant)

4.3.2 Code Arduino pour l’acquisition

i n t pinA = 2 ;
// Channel A c o n n e c t e s u r l ’ i n t e r r u p t i o n e x t e r n e numero 0 ( pin2 )
i n t pinB = 3 ;
// Channel B c o n n e c t e s u r pi n3
i n t i V a l u e = 0 ; // i n i t i a l i s a t i o n 0

void setup ( ) {
S e r i a l . begin (9600) ;
pinMode ( pinA , INPUT) ;
pinMode ( pinB , INPUT) ;
a t t a c h I n t e r r u p t ( 0 , e n c o d e r C l i c k , RISING ) ;
// r o u t i n e de s e r v i c e d ’ i n t e r r u p t i o n ( ou ISR ) .
}

void loop ( )
{
S e r i a l . p r i n t l n ( iValue ) ;
// l e c t u r e des i m p l u s i o n s s u r l e moniteur s e r i e
delay (10) ;
// p e r i o d e d ’ e c h a n t i l l o n a g e

Nizar CHELLY-Amine CHARED 10 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

v o i d e n c o d e r C l i c k ( ) / / l a f o n c t i o n a p p e l e e par l ’ i n t e r r u p t i o n e x t e r n e numero 0
{
// e n c o d e r must have turned one c l i c k b e c a u s e i n t e r r u p t 0 was t r i g g e r e d
// r e a d v a l u e from both e n c o d e r p i n s
i n t valA = d i g i t a l R e a d ( pinA ) ;
i n t valB = d i g i t a l R e a d ( pinB ) ;

// compare p i n s t o d e t e r m i n e i n which d i r e c t i o n e n c o d e r was tur ned

i f ( valA != valB ){
// pinA j u s t changed but pinB had not y e t changed
// D i r e c t i o n must be c l o c k w i s e i f A changes b e f o r e B
i V a l u e++ ;
}
else{
// pinA j u s t changed and pinB had a l r e a d y done so .
// D i r e c t i o n must be cou nte r −c l o c k w i s e i f B changes b e f o r e A
iValue −− ;
}
}

5 L’interfacage Arduino↔Matlab/Simulink
5.1 L’environnement Matlab/Simulink
C’est un logiciel de calcul mathématique pour les ingénieurs et les scientifiques créé par
Mathworks.

MATLAB est un environnement de programmation pour le développement d’algorithme,

d’analyse de données, de visualisation, et de calcul numérique. En utilisant MATLAB, la ré-
solution des problèmes de calcul complexes se fait plus rapidement qu’avec des langages de
programmation traditionnels, tels que C, C++, et le Fortran.

SIMULINK est un environnement pour la simulation, il fournit un environnement graphique

interactif et un ensemble de bibliothèques de bloc qui permettent de concevoir, simuler, mettre
en application, et examiner une variété de systèmes, tel que les systèmes de communications, de
commandes, de traitement des signaux, de traitement visuel, et de traitement d’image. Il existe
trois possibilités d’interfacer la carte Arduino avec Matlab/Simulink, à savoir :
1. Programmation de la carte Arduino Uno comme une carte d’interface.
2. Utilisation du package ArduinoIO.
3. Utilisation du package Arduino Target.

5.2 ArduinoIO
Cette solution consiste à utiliser la carte arduino comme une interface d’entrées(Analog
Input)/sorties(Analog/Digital Output).Ce package permet de communiquer Matlab ou Simulink
avec la carte Arduino via un câble USB.

Elle consiste à pré-charger un programme dans la carte Arduino afin que celle-ci fonctionne
en serveur.
Ce programme consiste à "écouter" les requêtes envoyées via la liaison série (USB) et de répondre

Nizar CHELLY-Amine CHARED 11 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

à ces requêtes en renvoyant l’état d’une entrée ou en modifiant l’état d’une sortie. Ces mêmes
entrées/sortie sont vues dans matlab comme des entrées logiques ou analogiques (utilisation du
CAN) ou des sorties analogiques (mode PWM).

5.2.1 Pré-chargement du programme dans la carte Arduino

1. Télécharger le package ArduinoIO

2. Décompresser à la racine de votre disque dur, exemple E :\arduinoio
3. Ouvrir le dossier décompressé.
4. Aller vers : ”ArduinoIO\pde\adiosrv” *
5. Charger le fichier adiosrv.pde vers le logiciel Arduino.
6. Televerser !
* adiosrv est l’abréviation de : Analog and Digital Input and Output Server for MATLAB.
La carte Arduino UNO est maintenant configuré pour être utiliser comme une carte d’interface
Entrées/Sorties.

5.2.2 Installation du package ArduinoIO

1. Lancer Matlab2013 et placer vous dans le répertoire E :\arduinoio

2. Exécuter la commande : install-arduino
3. Fermer et relancer Matlab puis Simulink
4. Dans les bibliothèques se trouvent maintenant les blocs dans Arduino IO library.

Figure 9 – ArduinoIO Library

5.2.3 Exploitation de la bibliothèque ArduinoIO sous Simulink

Les blocs nécessaires pour notre objectif d’asservissement sont les suivants :

Figure 10 – Les Blocs d’ArduinoIO nécessaires pour la commande

– Real-Time Pacer : Ce bloc permet de ralentir le temps de simulation de sorte qu’il

synchronise avec le temps réel écoulé.Le coefficient de ralentissement est contrôlable par
l’intermédiaire du paramètre Speedup.
– Arduino IO Setup : Pour configurer sur quel port la carte Arduino UNO est connectée.
Pour cela il suffit de voir dans Gestionnaire des périphériques.voir Figure 4.

Nizar CHELLY-Amine CHARED 12 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

Figure 11 – Emplacement COM de la carte Arduino UNO

– Encodeur Read : Pour configurer à partir de quel pin on va realiser l’aquistion des
signaux issue du capteur (channel A et channel B).
– Encodeur Reset : Pour configurer la période de la mise à zéro de l’encodeur.
– Arduino Analog Write : Pour configurer à partir de quel pin [3,5,6,9,10,11] on va envoyer
la commande en PWM vers l’actionneur.

5.2.4 Exploitation du package ArduinoIO sous Matlab

Le package ArduinoIO offre une panoplie de commandes permettant d’écrire un programme

sous Matlab (M-file). Pour accéder à ces commandes il faut créer un objet arduino dans l’espace
de travail et spécifier le port sur lequel la carte arduino est connecté avec la commande :
>> a = arduino(0 port0 ); (2)
Parmi les commandes qui sont accessibles on retrouve :
– pinMode
Exemple :a.pinMode(11,’output’) // configurer la pin 11 comme sortie.
– digitalRead
Exemple :val=a.digitalRead(4) ; // lecture de l’etat de la pin 4
– digitalWrite
Exemple :a.digitalWrite(13,0) ; // mettre la pin 13 à l’etat bas 0V
– analogRead
Exemple :val=a.analogRead(0) ; // lecture de la pin 0 de l’ADC
– analogWrite
Exemple :a.analogWrite(3,10) ; // envoyer sur la pin 10 un signal pwm de rapport cyclique
10/255

5.3 Arduino Target

Embedded Coder Support Package for Arduino permet de créer des applications Simulink
qui vont fonctionner de façon autonome sur la carte Arduino. on dit que la carte Arduino est
devenue une cible (Target) et elle peut fonctionner d’une façon autonome (sans avoir recours à
Matlab/Simulink).

Dans la suite, on utlisera les blocs Simulink offert par le package ArduinoIO Library.

6 Commande du moteur avec Arduino/Simulink

6.1 Utilisation du package ArduinoIO Libraray
1. Pré-chargement de adiosrv.pde sur la carte Arduino UNO
2. Développement du modèle Simulink

Nizar CHELLY-Amine CHARED 13 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

Figure 12 – Envoie de la commande PWM sous ArduinIO Library

7 Exploitation de l’encodeur optique avec Arduino/Simulink

1. Pré-chargement de adiosrv.pde sur la carte Arduino UNO

2. Développement du modèle Simulink

Figure 13 – acquisition des impulsions sous Arduino IO Library

8 Modélisation du système
Le but de cette partie est de déterminer la fonction de transfert échantillonnée de notre
système en boucle ouvert notée G(z).L’entrée du système est la tension u(z) en volts et la sortie
est la vitesse V (z) en (implusion/10ms).

8.1 Présentation de l’étape d’identification avec Matlab

Cette étape est constituée de deux parties. La première est assuré par l’environnement
Simulink et le package ArduinoIO pour l’envoie et l’acquisition des données. La deuxième partie
est assuré par l’outil System identification sous Matlab.

Figure 14 – L’utilisation de l’outil System Identification

Nizar CHELLY-Amine CHARED 14 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

8.2 Acquisition de la réponse indicielle du système

Plusieurs méthodes sont utilisées pour la modélisation d’un système comme la détermination
des équations physiques du système, l’étude de la réponse d’un système à une entrée....etc.
Dans notre cas on va identifier notre système en étudiant la réponse de notre système à échelon
de tension.
Le modèle Simulink permettant de réaliser l’acquisition de la réponse du système à un échelon
de tension est le suivant :

Figure 15 – Modèle Simulink pour la détermination de la réponse indicielle

8.3 Détermination de la fonction de transfert G(z)

Après avoir déterminer la réponse du système, on passe à la détermination de la fonction de
transfert G(z).
1. Ouvrir l’outil System identification Tool

Figure 16 – L’interface de l’outil System identification

Nizar CHELLY-Amine CHARED 15 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

2. Cliquer sur import data et choisir Time domain data.

Figure 17 – Choix des types des données ”Time Domain Data”

3. Entrer le nom de la variable Input et la variable Output ainsi que temps de starting time et
sample time qu’on a utiliser lors de l’identification avec Simulink.Enfin cliquer sur Import.

Figure 18 – Saisie des données relatives aux Input et Output du système

4. Cliquer sur Estimate et choisir Transfer Function Models

Nizar CHELLY-Amine CHARED 16 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

Figure 19 – Choix de la description du système à estimer”Tranfer Function”

5. Entrer le nombre de pôle et de zéro et cliquer sur Discrete-Time ensuite cliquer surEstimate.

Figure 20 – Choix du nombre des pôles et zéros de la fonction de transfert à estimer

6. Vous pouvez revenir à l’interface System Identification Tool et cliquer deux fois sur tf1
pour voir le résultat.

Nizar CHELLY-Amine CHARED 17 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

Figure 21 – Visualisation du résultat de l’estimation

7. Une fenêtre apparait dans laquelle vous trouvez G(z).

Figure 22 – Récupération de la fonction de transfert estimée

Nizar CHELLY-Amine CHARED 18 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

9 Implémentation de la commande sur Simulink

Dans cette partie l’implémentation du régulateur se fera sur Simulink.

Figure 23 – Schéma synoptique de l’asservissement à implémenter

L’étape de la commande du système est constituée de deux parties.

La première partie consiste à utiliser l’outil Matlab PID Tuning pour déterminer les différents
paramétrés de notre régulateur PI à savoir Kp ,Ki en fonction de notre objectif de commande.
La deuxième partie consiste à implémenter le régulateur sur Simulink.

Figure 24 – Emplacement de l’outil PID tuning

Nizar CHELLY-Amine CHARED 19 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

9.1 Synthèse du régulateur numérique

1. Ouvrir l’outil PID Tuner

Figure 25 – Interface de l’outil ”PID tuning”

2. Cliqueur sur Import new plant, une nouvelle fenêtre apparait.

Figure 26 – Importation du modèle estimé

3. Une nouvelle fenêtre apparait dans laquelle vous allez sélectionner tf1 ensuite cliquer sur
import puis close.

Nizar CHELLY-Amine CHARED 20 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

Figure 27 – Interface de l’outil ”Import Linear System”

4. Revenir à la fenêtre PID Tuner, vous pouvez choisir le type de régulateur à implémenter et
les objectifs de la commande en boucle fermé et voir la réponse de la sotie du système.

Figure 28 – Choix du régulateur à implémenter

Nizar CHELLY-Amine CHARED 21 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

5. Cliquer sur la flèche de show parameter pour voir les paramétrés utilisés de votre régulateur
ainsi que les performances du système en boucle fermé.

Figure 29 – Récupération des paramétrés du régulateur

9.2 Implémentation de la commande sous Simulink

La boucle d’asservissement à implémenter sur Simulink se traduit par le schéma suivant :
L’asservissement de notre procédé est assuré par le schéma Simulink ci-dessous qui regroupe la
consigne, le comparateur, le correcteur PI(z), l’acquisition de vitesse et l’envoie de la commande
PWM.

Figure 30 – Modèle Simulink d’asservissement de température

L’appui deux fois sur le bloc PID(z) permet d’introduire les paramétrés Kp Ki et de configurer
le régulateur selon notre objectif de commande.

Figure 31 – Saisie des paramétrés du régulateur

Nizar CHELLY-Amine CHARED 22 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

10 Implémentation de la commande sur la carte Arduino

Dans cette partie l’implémentation du régulateur directement sur la carte Arduino UNO.

Figure 32 – Schéma synoptique de l’asservissement à implémenter

10.1 Le régulateur PID Numérique

Ce type de correcteur est défini par l’équation différentielle suivante :
Z t
d
UP ID (t) = Kp × e(t) + Ki × e(τ )dτ + Kd × e(t) (3)
0 dt
L’équation de contrôle PID numérique peut être exprimée en de diverses manières, mais une
formulation générale est donnée par l’équation suivante [3] :
(erreur − erreurprécédente )
P ID = Kp × erreur + Ki × (erreur × ∆t) + Kd × (4)
X
∆t
L’implémentation du régulateur PID sur la carte Arduino se fera de la manière suivante [3] :
PID :
E r r o r = S e t p o i n t − Actual
I n t e g r a l = I n t e g r a l + ( E r r o r ∗ dt )
D e r i v a t i v e = ( E r r o r − P r e v i o u s _ e r r o r ) / dt
Drive = ( E r r o r ∗kP ) + ( I n t e g r a l ∗ k I ) + ( D e r i v a t i v e ∗kD)
Previous_error = Error
w a i t ( dt )
GOTO PID

10.2 L’implémentation du régulateur PID

Le code suivant permet d’implémenter le régulateur PID sur la carte Arduino.
– Implémentation direct de la consigne sur la carte Arduino
float d e l t a _ e r r e u r =0 ;
float somme_erreur = 0 ; // Somme des e r r e u r s pour l ’ i n t g r a t e u r
float kp = 0 . 0 0 0 3 0 7 9 8 ; // C o e f f i c i e n t p r o p o r t i o n n e l
float ki = 0.061596 ;// C o e f f i c i e n t integrateur

f l o a t ep , up , v , u , e , i n t e g r a l , cmd ;
float derive ;
i n t pinA = 2 ; // Encoder pi n A c o n n e c t s t o i n t e r r u p t 0 (D2)
i n t pinB = 3 ; // Encoder p i n B c o n n e c t s t o D4
i n t i V a l u e = 0 ; //A v a r i a b l e t h a t w i l l be i n c r e a s e d o r d e c r e a s e d

Nizar CHELLY-Amine CHARED 23 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

int consigne ;

void setup ( ) {
S e r i a l . begin (9600) ;
pinMode ( pinA , INPUT) ;
pinMode ( pinB , INPUT) ;
a t t a c h I n t e r r u p t ( 0 , e n c o d e r C l i c k , RISING ) ; / / r o u t i n e de s e r v i c e d ’ i n t e r r u p
}

void loop ( )
{
v=abs ( i V a l u e ) ;

e=50−v ;
d e l t a _ e r r e u r = ( e−ep ) / 0 . 0 1 ;
somme_erreur=somme_erreur+e ∗ 0 . 0 1 ;
cmd = kp∗ e + k i ∗ somme_erreur ;
a n a l o g W r i t e ( 5 , cmd ∗ ( 2 5 5 / 5 ) ) ;
S e r i a l . p r i n t l n ( e ) ; / / e n v o i e de l a donnee s u r l e p o r t s e r i e
// d e l a y ( 1 0 ) ; / / p e r i o d e d ’ e c h a n t i l l o n a g e
ep=e ;

i V a l u e =0 ;
delay (10) ;// periode d ’ echantillonage

}
v o i d e n c o d e r C l i c k ( ) / / l a f o n c t i o n a p p e l e par l ’ i n t e r r u p t i o n e x t e r n e num
{
// e n c o d e r must have turned one c l i c k b e c a u s e i n t e r r u p t 0 was t r i g g e r e d
// r ead v a l u e from both e n c o d e r p i n s
i n t valA = d i g i t a l R e a d ( pinA ) ;
i n t valB = d i g i t a l R e a d ( pinB ) ;

// compare p i n s t o d e t e r m i n e i n which d i r e c t i o n e n c o d e r was turned

i f ( valA != valB ){
// pinA j u s t changed but pinB had not y e t changed
// D i r e c t i o n must be c l o c k w i s e i f A changes b e f o r e B
i V a l u e++ ;
}
else{
// pinA j u s t changed and pinB had a l r e a d y done so .
// D i r e c t i o n must be cou nte r −c l o c k w i s e i f B changes b e f o r e A
iValue −− ;
}
}
.
– Changement de la consigne avec le moniteur série
float d e l t a _ e r r e u r =0 ;
float somme_erreur = 0 ; // Somme des e r r e u r s pour l ’ i n t g r a t e u r
float kp = 0 . 0 0 0 3 0 7 9 8 ; // C o e f f i c i e n t p r o p o r t i o n n e l
float ki = 0.061596 ;// C o e f f i c i e n t integrateur

Nizar CHELLY-Amine CHARED 24 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

f l o a t ep , up , v , u , e , i n t e g r a l , cmd ;
float derive ;
i n t pinA = 2 ; // Encoder pi n A c o n n e c t s t o i n t e r r u p t 0 (D2)
i n t pinB = 3 ; // Encoder p i n B c o n n e c t s t o D4
i n t i V a l u e = 0 ; //A v a r i a b l e t h a t w i l l be i n c r e a s e d o r d e c r e a s e d
int consigne ;

void setup ( ) {
S e r i a l . begin (9600) ;
pinMode ( pinA , INPUT) ;
pinMode ( pinB , INPUT) ;
a t t a c h I n t e r r u p t ( 0 , e n c o d e r C l i c k , RISING ) ; \ \
// r o u t i n e de s e r v i c e d ’ i n t e r r u p t i o n ( ou ISR ) .
}

void loop ( )
{
v=abs ( i V a l u e ) ;
i f ( Serial . available ()) {

c o n s i g n e =( S e r i a l . read () −48)∗100+( S e r i a l . read () −48)∗10+\\

( S e r i a l . read () −48)∗1 ;
// l e c t u r e des d o n n e s a r r i v e s
}
e=c o n s i g n e −v ;
d e l t a _ e r r e u r = ( e−ep ) / 0 . 0 1 ;
somme_erreur=somme_erreur+e ∗ 0 . 0 1 ;
cmd = kp∗ e + k i ∗ somme_erreur ;
a n a l o g W r i t e ( 5 , cmd ∗ ( 2 5 5 / 5 ) ) ;
S e r i a l . println ( consigne ) ;
// e n v o i e de l a donnee s u r l e p o r t s e r i e
// d e l a y ( 1 0 ) ;
// p e r i o d e d ’ e c h a n t i l l o n a g e
ep=e ;

i V a l u e =0 ;
delay (10) ;
// p e r i o d e d ’ e c h a n t i l l o n a g e

}
void encoderClick ()\\
// l a f o n c t i o n a p p e l e e par l ’ i n t e r r u p t i o n e x t e r n e n 0
{
// e n c o d e r must have turned one c l i c k b e c a u s e i n t e r r u p t 0 was t r i g g e r e d
// r ead v a l u e from both e n c o d e r p i n s
i n t valA = d i g i t a l R e a d ( pinA ) ;
i n t valB = d i g i t a l R e a d ( pinB ) ;

// compare p i n s t o d e t e r m i n e i n which d i r e c t i o n e n c o d e r was turned

i f ( valA != valB ){
// pinA j u s t changed but pinB had not y e t changed
// D i r e c t i o n must be c l o c k w i s e i f A changes b e f o r e B

Nizar CHELLY-Amine CHARED 25 ISET RADES 2015

Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

i V a l u e++ ;
}
else{
// pinA j u s t changed and pinB had a l r e a d y done so .
// D i r e c t i o n must be cou nte r −c l o c k w i s e i f B changes b e f o r e A
iValue −− ;
}
}

Nizar CHELLY-Amine CHARED 26 ISET RADES 2015

 Formation Arduino ↔ Simulink/Android Asservissement de vitesse d’un moteur à courant continu

Références
[1] http ://www.mathworks.com/
[2] http ://www.arduino.cc/
[3] PID Control : A brief introduction and guide, using Arduino.
[4] PID controller http ://en.wikipedia.org/w/index.php ?title=PID controller soldid=547984770.

Nizar CHELLY-Amine CHARED 27 ISET RADES 2015

View publication stats