Book TMEAutomatic

ÉCOLE DE L’AIR
DÉPARTEMENT DES VÉHICULES AÉROSPATIAUX
TRAVAUX DE MODÉLISATION
ET D’EXPÉRIMENTATION
François BATEMAN
Table des matières
TABLE DES MATIÈRES i
Introduction 1
I SIMULATION ET PROGRAMMATION SOUS SIMULINK 3
1 RAPPELS SUR LES SIGNAUX ET LES SYSTÈMES 5

1.1 Aspects temporels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 À propos des nombres sous SIMULINK . . . . . . . . . . . . . . . . . . . . . . . 8
2 PROGRAMMATION DE DSPICs 11
2.1 Microcontrôleur DsPic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Programmation du DsPic sous SIMULINK . . . . . . . . . . . . . . . . . . . . . 12
2.3 Présentation du blockset Embedded Target Microchip . . . . . . . . . . . . . . . . 12
2.4 Premier exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3 PROGRAMMATION DES PERIPHERIQUES DU DSPIC 19

3.1 Les ports numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2 Les UART . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3 Le bus SPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.4 Convertisseurs Analogiques-Numériques . . . . . . . . . . . . . . . . . . . . . . . 31
3.5 Les signaux PWM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.6 Le bus I2C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.7 Insertion de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
II TRAVAUX PRATIQUES 43
1 MODÉLE D’UN DRONE Á VOILURE TOURNANTE 45

1.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
i
Table des matières
1.2 Équations d’état d’un drone à voilure tournante . . . . . . . . . . . . . . . . . . . 45

1.3 Travail demandé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
1.4 Détermination des paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
1.5 Test du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
1.6 Elaboration des variables additionnelles . . . . . . . . . . . . . . . . . . . . . . . 49
1.7 Pour aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2 ESTIMATION D’ATTITUDE 51
2.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.2 La centrale d’attitude MTI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.3 L’estimation d’attitude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
2.4 Implémentation temps réel de la centrale d’attitude . . . . . . . . . . . . . . . . . 57
3 ESTIMATION DE HAUTEUR PAR FILTRAGE DE KALMAN 59

3.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.2 Modélisation des signaux et du système . . . . . . . . . . . . . . . . . . . . . . . 60
3.3 Présentation de la maquette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.4 Implémentation du filtre de Kalman . . . . . . . . . . . . . . . . . . . . . . . . . 63
4 CONTRÔLE DE L’ASSIETTE D’UN DRONE À VOILURE TOURNANTE 67

4.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.2 Modélisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.3 Lois de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.4 Expérimentations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5 PLANIFICATION DE TRAJECTOIRES 77
5.1 Présentation du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.2 Modèle du robot pour la commande . . . . . . . . . . . . . . . . . . . . . . . . . 78
5.3 Trajectoire de Dubins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.4 Champs de potentiel artificiels . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6 CONTRÔLE DE LA TRAJECTOIRE D’UN DRONE 87

6.1 Calibration du système de capture de mouvements (Motion CAPture) . . . . . . 87
6.2 Contrôle automatique de la trajectoire du drone . . . . . . . . . . . . . . . . . . 93
6.3 Loi de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
6.4 Pour aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
7 COMMANDE D’UN ESSAIM DE DRONES PAR CONSENSUS 103

7.1 Présentation du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.2 Commande par consensus du premier ordre . . . . . . . . . . . . . . . . . . . . . 104
7.3 Consensus du second ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
7.4 Formations étudiées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Bibliographie 114
ii
Introduction
Ce fascicule rassemble l’ensemble des travaux de modélisation et d’expérimentation d’auto-

matique et de traitement de signal. Il est organisé en trois parties :
1. La première est dédiée à l’utilisation de SIMULINK, elle se décline en trois séquences :
— La simulation de systèmes dynamiques à temps discret.
— La programmation de ces systèmes ; la cible retenue ici est un microcontrôleur dsPic
de Microchip, toutefois des blocksets dédiés permettent, avec la même philosophie la
programmation de PC, cartes Raspberry, BeagleBone Black, GumStick, etc.
— La programmation des périphériques du dsPic30F6014.
2. La seconde partie comporte six travaux pratiques d’automatique appliqués au contrôle des
aéronefs. Toutes les notions vues en première et deuxième année sont mises en application.
Les correcteurs, la commande par retour d’état, les observateurs déterministes, le filtre
de Kalman et l’identification paramétrique sont appliqués à des systèmes tels que la
commande du moteur d’un quadrirotor, une centrale d’attitude, la mesure de la hauteur
d’un drone, le contrôle de l’assiette et de la trajectoire d’un drone à voilure tournante.
3. La troisième partie comporte quatre travaux pratiques de traitement du signal. Les no-
tions sont pour partie celles vues en première année : acquisition, numérisation et res-
titution de signaux, filtres RIF et RII, bancs de filtres, identification paramétrique. Les
applications portent sur le traitement du son : la réduction active de bruit et le camouflage
d’un message dans un signal audio.
Il vous est demandé, avant chaque séance, de lire et de préparer le sujet qui vous est attribué
et de consulter votre cours dans le but de profiter pleinement de la séance.
Première partie
SIMULATION ET PROGRAMMATION
SOUS SIMULINK
3
SÉQUENCES 1
RAPPELS SUR LES SIGNAUX ET LES SYSTÈMES
1.1 Aspects temporels

1.1.1 Définition
En première année, dans le cours d’automatique, les modèles des systèmes étudiés étaient
supposés continus 1 . Cette propriété traduit le fait que les variables fonction du temps (ou si-
gnaux) qui caractérisent l’évolution du système sont définies à tout instant. En outre, sur un
intervalle donné, ces variables peuvent prendre toutes leurs valeurs dans R. De tels signaux sont
qualifiés d’analogiques. SIMULINK, un add-on de MATLAB, permet au moyen de bibliothèques
graphiques de représenter les modèles de simulation de ces systèmes et de les simuler grâce à
différents solvers. Depuis quelques décennies, la plupart des systèmes sont contrôlés par des
calculateurs (des microcontrôleurs dans le cadre de ces TME) qui permettent l’acquisition de
signaux issus des capteurs et la génération de signaux. Ces signaux sont lus et élaborés à des
intervalles de temps discrets, en outre ils sont codés sur un nombre fini de bits et par conséquent,
les valeurs que ces signaux peuvent prendre sont elle-mêmes discrètes. On parle alors de systèmes
et de signaux numériques. SIMULINK permet la modélisation de tels systèmes mais aussi celle
de systèmes hybrides mixant des sous-systèmes continus et des sous-systèmes numériques.
1.1.2 Signaux et systèmes à temps continu, discret et hybride

Depuis le bureau de votre ordinateur, exécutez MATLAB, exécutez SIMULINK et ouvrez
un nouveau modèle File ❀ New Model.
Système continu :
— Construisez un système continu d’ordre un (gain statique 1, constante de temps 0,1s)
soumis à un signal sinusoı̈dal (Amplitude 5, Frequency 2, Sample Time 0) et observez sur
un même oscilloscope les signaux d’entrée et de sortie. Soit S1 ce système.
1. De plus, des hypothèses stipulaient que les modèles de ces systèmes étaient linéaires et invariants.
5
Séquences 1. RAPPELS SUR LES SIGNAUX ET LES SYSTÈMES
Système échantillonné-bloqué : Si l’on suppose que ce système continu est piloté par un cal-
culateur, il convient de lui appliquer le signal d’entrée et de mesurer le signal de sortie à des
intervalles de temps réguliers définis par la période d’échantillonnage ou sample time Ts . Le
système est alors qualifié d’échantillonné-bloqué.
— Á partir du système continu S1 , réalisez un système échantillonné-bloqué en insérant
des bloqueurs d’ordre zéro (Discrete ❀ Zero Holder Block) à l’entrée et à la sortie du
système. Le Sample Time choisi est égal à 50ms. Soit S2 ce système.
— Simulez ce système et comparez sa réponse à celle du système continu.
— Compte-tenu des propriétés du système continu, dans quelle plage de fréquence [ωmin , ωmax ]
peut-on raisonnablement l’utiliser ?
— Quelle est alors la période d’échantillonnage maximale Tsmax qui peut-être théoriquement
choisie ?
— Sur quatre essais successifs, mettre en évidence ces limites. Pour cela vous appliquerez
successivement un signal de pulsation égale à ωmax avec les périodes d’échantillonnage
Ts Ts
Tsmax , 2Tsmax , max et max .
2 10
Système échantillonné-bloqué décrit par sa fonction de transfert en Z :

On rappelle (voir le cours de traitement du signal de première année) que la transformée en
Z d’un système de fonction de transfert H(s) échantillonné et muni d’un bloqueur d’ordre zéro
a pour expression :

−1 −1 H(s)
H(z) = (1 − z )Z L (1.1)
s
La fonction tf permet de construire une fonction de transfert (consultez l’aide en ligne help
tf ). La fonction c2d de MATLAB permet de calculer la fonction de transfert en Z d’un tel
système à partir de sa fonction de transfert continue obtenue avec la fonction tf.
— Calculez avec MATLAB la fonction de transfert en Z du système à temps continu défini
supra. Le temps d’échantillonnage est égal à 50ms.
— Au moyen de SIMULINK, réalisez cette fonction de transfert (Discrete ❀ Transfer Func-
tion). Vous paramètrerez en particulier le champ Sample Time. Soumettez ce système au
même signal sinusoı̈dal que celui défini précédemment. Soit S3 ce système.
— Simulez ce système décrit par sa fonction de transfert en Z et comparez sa réponse à celle
du système continu muni de ses échantillonneurs-bloqueurs.
Systèmes continu à commande numérique : On qualifie de système hybride ou mixte un système

qui comporte des éléments à temps continu et d’autres à temps discret. C’est par exemple le cas
des systèmes asservis pilotés par calculateur :
— Le système à commander est un système à temps continu e.g. avion, satellite, etc.
— Le comparateur et le correcteur qui le contrôle sont implémentés sur un calculateur et
constituent un système à temps discret.
Cet aspect est important car par la suite, au moyen de SIMULINK, vous simulerez des systèmes
à temps continu pour lesquels vous aurez préalablement synthétisé les correcteurs numériques.
Puis, toujours au moyen de SIMULINK, vous génèrerez le code source relatif au comparateur
6 F. BATEMAN
1.1. Aspects temporels
et au correcteur seuls. Ce code sera ensuite implémenté sur le calculateur en vue de piloter le
système réel.
— Sous SIMULINK, insérez le système continu d’ordre 1 déjà étudié et muni de ses bloqueurs
d’ordre zéro dans une boucle d’asservissement avec retour unitaire. Le correcteur utilisé
a pour fonction de transfert :
(0.1s + 1)
C(s) = 20 (1.2)
s
— Comment appelle-t-on ce correcteur, quelles performances garantit-il ?

— Etablissez sa fonction de transfert en Z, la période d’échantillonnage restant égale à 50ms,
et réalisez la boucle d’asservissement de ce système. Pensez à paramétrer le Sample Time
du comparateur. Soit S4 ce système.
— Soumettez ce système à une consigne sinusoı̈dale (Amplitude 2, Frequency 2, Sample
Time 50ms) et simulez-le. Vous observerez en particulier le signal de commande en sortie
du correcteur et le signal en sortie du système continu.
— Notez que les blocs discrete transfer function contiennent un bloqueur d’ordre zéro qui
rend caduque la présence du bloc zero-holder en sortie du correcteur.
1.1.3 Quantification du signal échantillonné-bloqué
Pratiquement, les signaux échantillonnés sont numérisés (au moyen de convertisseurs ana-
logique numérique ou CAN). Cette numérisation s’effectue sur un nombre de bits N fini, gé-
néralement N = 8, 10, 12, 16. La résolution est la plus petite variation du signal anlogique qui
provoque un changement du signal numérique d’une unité. Les effets de cette numérisation sur le
signal échantillonné-bloqué peuvent être mis en évidence par un bloc Quantizer (Discontinuities
❀ Quantizer). Sur le schéma S2 , vous l’ intercalerez entre le bloqueur d’ordre zéro en sortie du
système et l’oscilloscope.
5 5
— Réglez successivement le Quantization Interval q à 8 puis 3 et mettez ainsi en
2 −1 2 −1
2
évidence les effets de la numérisation sur le signal .
— Cette opération est à l’origine d’un bruit dit de quantifiquation que vous visualiserez en
opérant à la différence entre les signaux en amont et en aval du Quantizer.
— Réalisez sous SIMULINK l’opération qui permet de calculer la valeur efficace de ce bruit,
laquelle sous l’hypothèse d’ergodicité n’est autre que la variance de ce bruit dont vous
q2
vérifierez qu’elle est égale à .
12
— Recherchez dans les ouvrages mis à votre disposition la démonstration ayant conduit à
ce résultat. Prenez-en connaissance.
Dans ce qui suit et sauf indication contraire, on supposera que la résolution des convertisseurs
employés est suffisamment petite pour négliger les effets dus à la quantification.
2. Ces valeur seraient celles obtenues pour des CAN 8 bits et 3 bits et pour une tension pleine échelle de 5
Volts.
F. BATEMAN 7
1.2 À propos des nombres sous SIMULINK

Par défaut, les nombres calculés par SIMULINK sont, sauf exception, des nombres à virgule
flottante signés et codés sur 64 bits appelés double. Ce type de nombre permet de coder les
nombres réels et convient en particulier pour la simulation de systèmes continus. Toutefois,
lorsqu’on réalise un filtre numérique ou une loi de commande, le calculateur peut manipuler
d’autres types de nombre et il peut être intéressant d’effectuer les simulations dans des conditions
plus proches de la réalité. SIMULINK manipule entre autres les nombres de type :
— single : nombres à virgule flottante signés et codés sur 32 bits
— int32, int16, int8 : nombres entier signés et codés sur 32, 16, 8 bits
— uint32, uint16, uint8 : nombres entier non-signés et codés sur 32, 16, 8 bits
— etc.
Le codage sur un nombre de bits réduit permet d’économiser l’espace mémoire et d’accroı̂tre la
vitesse de calcul mais peut dégrader de manière significative les résultats obtenus avec le type
double. C’est ce que l’on se propose de mettre en évidence sur le modèle du système hybride S4 .
Codage du type single : Ouvrez le fichier sequence1 2.mdl, puis paramétrez le bloc Add ❀
Signal Attribute ❀ Output Data Type comme single. Notez que par défaut le bloc discrete
transfer function hérite du type du signal d’entrée.
— Simulez ce système et comparez-les réponses à celles obtenues avec le type double.
— Réitérez ces simulations avec des nombres de type int8 et uint8.
— Expliquez pourquoi cela ne pouvait fonctionner pour ce dernier type.
1.2.1 Retour sur les signaux et les systèmes à temps discret

Single sample time : Dans les travaux qui suivent, vous aurez à implémenter sur calculateur
des algorithmes de filtrage, de commande, etc. La simulation mais surtout la programmation de
ces algorithmes au moyen de SIMULINK nécessitent pour le solver un pas de calcul constant.
Ce dernier est défini à partir du menu Simulation ❀ Parameters ❀ Solver options :
— Type : Fixed Step
— Solver : discrete (non continuous...)
— Fixed Step Size : la valeur du pas, par exemple 50ms
Au niveau du schéma, dans chaque bloc, le paramètre Sample Time définit la cadence à laquelle
chacun des blocs est contrôlé par le solver. Ce temps doit être un multiple entier du Fixed Step
Time. Il est donc possible, sur un même modèle, de faire cohabiter des blocs avec des Sample
Time différents.
— Réaliser un système comportant deux intégrateurs à temps discret (Discrete ❀ discrete
time integrator) soumis tous deux à une constante unitaire. Les deux intégrateurs ont un
gain unitaire. Pour le premier le Sample Time est égal à 100ms, pour le second à 200ms.
Visualiser les signaux en sortie des deux intégrateurs. Soit S5 ce système.
Il est également possible d’ajouter un offset T0 de sorte que l’instant d’exécution d’un bloc tn
soit décalé :
tn = nTs + T0 (1.3)
8 F. BATEMAN
1.2. À propos des nombres sous SIMULINK
Pour ce faire, le champ du paramètre Sample Time du bloc sélectionné s’écrit [Ts , T0 ]. Où
T0 ≤ Ts et est un multiple entier du Fixed Step Solver.
— Modifier le système S5 de sorte que l’instant d’execution de l’intégrateur initialement
contrôlé toutes les 200ms soit décalé de 50ms.
Multi sample time : Lorsqu’un signal est propagé dans un système au travers de plusieurs blocs,
il est possible de définir pour différents ensembles de blocs des instants d’exécution distincts au
moyen d’un bloc Signal Attributes ❀ Rate transition. Cela présente un intérêt pour des systèmes
comportant plusieurs boucles imbriquées. La boucle interne ayant généralement à traiter des
signaux plus rapides que la boucle externe. Pour respecter le théorème de Shanon, la période
d’échantillonnage de la boucle interne est généralement plus petite que celle de la boucle externe.
L’autre intérêt est que cela nécessite moins de calculs que si toutes les boucles fonctionnaient à
la période d’échantillonnage de la petite boucle.
— Ouvrez le fichier Sequence1 4.mdl qui représente un système asservi comportant deux
boucles. Analysez sa structure, vous vous attacherez en particulier aux paramètres Sample
Time des différents blocs et à la valeur retenue pour le Fixed Step Time. Simulez-le et
observez les périodes d’échantillonnage des signaux des boucles interne et externe.
— En vous aidant de l’aide du bloc rate transition, mettez en évidence sur le schéma, au
moyen de couleurs ou de façon explicite les différents temps d’échantillonnage de la boucle.
— Modifiez le temps d’exécution des blocs qui réalisent la boucle interne en introduisant un
offset de 1ms.
F. BATEMAN 9
10 F. BATEMAN
SÉQUENCES 2
PROGRAMMATION DE DSPICs
2.1 Microcontrôleur DsPic
Les microcontrôleurs de la famille DsPic (Digital Signal Peripheral Interface Controller) de

Microchip sont des unités de traitement et d’exécution de l’information auxquels on a ajouté des
périphériques internes permettant de réaliser des montages sans nécessiter l’ajout de composants
annexes. Un microcontrôleur peut donc fonctionner de façon autonome après programmation.
Les PIC intègrent une mémoire de programme, une mémoire de données, des ports d’entrée-
sortie (numériques, analogiques, MLI, UART, bus I2C, etc.) et une horloge, bien que des bases
de temps externes puissent être employées.
Les PIC sont des processeurs dits RISC, c’est-à-dire processeur à jeu d’instructions réduit.
Plus on réduit le nombre d’instructions, plus facile et plus rapide en est le décodage, et plus
vite le composant fonctionne. Cependant, il faut plus d’instructions pour réaliser une opération
complexe.
L’horloge est réalisée par un quartz, par exemple avec un quartz de 8 MHz, on obtient donc
8.106 cycles d’horloge par seconde, qu’il est possible de multiplier à l’aide d’un module dit de
PLL. Nous choisissons de la multiplier par 16 (PLL x16). Or, pour exécuter une instruction, le
processeur à besoin de 4 cycles d’horloge. On arrive ainsi à une fréquence de fonctionnement
finale de 32 millions d’instructions par seconde ou 32 MIPS. Une instruction dure alors une
trentaine de nanosecondes. A ce propos, les dsPIC33E ont une puissance calcul pouvant aller
jusqu’à 70 MIPS.
2.1.1 Caractéristiques du DsPic 30F6014A
On se reportera à la documentation du constructeur sur le site http://microchip.com. On

présente ici quelques caractéristiques de ce composant :
11
Séquences 2. PROGRAMMATION DE DSPICs
Parameter Name Value

Architecture 16-bit
CPU Speed (MIPS) 30
Memory Type Flash (non volatile)
Program Memory (KB) 144
RAM Bytes 8192
Digital Communication Peripherals 2-UART
2-SPI
1-I2C
Analog Peripherals 1-A/D 16x12-bit @ 200(ksps)
CAN 2 CAN 1
Capture/Compare/PWM Peripherals 8
PWM Resolution bits 16 16
Timers 5 x 16-bit 2 x 32-bit
2.2 Programmation du DsPic sous SIMULINK

Dans le cadre de ce TME, le DsPic sera programmé dans l’environnement MATLAB-SIMULINK
au moyen du blockset Embedded Target For DsPic. Le descriptif de ce blockset est accessible de-
puis l’URL http://www.kerhuel.eu/wiki/Simulink_-_Embedded_Target_for_PIC. Cet outil
de prototypage rapide présente l’intérêt d’utiliser un même outil, SIMULINK, pour la simulation
et la programmation, ce que montre la figure 2.1.
— La simulation est menée de façon classique comme cela a été vu lors de la séquence 1. Il
n’est toutefois pas possible d’utiliser le blockset à des fins de simulation.
— La programmation du microcontrôleur DsPic se fait en adjoignant au schéma de simu-
lation les fonctions du blockset qui matérialisent les périphériques du microcontrôleur.
Ces derniers permettent d’acquérir des signaux et de communiquer avec les différents
composants constitutifs du système. Lors de cette phase de programmation, il convient
d’être extrêmement rigoureux dans l’utilisation des types de nombre manipulés par les
blocs et au choix des temps du solver (Fixed Step Time) et des blocs (Sample Time).
Les différents périphériques des microcontrôleurs DsPic sont déjà programmés et présentés
sous forme de blocs, qu’il ”suffit” d’agréger au modèle de simulation pour réaliser la fonction
désirée. Les bibliothèques du blockset sont illustrée sur la figure 2.2.
2.3 Présentation du blockset Embedded Target Microchip

2.3.1 Configuration de base
Cette configuration sera, à quelques détails près, la même pour l’ensemble des travaux pra-
tiques sur le microcontrôleur. Il vous est conseillé de conserver ce template pour ne pas perdre
de temps lors des prochaines séances.
Sous SIMULINK, parmi les blocksets installés, sélectionnez l’Embedded Target for DsPic block-
set, File❀New model. Ouvrez un nouveau Model et, depuis le blockset, copier-coller les bloc
12 F. BATEMAN
2.3. Présentation du blockset Embedded Target Microchip
Figure 2.1 – Prototypage rapide avec l’Embedded Target for DsPic blockset
Figure 2.2 – Librairie du blockset
F. BATEMAN 13
Master, Compiler configuration et le bloc Port Info s’il existe dans la version du blockset installée.
Paramétrez-les comme suit :
Le bloc Master
Onglet General
— Time step reference : Timer 1
— PIC : 30F6014A
Onglet Real Time Quartz
— Number Instruction per second : 40e6
— Oscillator Mode : XT PLL × 16
Concernant les paramètres de cet onglet, voir les explications données à la section 2.1.
Le bloc Compiler configuration

Par défaut, le code qui sera généré pour le DsPic utilise des nombres de type Single tandis que
par défaut les nombres utilisés lors des simulations sont des Double. Les différences de résultats
observées avec ces deux types de nombre sont peu significatives (cf. séquence 1), aussi pour ne
pas surcharger la mémoire du DsPic et réduire le temps de calcul, c’est ce codage qui par défaut
est retenu.
Le bloc Port info

Lors de la construction du schéma de programmation sous SIMULINK, il indique le numéro des
”pins” du microcontrôleur qui sont utilisées.
Le bloc Simulink Configuration ❀ Compile

C’est en fait un bouton sur lequel on double-clique et qui génère le code C (appelé C30 pour les
DsPic de la famille 30F) propre aux microcontrôleurs DsPic ainsi que la traduction sous forme
hexadécimale (extension hex) de ce code. Pratiquement, c’est cette dernière qui sera implémentée
sur le microcontrôleur.
Plus généralement, les fichiers SIMULINK, au moyen de l’outil Real Time Workshop peuvent
générer du code pour différents types de matériels, lesquels peuvent être programmés dans dif-
férents type de langage C. Il suffit que ces langages C soient installés sur l’ordinateur et qu’ils
soient accessibles depuis SIMULINK (voir le menu Simulation ❀ Configuration Parameters ❀
Real Time Workshop).
Le solver
Pour générer le code, il faut utiliser un solver à temps discret. Par défaut, le solver utilise
un Fixed Step Time de 1ms. Pratiquement, il faut adapter ce pas de calcul en fonction de la
dynamique du système à concevoir (selon qu’il est plus ou moins rapide ou lent) et au volume
de calculs à effectuer.
Ce réglage est souvent délicat et le blockset met à disposition un certain nombre d’outils pour
opérer au choix de ce pas. On se reportera à la documentation en ligne du bloc Master pour une
explication concernant les champs Busy Flag Port, Overload Flag Port et bloc Calculus Time
Step dans la librairie Others du blockset. La figure 2.3 montre :
14 F. BATEMAN
2.4. Premier exemple
a. un système pour lequel le pas de calcul du solver Fixed step time et la période à laquelle les
blocs sont contrôlés (Sample time) sont identiques, tandis que le temps de calcul ou Tbusy
(le nombre de cycles machines) est inférieur à la période du solver. S’il est activé, le B usy
Flag Port est maintenu à l’état logique haut le temps pendant lequel le microcontôroleur
est occupé.
b. un système pour lequel la période à laquelle les blocs sont contrôlés est un multiple de
celle du solver.
c. un système pour lequel il y a un offset temporel au niveau de la période à laquelle les
blocs sont contrôlés.
d. un système pour lequel le le temps de calcul requis pour effectuer les calculs est supérieur
à la période du solver. Si l’Overload Flag Port est activé, la pin sélectionnée passe à l’état
logique haut.
a. Tbusy =k cycles machine b.

✛
✲ ✛
✲ Tbusy =k cycles machine
sample time (bloc) sample time (bloc)
✻ ✛ ✲ ✻ ✛ ✲
✲ ✲
Fixed step time (solver) Fixed step time (solver)

c. d.
sample time (bloc) Tbusy =k cycles machine
✲
✛✻offset T0 ✛ ✲ ✛
✻ ✲ sample
✛ ✲ time (bloc)
✲ ✲
Fixed step time (solver) Fixed step time (solver)
Figure 2.3 – Le temps sous SIMULINK
2.4 Premier exemple
Dans ce premier exemple, on se propose de réaliser un chenillard à 4 LEDs. Pour cela, il faut
réaliser un registre à décalage circulaire. Comme l’indique la figure 2.4, les données se propagent
d’une cellule à une autre au rythme d’une horloge. A chaque coup d’horloge, la sortie de la
cellule ayant la valeur 1 allume une des 4 LEDs. Les diodes s’éclairent les unes après les autres
au rythme de la seconde.
F. BATEMAN 15
1 0 0 0 t=0.T
✛
0 1 0 0 t=1.T
✛
0 0 1 0 t=2.T
...
✛
1 0 0 0 t=4.T
Figure 2.4 – Registre à décalage circulaire
2.4.1 Schéma de simulation

Réaliser un registre à décalage comportant 4 cellules. Ces cellules seront réalisées par des
blocs Discrete❀Unit delay qui réalisent un retard d’un coup d’horloge et dont vous règlerez
judicieusement les champs Initial condition et Sample time. Vous aurez également à régler les
paramètres de simulation du solver, notamment le Fixed step time. Simulez ce système simple
et vérifiez son bon fonctionnement.
2.4.2 Schéma de programmation et compilation

Copiez-collez le schéma du registre à décalage dans le template préalablement paramétré.
Comme on souhaite allumer ou éteindre des LEDs (signaux tout ou rien), vous supprimerez
les blocs permettant de visualiser les signaux (à l’instar des blocs Scope et Display, ils ne se
programment pas) et ajouterez sur chaque sortie un bloc Commonly used blocks ❀ convert de
sorte qu’ils transforment les signaux en boolean.
Vous pourrez alors insérer les blocks Digital I/O ❀ Digital output write en les paramétrant
sur les sorties numériques des lignes de port b2 , . . . , b5 .
Enregistrez ce schéma et compilez-le. A l’issue de la compilation, les pourcentages de mé-
moires requises pour le programme et utilisée par les données sont communiquées. Ces informa-
tions sont importantes. Un fichier avec une extension hex et ayant le même nom que le fichier
mdl est généré, il se trouve dans le dossier ou Current folder défini par le Command window de
MATLAB.
2.4.3 Programmation du DsPic

1. Connectez un câble USB entre votre PC et la carte BigDsPic6,
2. Alimentez puis mettez cette carte sous tension,
3. Depuis le bureau Ouvrez le programme dsPICFLASH ou MikroProg Suite for DsPic :
— choisissez le microcontrôleur 30F6014A dans le champ device,
— cliquez sur le bouton Load Hex et sélectionnez le fichier avec l’extension hex préala-
blement généré,
— cliquez sur bouton Write pour implémenter le fichier hex sur le microcontrôleur.
16 F. BATEMAN
2.4. Premier exemple
2.4.4 Visualisation du temps de calcul du microcontrôleur

Dans cette partie, on souhaite mettre en évidence les différents temps caractéristiques du
microprocesseur. Paramétrez le bloc MASTER de sorte que le Busy Flag Port et Overload Flag
Port puissent être visualisés sur les ports B0 et B1.
— Choisissez un Fixed Step Time égal à la moitié du Sample Time des blocs Unit delay,
compilez le modèle et exportez le fichier .hex généré sur le microcontrôleur.
— Visualisez avec l’oscilloscope le signal au niveau du quartz et le bit RB0 Busy Flag Port.
Observez également le bit RB1. Relevez ces signaux.
— Choisissez un Fixed Step Time égal à la moitié du Sample time les blocs Unit delay,
compilez le modèle et exportez le fichier .hex généré sur le microcontrôleur.
— Visualisez avec l’oscilloscope le signal au niveau du quartz et le bit b0 Busy Flag Port.
Observez également le bit b1 . Relevez ces signaux.
Il est difficile avec un montage aussi simple de dépasser les capacités de calcul du microcontrô-
leur. En revanche, lorsque les calculs à effectuer seront beaucoup plus importants, il conviendra
de surveiller le Busy Time du microcontrôleur. A ce propos, le bloc Others ❀ Calculus Step
Time peut fournir cette information sous forme numérique.
— Sur l’un des blocs Unit delay, ajouter un offset égal à un Fixed Step Time.
— Compilez et vérifiez avec l’oscilloscope que la LED associée au bloc sur lequel vous avez
opéré la modification s’allume avec un retard.
F. BATEMAN 17
18 F. BATEMAN
SÉQUENCES 3
PROGRAMMATION DES PERIPHERIQUES DU DSPIC
3.1 Les ports numériques
Le DsPic dispose de 5 ports référencés RA, RB, RC, RD, RF et RG. Chacune des lignes du
ports peut, au moyen de blocs Digital I/O❀Digital input et Digital output être définie comme
une entrée ou une sortie numérique. Il convient de préciser que le bloc qui précède ou suit les
blocs Digital output et Digital input doit renvoyer ou pouvoir lire un nombre de type booléen.
Lorsque ces lignes sont programmées comme des entrées/sorties numériques, elles ne peuvent
évidemment pas réaliser d’autres fonctions. Il est conseillé de se reporter à la documentation
en ligne du microcontrôleur pour prendre connaissance des fonctions réalisées par les différentes
pins.
Bascule T
La platine de développement BigDsPic6, dont la documentation est fournie avec le kit, dispose
de boutons poussoirs (BP) connectés aux ports RA, RB, RC, RD, RF et RG. Ces boutons
poussoirs permettent d’appliquer sur ces ports (configurés comme entrée) un niveau logique
haut ou bas selon la position du jumper J13.
Comme cela a déjà été entrevu, des LEDs permettent de visualiser l’état de ces ports. Des
switchs permetent d’activer ou de désactiver ces LEDS en portant leur cathode à un état logique
bas (0 Volt) ou haut (5 Volts).
Lorsqu’on appuie sur le BP RB4, on désire que la LED associée au port RB5 s’allume et
le reste lorsqu’on relâche ce BP. La LED s’éteint lorsqu’on appuie à nouveau sur le BP. Cette
fonction peut être réalisée au moyen d’une bascule D vue en cours d’électronique numérique de
première année.
— Rappelez la structure d’une bascule D possédant une entrée d’horloge H et sa table de
vérité.
— La bascule T (T désigne l’entrée de commande de la bascule reliée au BP), construite
19
Séquences 3. PROGRAMMATION DES PERIPHERIQUES DU DSPIC
avec une bascule D a pour équation :

Dn = Q̄n (3.1)
H = T (3.2)
— Réalisez la bascule T et Simulez-là sous SIMULINK (bibliothèques Logic and bit opera-
tion et Simulink extras ❀ Flip-flop ❀ D Flip-flop). La période de l’horloge H doit être
petite devant le temps d’enfoncement d’un bouton-poussoir.
— Réalisez sous SIMULINK le schéma permettant de programmer la bascule T sur le mi-
crocontrôleur, générez le code correspondant et implémentez-le sur la cible.
— Vérifiez le bon fonctionnement du système.
20 F. BATEMAN
3.2. Les UART
3.2 Les UART

Les Universal Asynchronous Receiver-Transmitter (UART) sont des périphériques qui per-
mettent au microcontrôleur de communiquer avec le monde extérieur. Cette communication
s’opère dans ce cas par une liaison série, ce qui signifie que les bits sont transmis séquentielle-
ment sur un fil en émission et sur un fil en réception. De plus, il y a un fil de masse.
3.2.1 Le protocole de liaison série RS232

Ce protocole est dédié à la transmission de données bidirectionnelle en mode full-duplex et
est illustré sur la figure 3.1. Malgré l’apparition de protocoles plus rapides et plus robustes aux
erreurs de transmission, il reste utilisé, en particulier pour la communication avec des capteurs
tels que les récepteurs GPS. Ce type de liaison est asynchrone, cela signifie que les données sont
émises ou reçues à n’importe quel moment, sans référence de temps particulière. Par conséquent,
les ordinateurs qui communiquent doivent pouvoir interrompre les programmes en cours pour
traiter ces informations. Une trame type est représentée sur la figure 3.2, elle comporte :
— 8 bits de données soit des nombres de type UINT8 ∈ [0, 255]. Le transfert d’un Single
requiert par exemple que celui-ci soit codé sur 4 octets.
— 1 bit de start.
— 1 à 2 bits de stop.
— vitesse de transmission 300 à 115200 bauds
— Les données sont émises de la broche Tx (Transmit Data du périphérique 1) vers la broche
Rx (Receive Data du périphérique 2).
— L’état 0 logique correspond à un signal de +12V alors que le 1 logique correspond à un
signal de -12V. Ces amplitudes relativement élevées visent à garantir une bonne immunité
au bruit et par là-même à assurer l’intégrité des signaux émis et reçus, et ce pour des
longueurs de connection pouvant atteindre plusieurs mètres. Pratiquement, sur la carte
BigDsPic6, un circuit MAx202 réalise cette adaptation de niveau de tension.
— La connectique de cette liaison se présente fréquemment sous la forme du connecteur
DB-9 représenté sur la figure 3.3. Ces connecteurs appelés port série et référencés COM1,
COM2, etc. tendent à disparaı̂tre au profit des ports USB. De fait, il existe des adapteurs
USB qui permettent d’émuler la liaison série RS323. La carte BigDsPic6 comporte un tel
adaptateur.
— Le protocole présenté dans ce tutoriel n’utilise que les lignes Tx , Rx et la masse GND. Il
faut toutefois savoir que d’autres protocoles de transmission utilisant les lignes de contrôle
RTS, CTS, etc. existent.
Quelques considérations sur la vitesse de transmission : Supposons que l’on ait à recevoir une
trame de N octets qui se répète k fois par seconde (typiquement, ce serait le cas des données
issues d’un GPS). Comme un octet comporte en plus, pour sa transmission, un bit de start et
un bit de stop, ce sont 10.N.k bits qu’il faut transmettre par seconde. La vitesse de transmission
B en bits/S doit vérifier : B > 10.k.N
Dans le cas d’une programmation avec SIMULINK, comme les octets sont reçus au rythme du
F. BATEMAN 21
Figure 3.1 – Une liaison série
Figure 3.2 – La trame d’une liaison série
Figure 3.3 – Connecteur DB9
22 F. BATEMAN
3.2. Les UART
1
Sample Time ou Ts , il faut aussi s’assurer que Ts ≥
k.N
3.2.2 Programmation des UARTs du DsPic

La mise en œuvre d’un protocole RS232 au niveau du DsPic nécessite l’utilisation d’un des
UARTs du microcontrôleur Le DsPic 30F6014a possède deux UART appelés UART1 et UART2,
respectivement accessibles depuis les ports :
RF2 (UART1 RX) RF3 (UART1 TX)

RF4 (UART2 RX) RF5 (UART2 TX)
Pour un programme donné, si ces lignes sont utilisées par l’UART, elles ne peuvent plus être
utilisées à d’autres fins.
Dans ce qui suit, en parallèle à la lecture de ce document, vous êtes invités à consulter l’aide
en ligne du blockset et en particulier la bibliothèque Serial Port.
Pour programmer les UARTs avec le blockset sous SIMULINK, vous devez ajouter au tem-
plate (modèle sur lequel ont déja été insérés et paramétrés les blocs Master, Compilez configu-
ration et Compile) les blocs :
— Serial Port❀UART Configuration
— Le numéro de l’UART utilisé, il faut donc deux blocs UART Configuration si on veut
réaliser deux liaisons série.
— La vitesse de transmission des données.
— Sous l’onglet Tx on gère la transmission, en particulier le niveau de priorité de l’in-
terruption. Une interruption est un arrêt temporaire de l’exécution normale du pro-
gramme par le microcontrôleur afin d’exécuter un programme jugé prioritaire, en
l’occurrence, l’émission des données. Plusieurs périphériques pouvant interrompre le
programme en cours, faut définir un ordre de priorité des interruptions. On gère éga-
lement la taille de la mémoire (Buffer) qui contient les données à émettre.
— Paramètres analogues sous l’onglet Rx.
— Ajoutez un bloc Serial Port❀Tx Output si vous souhaitez émettre des données. Noter
qu’il est possible de copier autant d’instances de ce bloc qu’il y a de données à émettre.
Ces dernières doivent être du type UINT8.
— Ajoutez un bloc Serial Port❀Rx Input si vous souhaitez recevoir des données. Les données
reçues doivent être du type UINT8, elles le sont à un rythme défini par le Sample time
du bloc. Les données reçues sont propagées dans le schéma SIMULINK à ce rythme. Le
réglage de ce temps est délicat, il procède du nombre de données à émettre et de la vitesse
de transmission en bauds. Pour le codage retenu, un baud équivaut à un bit/s.
Si les interruptions sont autorisées, un flag avertit de la présence des données (double-clic
sur le bloc Rx Input, case à cocher Received Output Flag).
Transmission de données par port série RS232

Vous allez réaliser une liaison série entre le module USB UART de la carte BigDsPic6 et un
PC. Un composant FDI implanté sur la carte émule le port série. Il s’agit très simplement
F. BATEMAN 23
d’afficher sur l’écran du PC au moyen du logiciel Realterm une suite de caractères générée par
le microcontrôleur et transmise via l’UART par une liaison série.
— Recherchez dans une table de caractères ASCII les codes décimaux correspondant aux
lettres $, A, B, C.
— Générez des constantes ayant les valeurs correspondantes et affectez-leur le type UINT8.
— Ajoutez au fichier template les blocs UART Configuration
— Paramétrez l’UART de votre choix, veillez simplement à sortir les signaux sur les bonnes
pins.
— Paramétrez la liaison à 38400 bauds.
— Ajoutez les Tx Output en sortie de chaque constante.
— Adoptez pour le solver un pas de 1ms.
— Connectez la carte BigDsPic6 (sortie USB UART) au PC par le câble USB et commutez
les switchs 1 et 2 de SW 2 en position USB UART.
— Mettez la carte BigDsPic6 sous tension.
— Sur le PC, identifiez le numéro de port série alloué par le gestionnaire de port USB :
Démarrer❀Panneau de configuration❀Performances et Maintenance ❀Système❀ Ma-
tériel❀Gestionnaire périphériques❀Ports.
— Depuis le bureau du PC, ouvrez le logiciel Realterm (cf. figure 3.4). Ce freeware permet
d’analyser les trames pour différents types de protocoles (RS232, I2C, etc.). Sélectionnez
l’onglet PORT et configurez la liaison série (numéro du port, vitesse de transmission en
baud, 8 bits de données, 1 bit de stop et aucun bit de parité).
— Compilez le programme et l’implémenter sur le DsPic, ouvrez le port sous Realterm (bou-
ton OPEN) et vérifiez que les caractères reçus sont conformes à ce qui est attendu.
Figure 3.4 – Le menu du programme Realterm
24 F. BATEMAN
3.2. Les UART
Réception-Emission de données 1 Realterm comporte une fenêtre d’édition depuis laquelle il est
possible de saisir du texte. Ce texte traduit sous forme de codes ASCII est ensuite émis vers le
port série. Ouvrez le fichier Test Rx Tx.mdl, ce programme, une fois compilé, traite les données
issues de Realterm.
— Analysez ce programme, vous prendrez le temps de lire l’aide des blocs que vous n’avez
pas encore eu l’occasion d’utiliser.
— Expliquez ce qu’il fait.
— Compilez-le et testez-le.
Réception-Emission de données 2 Modifiez ce programme de sorte que seul le caractère ASCII

a soit retransmis. Vous trouverez des fonctions de test de caractère (tester un caractère ASCII
équivaut à tester un nombre) dans la bibliothèque Logic and bit operation
Réception-Emission d’un flux de données 3 Cette situation est typiquement celle rencontrée
lorsqu’on lit un capteur délivrant des informations au format RS232. On suppose une trame
composée de trois nombres codés en UINT8.
— le caractère d’entête de trame 255,
— deux caractères de données quelconques.
Cette trame sera générée depuis Realterm, pour cela :
— onglet Port : baudrate 300, no parity, 8 bits de données, 1 bit de stop, numéro de port.
N’ouvrez pas encore le port.
— onglet Send : dans le champ dédié à cet effet, saisissez une trame telle que définie supra.
Réalisez un système qui réceptionne les données, identifie l’entête de début de trame et opère
à la somme des deux octets de données. Cette somme sera alors renvoyée sur l’hyperterminal.
Pour réaliser ce système, il convient d’opérer à une transformation série-parallèle de la trame
reçue. Cela est réalisé par un registre à décalage au moyen de blocs Discrete❀Delay.
F. BATEMAN 25
3.2.3 Visualisation des signaux

Le blockset offre des outils qui permettent de visualiser en temps réel, dans MATLAB, les si-
gnaux calculés et traités par le microcontrôleur. Ces outils utilisent un UART du microcontrôleur
et le port série du PC sur lequel MATLAB est installé.
— Ouvrez le template et adoptez un Fixed Step Time de 1ms.
— Vous allez observer un signal issu d’un compteur dont la sortie varie de 0 à 15 (bloc
Source❀Limited Counter). Réglez le Sample time pour que la période de ce signal soit
de 1,6 s.
— Vous allez, dans le même temps, observer un signal sinusoidal échantillonné (mode Sam-
pled based) d’amplitude égale à 16, de bias égal à 16, choisissez le Sample Time et le
nombre de Sample per Period pour que la période de ce signal soit égale à 1,6s. Il ne doit
pas y avoir plus de 100 points par période.
— Ajoutez un bloc UART Configuration et définissez le numéro de l’UART que vous voulez
utiliser. Le choix de la vitesse de transmission va dépendre :
— du nombre de signaux à observer (jusqu’à 16) en mode alterné,
— de la fréquence de ces signaux. Par exemple, si l’on désire observer 2 signaux dont
la fréquence n’excède pas 100 Hz avec pour chacun une résolution de 10 points par
période, il faut 20 points par période de 10 ms soit 2000 points par seconde. Comme
chaque donnée est codée sur deux octets 1 , cela représente 4000 octets, soit 40000 bits
(bits de start et de stop à inclure). On doit donc fixer une vitesse de transmission
supérieure, le choix se portera sur 57600 bauds.
— Pour l’envoi de ces signaux vers le PC, il faut ajouter autant d’instances du bloc Serial port
❀ Tx Labview Matlab qu’il y a de signaux à visualiser. Ces blocs admettent des nombre
du type UINT16 (chaque information est codée sur 2 octets), il faut donc adapter le type
des signaux qu’on veut visualiser, au besoin en insérant un bloc Data type conversion.
Il faut ensuite paramétrer ces blocs en allouant à chaque bloc Tx Labview Matlab un
numéro de voie compris entre 0 et 15. Une fois le schéma terminé, il reste à le compiler
et à implémenter le programme sur le microcontrôleur.
— La liaison entre le microcontrôleur et le PC reste identique à celle câblée précédemment.
Sur le PC, depuis le Command Window de MATLAB, taper rs232gui. Reportez le numéro
de port COM et appuyer sur le bouton Connexion puis sur Start. Les signaux apparaissent alors
dans une fenêtre. Pour plus de détails sur cette fonction, se reporter à l’aide en ligne Serial
port❀Interface Tx Matlab.
Par défaut, la fonction rs232gui affiche des nombres de type UINT16, donc strictement
positifs. Pour visualiser des nombres négatifs de type INT16, cliquez sur le bouton plot int16. A
titre d’exemple, portez le champ Bias du signal sinusoı̈dal à 0, recompiler le modèle et observer
les signaux sur rs232gui.
Les données affichées sont stockées dans 2 tableaux référencés R et Rn pouvant respective-
ment contenir 50000 et 10000 points. Les vecteurs t R et t Rn contiennent les valeurs des temps
auxquels ont été réalisées ces simulations. Il est donc possible d’opérer à un post-traitement de
1. On reviendra sur ce point un peu plus loin.
26 F. BATEMAN
3.2. Les UART
ces données sous MATLAB.
F. BATEMAN 27
3.3 Le bus SPI
Le bus SPI (Serial Peripheral Interface) est un bus série synchrone qui opère en mode full-
duplex 2 . La communication s’opère au rythme d’une horloge entre un maı̂tre et un esclave, ce
dernier est sélectionné par le biais d’une ligne de contrôle CS (chip select) ou SS active à l’état
bas. Les données échangées sont codées sur 8 ou 16 bits. Une ligne est dédiée à l’émission, une
autre ligne à la réception. Si ce bus est rapide, il nécessite en revanche des liaisons courtes entre
le maı̂tre et l’esclave et il faut un CS par esclave.
— SCK : l’horloge générée par le maı̂tre,

— MOSI : Master Output - Slave Input ou SDI sur le DsPic,
— MISO : Master Input - Slave Output ou SDO sur le DsPic,
— SS : ligne active à l’état bas qui permet d’activer le SS ou CS de l’esclave.
La figure 3.5 illustre ce protocole et la figure 3.6 montre les signaux dans le cas d’une écriture
du maı̂tre vers l’esclave.
Figure 3.5 – Communication entre un maı̂tre et un ou plusieurs esclaves
2. Communication bidirectionnelle.
28 F. BATEMAN
3.3. Le bus SPI
3.3.1 Application : contrôle d’un DAC (Digital to Analog Converter)

Le DsPIC 30F6014A n’intègre pas de convertisseur numérique - analogique. Il est toutefois
possible d’en contrôler un avec le port SPI. L’intérêt est de pouvoir opérer à des conversions à
fréquence élevée. Ce qui peut s’avérer utile pour des applications audio embarquées. Pour débit
Pour cette application, on met en œuvre le convertisseur 12 bits MCP4921 dont on trouvera la
notice dans le dossier Datasheet sur le Bureau. Ce composant est implémenté sur un support
réalisé par la société MIkroElektronika et se plugge directement sur la carte BigDsPic6.
1. Sur la documentation du DsPic, Identifier les ports alloués au bus SPI2,

2. Sur la carte du DAC 12 bits, vous veillerez à ce que les switchs aient la configuration
suivante :
— SW 1,2, 4, 6,7 : Off
— SW 3, 5, 7 : On
— Cavalier sur 4.096V, ainsi la résolution du DAC 12 bits sera de 1mV.
3. Plugger le DAC12 bits sur le port G,
4. Sur la carte BigDsPic6, commuter les switchs de SW12 sur MOSI, MISO, SCK,
¯ associée à RG9, cette dernière ne peut être reliée

Bien que le 30F6014A possède une ligne SS
au CS du DAC 12 bits. On utilise en lieu et place le port RG1 qu’on utilisera comme ligne de
sélection du DAC 12 bits lorsqu’on voudra convertir les données.
On veut générer un signal sinusoı̈dal analogique de fréquence 440Hz (soit un LA naturel). Le

signal source est échantillonné à 8kHz, soit un Fixed-Sample-Time égal à 1.25e−4 s. Toutefois,
comme le signal de CS alterne entre les valeurs 1 et 0, on prend un Fixed-Sample-Time deux
fois plus rapide, soit 6.25e−5 s.
1. Modifier le template pour régler le Fixed-Sample-Time désiré,
Figure 3.6 – Les signaux du protocole SPI
F. BATEMAN 29
2. Ajouter une source sinusoı̈dale : Sources ❀ Sine Wave et paramétrer ce bloc de sorte
qu’il produise un signal d’amplitude crête égale à 2048, de valeur moyenne égale à 2048
(bias) et qu’il génère par période un nombre d’échantillons tel que le signal de sortie ait
une fréquence 440 Hz et soit échantillonné à 8000Hz (choisissez l’option Sine Type ❀
Sampled Base.
3. Ajouter un bloc SPI config pour définir la configuration du port SPI paramétré comme
suit : { Port 2, Master, SDO Enable, données sur 16 bits, fréquence d’horloge réglé avec
le prescaler à 416kHz}.
4. Ajouter un bloc SPI Input-Output, ce bloc est paramétré comme suit : {Port 2, Always
Enable, SPI Input 3 , SPI Output}. L’entrée de ce bloc sera reliée à la source sinusoı̈dale
par l’intermédiaire d’un bloc Commonly Used Blocks❀convert❀ UINT16.
5. Pour contrôler le SS, ajouter un bloc Digital Output paramétré sur RG1 et piloté par
un Sources❀ Limited counter qui compte jusqu’à 1 (soit 0, soit 1) à une cadence de
6.25e−5 s.
La donnée issue du bus SPI est constituée des 12 bits de poids faible, les 4 bits de poids fort
sont utilisés pour le contrôle du DAC 12 bits, en particulier, si l’on se réfère à la datasheet de ce
composant page 18, vous justifierez l’intérêt de régler les bits b12 et b13 à 1.
— Comment pourrait-on simplement modifier la donnée (le signal sinusoı̈dal codé en UINT16)
pour régler les bits b12 et b13 à 1 ? La fonction bin2dec convertit un mot binaire en
nombre décimal, elle peut vous aider à comprendre coment réaliser cette modification.
— Sauvegardez votre modèle et générez le fichier hex correspondant. Transférez-le sur le
microcontrôleur et observez avec l’oscilloscope le signal ainsi généré.
— Observez à l’oscilloscope les signaux du bus SS, SCK et MOSI en vous synchronisant sur
le front descendant de SS.
— Il est possible d’utiliser les différentes sources fournies par SIMULINK pour générer des
signaux de différentes natures. Attention toutefois à les convertir au format UINT16.
Veillez également à ce que l’amplitude de ces signaux aient des valeurs cohérentes avec le
format UINT16 (c-à.d ∈ [0 − 65535]).
3. Normalement, on n’aurait pas à activer cette option mais si la case est décochée, le DAC ne fonctionne pas.
30 F. BATEMAN
3.4. Convertisseurs Analogiques-Numériques
3.4 Convertisseurs Analogiques-Numériques

Il s’agit de numériser des signaux analogiques et de mettre en évidence les limites de cette
opération.
Au moyen du générateur basses-fréquences (GBF), générez un signal sinusoı̈dal de fréquence
50 Hz dont l’amplitude crête à crête varie entre 0 et 5 Volts et visualisez-le sur l’oscilloscope.
Au moyen d’un bloc ADC Analog to Digital Converter ou CAN, réalisez une conversion
analogique-numérique du signal sinusoı̈dal délivré par le GBF. En exploitant la documentation
HTML de ce bloc, paramétrez-le de sorte que le signal sinusoı̈dal soit échantillonné à 200 Hz.
Pour ce faire, cette conversion sera déclenchée par une source extérieure mode trigger. Vous
pourrez réaliser facilement la source qui déclenche les conversions en utilisant un Source ❀
Counter limited.
Pour l’observation des signaux, vous mettrez en œuvre un bloc TX Labview Matlab, la
transmission des données sera cadencée à 115200 bauds et le Fixed Step Time réglé à 1.10−4 .
Pour une telle vitesse de transmission, le dsPIC Master est cadencé à 40 MIPS.
Dans la fenêtre rs232gui, affecter la valeur 200 à Rn, cela limitera la durée d’observation des
signaux. N’hésitez pas à chercher dans l’aide la syntaxe de la fonction axis.
— Observez sous rs232gui le signal échantillonné, avec le curseur, relevez la période d’échan-
tillonnage et l’amplitude crête à crête de ce signal dont on rappelle qu’il est codé sur 12
bits, autrement dit 5V équivalent à 4096.
— Représentez le spectre du signal échantillonné.
F. BATEMAN 31
3.5 Les signaux PWM

Mise en œuvre des fonctionnalités Output Compare et Input Capture.
3.5.1 Définition d’une PWM

Le principe de fonctionnement de ces deux blocs repose sur la génération ou l’analyse d’un
signal carré à rapport cyclique variable (Duty Cycle). Sur la figure 3.7 vous pouvez observer
différentes valeurs de rapport cyclique avec la forme du signal qui en résulte. Le rapport cyclique
a pour expression a = ∆t T , avec :
— ∆t : temps du signal à l’état haut
— T : période du signal
— a : rapport cyclique
Lorsque a est fonction du temps, le signal à rapport cyclique variable est qualifié de PWM
(Pulse Width Modulation).
Figure 3.7 – Le menu du programme Realterm
Exemples d’utilisation :
— L’échange d’informations entre un capteur (température, accéléromètre, etc.) et un mi-
crocontrôleur ou entre microcontrôleurs,
— La commande de moteurs à travers des transistors de puissance.
3.5.2 Génération d’une PWM

Pour cela vous allez dans un premier temps réaliser un programme qui permet le codage
numérique d’une entrée analogique (ADC Input). Cette entrée sera reliée par cavalier à l’un des
32 F. BATEMAN
3.5. Les signaux PWM
deux potentiomètres (A/D converter input) présents sur votre carte de développement. Vous
êtes libre du choix de l’entrée (RB8, RB9, ..., RB15).
— Paramétrez le convertisseur analogique numérique (bloc ADC Input) en utilisant une
tension de référence externe. Pratiquement la tension de 4, 096V générée sur la carte
BigDsPic6 (consultez le manuel de cette carte p 13). Vous paramétrerez le rythme des
conversions (Trigger Source) en mode auto convert.
— Visualisez le signal issu de la conversion analogique numérique au moyen de rs232gui et
d’un bloc Tx Labview Matlab.
— Configurez ensuite le bloc Peripheral I/O❀Output Compare HW, celui-ci vous permettra
de générer un signal à rapport cyclique variable directement proportionnel à la tension
d’entrée du potentiomètre que vous avez choisi. Pour la configuration des paramètres du
bloc consulter l’aide. On opère les choix suivants :
— Channels Input Type : la PWM est définie par sa période et sa durée à l’état haut.
— La Period Max vaut 20ms (période typique pour des servocommandes).
— La variable OCmax est essentielle. Pour un signal égal à OCmax à l’entrée du bloc
Output Compare HW correspond un rapport cyclique a = 100%. Vous pouvez accéder
à la valeur de OCmax depuis le Workspace de MATLAB qui sera mis à jour après
une configuration de votre programme.
— Pour fonctionner, le bloc Output Compare HW est piloté par l’entrée (OCx Up) qui
prend ses valeurs dans [0, OCmax]. Attention, le seul format d’entrée admissible par
le bloc est le type UINT16. Au moyen d’un gain, réalisez la fonction qui transforme le
signal issu de l’ADC ([0, 4095]) en un signal de type UINT16 qui varie dans l’intervalle
[0, OCmax].
— Observez à l’oscilloscope le signal de sortie modulé en rapport cyclique à l’aide du po-
tentiomètre. En parallèle, relevez avec rs232gui le signal issu de l’ADC. Pour connaitre
les pins utilisées dans votre programme, affichez le Port info et cliquer dessus pour la
mise à jour. Attention malgré tout à vérifier sur la documentation (datasheet de votre
composant) des erreurs peuvent apparaitre.
3.5.3 Décodage d’un signal PWM

Dans ce qui suit, l’objectif est de décoder une PWM (période, durée de l’état haut ou bas
etc.), par exemple, celle issue du signal généré par le module Output Compare HW précédem-
ment programmé. Plus généralement, la PWM peut permettre de transmettre des informations.
Ces dernières proviennent par exemple d’une radiocommande et sont décodées par le microcon-
trôleur.
— Mettez en place un bloc Input Capture dans votre programme et consultez l’aide pour la
configuration.
— De la même façon que précédemment, la valeur de ICimax vous sera donnée dans le
Workspace de MATLAB.
— Au moyen du rs232gui, vous visualiserez la valeur du temps haut de votre signal d’entrée
ainsi que sa période (sorties ICx Up et ICx Periode).
— Avant de compiler votre programme, assurez-vous qu’aucune pins ne soit utilisée plus
d’une fois.
F. BATEMAN 33
— Pour effectuer la mesure, réalisez une liaison filaire entre la sortie Output Compare HW
et l’entrée Input Capture. Attention les données inscrites dans Port info sont erronées
pour le bloc Input Capture, reportez-vous au datasheet du microcontrôleur.
— Faire varier le rapport cyclique du signal d’entrée de Input Capture avec le potentiomètre
et relevez la valeur mesurée.
— Vérifiez la cohérence de vos mesures avec la valeur de ICxmax. Par exemple, si la valeur
de ICxmax est 9999 et la valeur du rapport cyclique du signal d’entrée de 0,2. Le résultat
en sortie doit être très proche de 2000.
— Relevez les valeurs de ICi Up et ICi Periode pour les valeurs de rapport cyclique extrêmes.
Commentez les résultats. Comment peut-on modifier ces valeurs ?
34 F. BATEMAN
3.6. Le bus I2C
3.6 Le bus I2C

Le bus I2C est un bus de données série, asynchrone, bidirectionnel et half-duplex (deux
sens de communication possibles mais pas simultanément). Les équipements connectés au bus
sont maı̂tres ou esclaves, et réciproquement. Il faut noter que les échanges ont toujours lieu à
l’initiative du maı̂tre vers un esclave.
,D’un point de vue électrique le bus nécessite trois conducteurs : la masse, l’horloge (SCL,
Serial Clock) et les données (SDA, Serial Data). L’impédance de chaque équipement sur le bus
doit être absolument adaptée, la charge capacitive maximale des conducteurs SDA et SCL est
de 400 pF. Les deux lignes SDA et SCL sont reliées au niveau de tension VDD à travers des
résistances de tirage (< 3.5 KOhms).
Dans ce qui suit, le microcontrôleur pilote des cartes de contrôle de moteurs brushless via
le bus I2C. L’intérêt de ce bus pour le contrôle d’un multirotor réside dans le nombre limité de
conducteurs entre le microcontrôleur et les cartes de contrôle des moteurs.
Le protocole I2C
Le protocole se décompose en deux temps, le premièr définit l’adresse de l’esclave concerné

et la seconde contient les données envoyées ou réceptionnées par le maı̂tre. Le maı̂tre, avant
d’envoyer des informations sur le bus, s’assure que celui-ci est disponible. Alors, ensuite, il passe
la ligne SDA de l’état haut à l’état bas, tout en maintenant la ligne SCL à l’état haut, c’est la
condition de départ (bit de Start). Le maı̂tre envoie alors l’adresse de l’esclave désigné qui est
composée de huit bits dont un bit (possibilité d’un codage sur 10 bits) qui précise l’écriture ou la
lecture des données (Read à 1, Write à 0). L’esclave renvoie alors un bit d’acquittement ACK ou
de non acquittement NACK pour informer de la prise en compte de l’information. Les données
sont codées sur un ou plusieurs octets et envoyées du maitre vers l’esclave ou inversement, avec
acquittement à la réception. Sur la Figure 3.8 illustre la structure du protocole I2C lors d’une
phase d’écriture. La Figure 3.9, montre les signaux SDA (en haut) et SCL (en bas) pour une
écriture de la valeur 10 à l’adresse 82 (en décimal).
Figure 3.8 – Structure de la trame I2C
Commande d’un moteur brushless
Dans cette partie, vous mettrez en œuvre un bus I2C dans le but de contrôler un moteur
brushless ou moteur sans balai utilisé en aéromodélisme. Ce moteur est contrôlé par une carte
de contrôle des moteurs brushless (Bl-Ctrl) qui fournit la puissance électrique au moteur. Cette
carte permet également de mesurer le courant consommé et la vitesse du moteur. Le bus I2C peut
F. BATEMAN 35
travailler à des cadences d’horloge élevées, typiquement 400kz. Il est ainsi possible de contrôler
plusieurs périphériques en raffraichissant les commandes à un rythme élevé. Cela est particuliè-
rement intéressant pour le contrôle des drones à voilure tournantes tels que les quadrirotors.
Commande d’un moteur brushless sur 8 bits

Pour réaliser ce montage, reportez-vous aux documentations du microcontrôleur, de la Bl-Ctrl
http://www.mikrokopter.de/ucwiki/fr/BL-Ctrl_2.0 et à la figure 3.12. Toutes les cartes
sont hors tension.
— Reliez les ports SCL et SDA ainsi que la masse du microcontrôleur aux points C (SCL)
Figure 3.9 – Relevé d’une trame I2C
Figure 3.10 – Moteur brushless
36 F. BATEMAN
3.6. Le bus I2C
et D (SDA) ainsi qu’à la masse de la Bl-Ctrl.

— Commutez les switchs SWI2 SCL et SDA en position I2C.
— Reliez les trois phases du moteurs brushless notées sur les câbles A, B, C aux sorties A,
B, C de la Bl-Ctrl.
L’alimentation ne doit pas encore être reliée à la carte Bl-Ctrl.

— Mettre l’alimentation sous tension, régler la tension à 15 Volts et ne pas limiter le courant,
en effet, les demandes en courant peuvent atteindre 10A (ce qui dépasse les capacités de
l’alimentation.)
— Couper l’alimentation et connecter-la à la Bl-Ctrl.
— Relier la masse de la BL-Ctrl à la masse de la carte BigDsPic6.
— Ouvrir le fichier I2C.mdl et analyser les paramètres du bloc I2C Master qui permet
de piloter une carte de contrôle Bl-Ctrl pour un moteur brushless depuis un bus I2C.
L’adresse de la carte est 82 (décimal), la commande du moteur est codée sur un octet ([0,
255]) et la fréquence du bus est de 400 kHz. Les données sont transmises sur le bus avec
un Sample Time égal à 2 ms. Par défaut, dans ce montage, la commande est égale à 10.
Soyez prudent à ne pas appliquer un nombre trop grand, l’hélice atteindrait des vitesses
de rotation très élevées.
— Compiler le schéma et implémenter-le sur le microcontrôleur, le moteur doit tourner. Pour
le stopper, cliquer sur le bouton Erase du programme DsPicFlash.
Commande d’un moteur brushless sur 11 bits

Pour un contrôle plus fin de la vitesse des moteurs, il est possible de contrôler la Bl-Ctrl sur
11 bits ([0,2047]). Pratiquement, les données sont codées sur 2 octets sur le bus I2C, les bits
{11 . . . 15} n’étant pas pris en compte par la Bl-Ctrl.
Figure 3.11 – Carte Bl-Ctrl

+12V-8A
moteur
sda
DsPic scl BCTRL
gnd
Figure 3.12 – Plan de cablâge du moteur
F. BATEMAN 37
0 0 0 0 0 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0
Il faut réaliser une fonction qui, partant d’un mot codé sur 16 bits et compris dans [0, 2047]
génère ce mot sur 2 octets codés en UINT8.
L’octet de poids faible ou LSB 4 contiendra les bits
0 0 0 0 0 b 2 b1 b0
L’octet de poids fort ou MSB 5 contiendra les bits
b10 b9 b8 b7 b6 b5 b4 b3
On se rappellera qu’un décalage d’un bit à droite équivaut à une division par deux.
0 0 0 0 0 0 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1
On se rappellera qu’un décalage d’un bit à gauche équivaut à une multiplication par deux,
0 0 0 0 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 0
Réalisez sous SIMULINK un schéma de simulation qui transforme un nombre de type
UINT16 dont la valeur peut varier entre 0 et 2047 en deux nombres codés sur 8 bits. Les
octets de poids faible et de poids fort doivent avoir la structure proposée ci-dessus.
Modifiez le modèle I2C.mdl pour contrôler le moteur avec un mot de commande codé sur
deux octets et dont la valeur peut varier entre 0 et 2047. Sur la Bl-Ctrl, les octets doivent être
transmis dans l’ordre suivant :
MSB LSB
Lecture d’octets depuis un bus I2C

Pour cet essai, vous reprendrez le modèle du système qui permet l’écriture d’un mot de 8 bits
sur le bus I2C.
Le bus I2C permet également de lire des données issues de périphériques externes. En par-
ticulier, la carte Bl-Ctrl est également accessible en lecture à l’adresse 83. Il est notamment
possible de lire :
— octet 1 : l’intensité du courant absorbé par le moteur
— octet 2 :
— octet 3 :
— octet 4 : la vitesse du moteur en tours/s
— octet 5 : la tension d’alimentation de la carte Bl-Ctrl
Pour lire ces données, il faut ouvrir une nouvelle instance du bloc I2C Master et l’ajouter au
modèle qui comporte déjà un premier bloc I2C Master pour l’écriture sur la carte Bl-Ctrl.
4. Less Significant Byte

5. Most Significant Byte
38 F. BATEMAN
3.6. Le bus I2C
— En lecture, la carte Bl-Ctrl doit être adressée à l’adresse 83.

— Paramétrer le bloc I2C Master de façon à pouvoir lire les cinq premiers octets. Attention,
pour pouvoir fonctionner correctement, la séquence de lecture des cinq octets doit être
suivie d’une opération d’écriture (cependant aucun octet ne doit être envoyé) 6 .
— Connecter un bloc Tx Labview Matlab de façon à pouvoir enregistrer la vitesse du mo-
teur.
— Appliquer à l’entrée du bloc I2C un signal dont la valeur varie discrètement de 0 à 100
(utiliser un Counter Limited) et relever la vitesse de rotation du moteur. La constante de
temps du moteur est de l’ordre de 100 ms, il vous faut tenir compte de cette information
pour cadencer correctement le signal appliqué à l’entrée du bus I2C.
Relevé des caractéristiques de l’ensemble {Bl-Ctrl-Brushless-Hélice}

On conserve le même montage que précédemment.
— Mettez en œuvre le banc moteur Brushless muni de son hélice et piloté par la carte Bl-
Ctrl. Installer une balance/masselotte en vue de mesurer la poussée exercée par l’hélice.
— Relevez la caractéristique statique f (N ) où f désigne la fréquence de rotation du
moteur et N l’octet de commande appliqué à la Bl-Ctrl.
— Relevez également la tension d’alimentation et le courant. Calculer la puissance élec-
trique et visualiser-là.
— Relevez pour chaque acquisition de f la poussée P exercée par le groupe moto-
propulsif.
— Représentez la caractéristique P (f 2 ), vous êtes invités à relever les points de cette carac-
téristique dans un tableau sous MATLAB. Au moyen de la fonction polyfit, proposez une
approximation polynômiale de cette caractéristique et donnez une expression de P (f 2 ).
— Proposez une modification du montage du moteur sur le banc qui permette de relever la
trainée générée par l’hélice.
6. Nous n’avons pas à ce jour d’explication sur ce point.
F. BATEMAN 39
3.7 Insertion de code

3.7.1 Insertion de code C
Le blockset permet d’insérer dans des blocs des programmes codés en langage C Others❀C
function call. Cela peut permettre de réaliser des fonctions qui n’existent pas sous SIMULINK.
Dans ce qui suit, les programmes le code source figure dans le fichier essai .c, lequel appelle les
fonctions déclarées dans le bloc C function call.
Premier exemple
Un exemple simple peut être consulté en ouvrant le fichier Programme en C.mdl. Vous consul-
terez par ailleurs l’aide du bloc C function call pour comprendre le paramétrage du bloc. Il faut
en particulier indiquer le nom du fichier *.C sous Simulation Real-Time Workshop Custom
Code Source files.
— Compilez ce modèle puis implémentez le programme *.hex sur la cible et visualisez le
résultat de l’opération programmée au moyen de rs232gui.
Second exemple : cinématique de rotation d’un solide

Le contrôle des véhicules aérospatiaux requiert le contrôle de leur attitude. Il est théoriquement
possible de calculer cette dernière à partir de la mesure des vitesses angulaires réalisées par les
gyromètres de roulis, de tangage et de lacet. Ces vitesses angulaires sont respectivement notées
p, q et r. Les angles d’attitude qui permettent de localiser la position du repère véhicule par
rapport à un repère de référence sont respectivement les angles de gı̂te ϕ, d’assiette θ et le cap
ψ. On montre que :
ϕ̇ = p + q sin ϕ tan θ + r cos ϕ tan θ

θ̇ = q cos ϕ − r sin ϕ
cos ϕ
sin ϕ
ψ̇ = q+ r (3.3)
cos θ cos θ
— Quelles sont les limites de cette représentation de l’attitude ?

— Au moyen d’un bloc C function call implémentez ces équations.
— Ajouter à ce schéma les fonctions nécessaires à l’obtention des angles de gı̂te ϕ, d’assiette
θ et le cap ψ.
— Insérez des blocs Tx Labview Matlab afin de relever les angles d’attitude.
— Pour tester cette fonction, appliquez successivement aux entrées des signaux émulant des
vitesses angulaires constantes, par exemple du roulis seul puis du tangage seul enfin du
lacet seul.
— Pratiquement, les mesures des vitesses angulaires peuvent être obtenues avec la centrale
MTI qui sera utilisée lors d’une séance de TP pour réaliser une centrale d’attitude.
Troisième exemple : gestion des périphériques du DsPic

Il est possible de reprogrammer ou d’améliorer les fonctionnalités proposées par le blockset.
Ainsi, le fichier Programme en C2.mdl associé au fichier essai .c et à la fonction cna écrit un mot
40 F. BATEMAN
3.7. Insertion de code
de 8 bits sur le port D. La fonction TRISD, propre au C des microcontrôleurs de cher Microchip
déclare le port D en sortie tandis que la fonction LATD recopie sur ce même port le mot de 8
bits contenu dans la variable qui lui est affectée.
3.7.2 Insertion de code MATLAB

Le bloc Embedded Matlab Function que l’on trouve dans la bibliothèque User defined func-
tions appelle une fonction écrite sous MATLAB pour laquelle le code C correspondant est généré
en vue de pouvoir être utilisé dans des applications temps réels. Ces blocs sont particulièrement
intéréssants car ils permettent de disposer de la diversité des fonctions proposées par MATLAB.
L’exemple qui suit vous montre sur un exemple simple comment utiliser un tel bloc.
Soit à coder l’équation d’état :
! !
0.5 0 3
xk+1 = xk + εk
0 −0.5 1
yk+1 = xk+1 (3.4)
Pour faire simple, εk est un signal sinusoı̈dal d’amplitude unitaire et de fréquence égale à
1rad/s. Sous SIMULINK, on réalise le schéma suivant (3.13) :
Figure 3.13 – Embedded MATLAB Function
Le code programmé dans l’Embedded Matlab function :
function [ y ] = observateur ( erreur )

%UNTITLED Summary o f t h i s f u n c t i o n g o e s h e r e
% Detailed exp lan ation goes here
A= [ 0 . 5 , 0 ; − 0 . 5 , 0 ] ;
B= [ 3 ; 1 ] ;
persistent x; % l e typ e p e r s i s t e n t e s t mémorisé e t a c t u a l i s é à
% chaque Sample Time
i f is em p ty ( x ) ; % Ce t e s t permet d ’ e n t r e r dans l a b o u c l e i f une f o i s
% l o r s de l ’ i n i t i a l i s a t i o n
F. BATEMAN 41
x=[0;0]; % e t d ’ a l l o u e r d es v a l e u r s à x
end ;
x=A∗ x+B∗ e r r e u r % L ’ é t a t p r é s e n t e s t c o r r i g é par l ’ e r r e u r au t r a v e r s

% d es g a i n s
y = x; % L ’ é q u a t i o n de s o r t i e
end
Cette fonction est appelée et exécutées à chaque Sample Time (utilisez un bloc Rate Tran-
sition, sinon la fonction sera appelée au rythme du Fixed Step Time ). L’intégrité des valeurs
prises par les variables de type persistent doit être assurée entre deux appels de la fonction
(intervalle de temps d’un Sample Time.
Substituez au bloc scope un démultiplexeur et deux blocs Tx Labviex Matlab pour observer
chacune des variables du vecteur x.
42 F. BATEMAN
Deuxième partie
TRAVAUX PRATIQUES
43
TP 1
MODÉLE D’UN DRONE Á VOILURE TOURNANTE
1.1 Objectif
Au cours de cet séance de TP, vous aurez à implémenter sous Matlab Simulink le modèle
d’un drone à voilure tournante (hexacotpère, octocoptère) comme illustré sur la figure 1.1.
Des expérimentations conduites en parallèle seront nécessaires pour établir les valeurs numé-
riques de certains paramètres.
Les fonctions qui réalisent le modèle devront être encapsulées dans des sous-systèmes. Le bloc
de plus haut niveau sera défini comme un masque depuis lequel il sera possible de paramétrer
le drone.
1.1.1 Liste du matériel

— Hexacoptère ou octocoptère Mikrokopter,
— Banc moteur + balance,
— Carte de développement BigDsPic6, câbles USB,
— Portique et suspente,
— PC + MATLAB-SIMULINK, MPLAB.
1.2 Équations d’état d’un drone à voilure tournante

Ces équations sont celles d’un quadrirotor et vous devrez les adapter au drone étudié. Pour
les équations présentées, les repères retenus sont représentés sur les figures 1.2 et 1.3. Vous vous
reporterez au support de cours Supervision de Drones pour le descriptif des variables.
45
TP 1. MODÉLE D’UN DRONE Á VOILURE TOURNANTE
Figure 1.1 – L’hexacoptère
Figure 1.2 – Quadrirotor et repère attaché
Les équations d’état qui décrivent les dynamiques et les cinématiques de rotation 1 :
1
ṗ = kℓ(ω42 − ω22 ) + (Iyy − Izz )qr
Ixx
1
q̇ = kℓ(ω12 − ω32 ) + (Izz − Ixx )rp
Iyy
1
ṙ = dℓ(−ω12 + ω22 − ω32 + ω42 )
Izz
ϕ̇ = p + q sin ϕ tan θ + r cos ϕ tan θ
θ̇ = q cos ϕ − r sin ϕ
q sin ϕ + r cos ϕ
ψ̇ = (1.1)
cos θ
1. Vous vous reportez au document Supervision de Drones pour comprendre comment ont été établies ces
équations.
46 F. BATEMAN
1.2. Équations d’état d’un drone à voilure tournante
−
→
xb
−
→1
x −
−
→ θ y→
E
x −
y→
E
ψ ψ
12
ϕ −
→
yb
ϕ
θ
−
→
z2
−
→
zb
−
→
z1
Figure 1.3 – Passage du repère drone Rb au repère de référence RE supposé galiléen
Figure 1.4 – Synoptique des dynamiques et des cinématiques
ku |u|u
u̇ = −g sin θ − − qw + rv
m
kv |v|v
v̇ = g cos θ sin ϕ − + pw − ru
m
P4
kωi2
i=1 kw |w|w
ẇ = g cos θ cos ϕ − − − pv + qu
m m
x˙E = {cos θ cos ψ}u + {sin ϕ sin θ cos ψ − cos ϕ sin ψ}v + {cos ϕ sin θ cos ψ + sin ϕ sin ψ}w
y˙E = {cos θ sin ψ}u + {sin ϕ sin θ sin ψ + cos ϕ cos ψ}v + {cos ϕ sin θ sin ψ − sinϕ cos ψ}w
z˙E = {− sin θ}u + {sin ϕ cos θ}v + {cos ϕ cos θ}w
F. BATEMAN 47
1.3 Travail demandé

Le drone est supposé rigide et de masse constante. Les sous-systèmes suivants sont à réaliser
sous Matlab Simulink et à organiser comme illustré sur la figure 1.4 :
— le modèle des forces et des moments produits par le groupe motopropulsif,
— le modèle de la dynamique de rotation,
— le modèle des cinématique de rotation,
— le modèle de la dynamique de translation,
— le modèle des cinématiques de translation.
Ces quatre modèles réalisent la plateforme à six degrés de liberté (6 DoF).
Ces modèles nécessitent de connaitre la masse et les moment principaux d’inertie du drone.
Ces paramètres seront obtenus par pesée et pendulage (cf figure 1.5).
Figure 1.5 – Pendulage

T2 mgR2
I=
4π 2 L
Les composantes de la résultante des forces Fx , Fy , Fz procèdent :
— de la force de portance des hélices,
— du poids du drone,
— de la trainée aérodynamique du drone.
Par ailleurs, les moments L, M , N ont pour origine les forces de portance et de trainée des
hélices.
1.4 Détermination des paramètres

Au moyen du banc moteur (cf figure 1.6), il vous est demandé de conduire les essais qui
permettront de déterminer les valeurs des coefficients de poussée et de trainée des hélices en
48 F. BATEMAN
1.5. Test du modèle
fonction de la vitesse de rotation.
Figure 1.6 – Banc moteur
Il pourrait également être intéressant d’affiner le modèle des hélices en caractérisant leur
coefficients de poussée et de trainée lorsqu’elles fonctionnent au voisinage du sol (effet de sol).
Les vitesses de rotation des moteurs sont asservis à des consignes. Il y a cependant à prendre
en compte les caractéristiques dynamiques de ces boucles d’asservissement qui sont assimilées
à des systèmes du premier ordre de gain unitaire, de constante de temps égale à 30 ms avec
retard pur de 30 ms. Vous réaliserez ces modèles du premier ordre au moyen de blocs décrivant
une représentation d’état (Continuous ❀ State-Space pour lesquels vous règlerez les vitesses de
rotation des hélices à l’instant initial égales à leurs valeurs d’équilibre.
1.5 Test du modèle

Appliquez au modèle des commandes correspondant à leurs valeurs d’équilibre puis ajoutez à
ces commandes de petites variations autour de l’équilibre et analysez les mouvements du drone.
Observez les réponses obtenues et validez le modèle.
1.6 Elaboration des variables additionnelles

Ces variables représentent des grandeurs qui pourront être mesurées et à partir desquelles
seront implémentées, dans la phase de synthèse de ce TME, l’estimateur d’attitude, le contrôle
d’attitude, le filtre de Kalman qui élabore la hauteur et la vitesse ascensionnelle et le contrôle
de trajectoire. Soit :
F. BATEMAN 49
— Les accélérations mesurées selon −

→
x b, −
→
y b et −
→
z b respectivement notées accx , accy et accz .
Ces mesures sont échantillonnées à 100 Hz.
— Les vitesses angulaires autour de − →
x b, −
→
y b et −
→
z b respectivement notées gyrx , gyry et gyrz .
Ces mesures sont échantillonnées à 100 Hz.
— La hauteur du drone, cette mesure est échantillonnée à 10Hz.
— Les mesures des coordonnées x et y dans le repère terrestre Re .
1.7 Pour aller plus loin

1.7.1 Prise en compte des variations de l’atmosphère
On pourrait utiliser un modèle d’atmosphère dans lequel la densité de l’air ρ est fonction de
la température et de l’altitude.
1.7.2 Modélisation de la trainée aérodynamique

La trainée aérodynamique du drone ayant un impact non négligeable sur les performances
du drone lorsqu’il se déplace, il vous est demandé de réfléchir à une expérience (ou plusieurs) qui
pourrai(en)t être conduite(s) afin de déterminer ces coefficients de trainée. S’il n’est pas possible
de la (ou les conduire), ces coefficients seront temporairement réglés à 0.
1.7.3 Contact avec le sol

Au contact du sol, que ce soit au moment du décollage ou de l’atterrissage, le drone adopte
un comportement différent de celui en vol. Aussi, il peut être intéressant de caractériser ces deux
modèles. En effet :
1. lors du décollage, la réaction du sol est a prendre en compte dans le modèle afin d’éviter
une commande des gaz trop importante sur un moteur pouvant conduire au retournement
du drone.
2. lors de l’atterrissage, prendre en compte les effets de sol et la résultante du sol afin d’éviter
un posé dur ou des rebonds.
50 F. BATEMAN
TP 2
ESTIMATION D’ATTITUDE
2.1 Objectif
L’attitude désigne l’orientation d’un repère attaché à un solide (pratiquement un aéronef)
par rapport à un repère de référence (pratiquement un repère attaché à la terre). Différents
formalismes permettent de décrire l’attitude : matrice des cosinus directeurs, angles d’Euler,
quaternions, etc. Au cours de cette séance, vous allez réaliser une centrale d’attitude en mettant
en œuvre un observateur déterministe. On rappelle qu’un observateur est un système dynamique
qui permet d’estimer les états que l’on ne mesure pas. Dans le cas d’un système linéaire décrit
par l’équation d’état dont on cherche à estimer les états x :
ẋ = Ax + Bu (2.1)
y = Cx (2.2)
Ce système échantillonné à la période T a pour modèle :

xk+1 = Fx + Guk (2.3)
yk = Cxk (2.4)
Un observateur est un système dynamique d’équation :
x̂k+1 = Fx̂k + Guk + L(y − ŷ) (2.5)

| {z } | {z }
prédiction recalage
ŷk = Cx̂k (2.6)
L’estimation est correcte si les erreurs d’estimation lim ε = lim x − x̂ → 0. Cette condi-
t→+∞ t→+∞
tion est réalisée si et seulement si la matrice F − LC a toutes ses valeurs propres dans le cercle
unité. Les erreurs d’estimation convergent d’autant plus vite vers zéro que les modules de ces
valeurs propres sont petites.
51
TP 2. ESTIMATION D’ATTITUDE
— Centrale d’attitude MTI de XSENS + câble de connection au PC + connecteur ODU-DB9

— Carte BigDsPic6
— PC + MATLAB R2010b -SIMULINK, MT Manager
— Boitier d’alimentation
— Câble USB
2.2 La centrale d’attitude MTI
Dans ce TP, le système étudié est une centrale d’attitude MTI de la marque XSENS http:
//www.xsens.com/. Cette centrale comporte :
— trois accéléromètres qui mesurent les trois composantes de l’accélération projetées dans
le repère du capteur notées accx = γx , accy = γy , accz = γz ,
— trois gyromètres qui mesurent les trois composantes de la vitesse angulaire absolue pro-
jetées dans le repère du capteur notées gyrx = p, gyry = q, gyrz = r,
— trois magnétomètres qui mesurent les trois composantes du champ magnétique terrestre
projetées dans le repère du capteur notées magx = Bx , magy = By , magz = Bz .
Cette centrale traite ces mesures et renvoie les angles d’attitude ϕ, θ et ψ.
Le repère capteur est défini comme suit (cf. figure 2.1) :
Figure 2.1 – Le repère capteur
Connectez la MTI au port USB du PC au moyen du câble USB-RS232 converter.
52 F. BATEMAN
2.2. La centrale d’attitude MTI
Figure 2.2 – Le câble USB-RS232
Depuis le bureau, ouvrir le logiciel MT Manager, la fenêtre suivante apparaı̂t :
Figure 2.3 – Le logiciel MT Manager
Il faut ensuite cliquez sur Ok puis sur Annuler.
F. BATEMAN 53
Figure 2.4 –
Le capteur est déjà programmé, les données sont transmises via le port USB au format RS232
(100 mesures /seconde, 115200 bauds, 8 bits), il s’agit de accx , accy , accz , gyrx , gyry , gyrz , magx ,
magy , magz , φ, θ, ψ. Ces données sont de type single, soit des réels à virgule flottante codés sur
32 bits (4 octets forment un single).
— Pour visualiser les angles d’attitude roll φ, pitch θ, yaw ψ, cliquez sur le bouton Orienta-
tion Data View.
— Pour visualiser les mesures accx , accy , accz , gyrx , gyry , gyrz , magx , magy , magz , cliquez
sur le bouton Calibrated Data View.
— Réalisez un enregistrement des données en cliquant sur le bouton Record/Stop Record.

Opérez à des petits mouvements du capteur autour des axes de roulis et de tangage.
— Cliquez sur File❀Open MT-XXXX (type MT manager log file) ❀Export ; le fichier est
exporté au format *.txt et peut être lu sous MATLAB,
— Depuis MATLAB R2010b, cliquez sur File❀Import Data, ouvrir le fichier texte MT-
XXXX, poursuivre la procédure de transfert des données (Next, Finish). Les données
sont accessibles depuis la variable data qui a la structure suivante :
data counter accx accy accz gyrx gyry gyrz magx magy magz φ θ ψ
1 xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx
... ... ... ... ... ... ... ... ... ... ... ... ... ...
N xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx
Figure 2.5 – La structure de la variable data
N
Comme les mesures sont effectuées à 100Hz, la durée de l’essai est égale à 100 s et N peut
54 F. BATEMAN
2.3. L’estimation d’attitude
être connu avec la fonction size(data) qui renvoie la dimension du tableau correspondant, soit
N lignes, 13 colonnes. Pour afficher les données, il faut recréer un vecteur temps :
1 −1 1
— time = [0 : 100 : N100 ]’ génère un vecteur de longueur N par pas de 100 , transposez ce
vecteur ❀ transpose(time) ou ❀ time´.
— Pour accéder aux mesures de l’angle de gı̂te, tapez data( :,11) affiche toutes les lignes de
la 11ème colonne,
— Pour accéder aux mesures des angles de gı̂te, d’assiette et de cap, tapez data( :,11 :13)
affiche toutes les lignes de la 11ème à la 13èmecolonne.
Réalisez un second enregistrement des données alors que le capteur est immobile. Sauvegardez
les données de cet essai dans un second fichier portant un nom différent de celui obtenu lors de
l’essai précédent.
Ces données serviront ultérieurement à alimenter le modèle de simulation de la centrale

d’attitude que vous allez réaliser. Avant de débrancher la MTI, cliquez sur le bouton Disconnect.
2.3 L’estimation d’attitude

Ce modèle repose pour partie sur l’utilisation des relations cinématiques :
φ̇ = p + tanθ(q sin φ + r cos φ) (2.7)

θ̇ = q cos φ − r sin φ
sin φ cos φ
ψ̇ = q +r
cos θ cos θ
2.3.1 Le modèle de prédiction

Les équations (2.7) sont non linéaires et ne satisfont pas aux hypothèses faites sur les obser-
vateurs.
— Etablissez le modèle linéarisé des équations (2.7) pour de petites variations φ, θ, ψ, p, q,

r autour du point de fonctionnement noté e et défini par φe = θe = pe = qe = re = 0
— On ne s’intéresse qu’aux mouvements autour des axes de roulis et de tangage. En posant
T T
x= φ θ et u = p q qui sont en fait les vitesses angulaires mesurées par la MTI,
établissez les équations d’état et d’observation et par suite les expressions des matrices
F et G.
— Implémentez les équations cinématiques linéarisées sous SIMULINK. Comme ce modèle
est destiné à être implémenté en temps réel, vous en réaliserez une version à temps discret.
Pour réaliser le retard, vous utiliserez un bloc Unit Delay. Le Fixed step size est choisi
1
égal à la période des mesures, soit 100 s.
— Vous réaliserez les signaux d’entrée de ce modèle au moyen des blocs Sources❀Simin qui
permettent d’utiliser sous SIMULINK des données du Workspace de MATLAB. A ce
propos, il est nécessaire dans le bloc Simin d’utiliser le vecteur time créé précédemment.
F. BATEMAN 55
— Sur un même oscilloscope, visualisez les angles φ et θ mesurés sous MT Manager et ceux
estimés.
— Que constate-t-on ?
— Réitérez cette simulation en utilisant les mesures obtenues lors de l’essai statique et
proposez un modèle pour les erreurs de mesure commises par les gyromètres et notées εx ,
εy .
— Estimez ces erreurs pour cet essai.
— déduisez-en un modèle des mesures gyrx et gyry que vous exprimerez en fonction de p,
q, εx , εy .
— En admettant ces erreurs constantes, reformulez les équations d’état.
— Proposez un nouveau modèle de prédiction pour cet observateur et testez-le. Pensez à
l’initialiser judicieusement.
2.3.2 Recalage des estimations par les mesures accélérométriques

Les mesures des accélérations projetées sur les axes de roulis − →x b et de tangage −
→y b sont
utilisées pour recaler les estimations des angles de gı̂te et d’assiette.
L’accéléromètre est en mouvement dans un champ de gravitation − →
g et est soumis à une
→
−
somme d’accélérations (dont la gravitation) Γ . Or un accéléromètre ne mesure que l’accélération
→ −
− → →
non gravitationnelle (appelée également force spécifique) f = Γ − − g Par conséquent, la MTI,
→
−
immobile sur un plan horizontal, l’axe de mesure z b dirigée vers le haut comme l’illustre la
→
−
figure 2.1 renverra, aux bruits de mesure près f = 0 − − →
g soit accz = 9.81ms−2 . En chute libre,
→ −
−
dans le champ de pesanteur, elle renverrait f = → g −− →
g = 0ms−2 .
Deux repères sont utilisés dans ce problème :
1. Le repère capteur R = (O, −
b
→
x ,−
b
→y ,−
b
→
z ), dont l’origine {O} est le point d’intersection
b
des trois axes qui portent les capteurs.
2. Le repère terrestre RE (O, −x→ −
→ − →
E , yE , zE ) est un repère orthonormé direct supposé galiléen.
L’axe (O −
x→) est dirigé vers le nord géographique et l’axe (O −
E y→) vers l’ouest. L’axe (O −
E z→)
E
complète le trièdre. L’origine de ce repère coı̈ncide avec celle du repère capteur. Le repère
capteur est en rotation autour du repère terrestre.
La matrice de passage du repère terrestre RE au repère terrestre supposé inertiel Rb notée
TEb s’écrit :
 
cos θ cos ψ cos θ sin ψ − sin θ
 
TEb =  sin φ sin θ cos ψ − cos φ sin ψ sin φ sin θ sin ψ + cos φ cos ψ sin φ cos θ 
cos φ sin θ cos ψ + sin φ sin ψ cos φ sin θ sin ψ − sinϕ cos ψ cos φ cos θ
Cette matrice est orthogonale et son inverse TEb = T−1 T

bE = TbE .
— Donnez l’expression de l’accélération de pesanteur dans le repère RE (O, −
x→ −
→ − →
E , yE , zE ).
— En utilisant la matrice de passage, établissez les expressions des composantes de l’accé-
lération mesurées sur accx et accy dans le repère capteur.
— En supposant l’angle de cap ψ étant égal à 0, linéarisez les équations précédemment
établies pour de petites variations des angles φ et θ autour de 0.
56 F. BATEMAN
2.4. Implémentation temps réel de la centrale d’attitude
T
— Écrivez l’équation de sortie (2.4) pour le vecteur des mesures y = accx accy tandis
T
que le vecteur d’état a pour expression x = φ θ .
— Déduisez-en l’expression de la matrice de sortie C et saisissez-là sous MATLAB.
— Calculez le gain L de l’observateur de sorte que les erreurs d’estimation convergent vers
zéro en un temps inférieur ou égal à 200 ms. En outre, ces erreurs doivent présenter des
régimes transitoires du second ordre avec des dépassements inférieurs ou égaux à 5%. Pour
traiter cette question, il est conseillé de chercher les pôles du système à temps continu
équivalent et d’en établir la représentation à temps discret z = epTs . Pour calculer L,
Vous pourrez avantageusement utiliser la fonction place de MATLAB pour laquelle vous
consulterez l’aide en ligne. Attention à transposer les matrices !
— Sous SIMULINK, complétez le modèle de prédiction pour réaliser l’observateur complet.
— Simulez la centrale d’attitude et observez les angles de gı̂te φ̂ et d’assiette estimés θ̂.
— Calculez le gain L de l’observateur de sorte que les pôles de l’observateur spe(A − LC) =
{−1 − 1i, −1 + 1i} et simulez à nouveau la centrale d’attitude.
— Pour estimer la qualité de l’estimation, vous pouvez calculer le carré de l’intégrale des
erreurs commises entre les angles de gı̂te et d’assiette calculés par la MTI avec ceux
fournis par votre estimateur.
— Affiner le choix des pôles pour réduire au maximum ces indicateurs.
— Donnez une explication au phénomène observé.
— On peut enfin, pour les grands angles, améliorer l’estimation en utilisant une expression
exacte des angles de gı̂te et d’assiette obtenus avec les mesures accélérométriques en lieu
et place de l’approximation faite.
2.4 Implémentation temps réel de la centrale d’attitude
2.4.1 Cablâge de la MTI
La centrale d’attitude est connectée à la carte BigDsPic6 via un connecteur ODU, attention
à bien réaliser la connection, les points rouges sur les connecteurs mâles et femelles doivent
coı̈ncider. Il ne faut surtout pas forcer la connection et ne pas hésiter à demander
conseil si vous avez des doutes sur le branchement.
— fil rouge relié à une broche +VCC,

— fil noir relié à une broche GND,
— fil de données vert, relié à la broche 3 du connecteur CN13.
— Le switch RF4 de SW14 doit être sur la position ON, tous les autres switchs sont en
position OFF. Pour comprendre ces choix, il faut se reporter à la page 15 du User manual
de la carte BigdsPIC6.
— Les signaux seront visualisés sur l’interface rs232gui au moyen d’un bloc Serial Port❀
Tx Labview Matlab sur le Tx de l’UART 1, soit la pin RF3.
F. BATEMAN 57
2.4.2 Programme de lecture de la MTI

Le fichier Lecture MTI.mdl permet, après compilation, de lire les données issues de la centrale
MTI sur le microncontrôleur.
— Vérifiez le bon fonctionnement de ce schéma en observant l’angle de gı̂te sous rs232gui.

Vous noterez que le bloc UINT16 est précédé d’un amplificateur de gain 100. En effet,
comme l’angle mesuré peut varier entre − π2 (-1,57) et π2 (1,57), le codage sous forme
d’un nombre entier est problématique, aussi les données sont elles multipliées par un gain
important pour pouvoir être lues sur l’interface rs232gui. A ce propos, il faut cliquer sur
le bouton int16 de cet interface pour visualiser les nombres négatifs.
2.4.3 Implémentation de l’algorithme d’estimation d’attitude

Dans cette dernière partie vous avez à implémenter la centrale sur le microcontrôleur et à la
tester.
— Implémentez le schéma de l’observateur à temps discret sous SIMULINK.
— Ajoutez des blocs Tx Labview Matlab afin d’observer les angles de gı̂te et d’assiette
estimés par l’observateur.
— Compilez ce modèle et simuler la centrale d’attitude pour de petits mouvements de la
centrale MTI autour des axes de roulis et de tangage.
— Comparez ces réponses en gı̂te et en assiette à celles délivrées par la centrale MTI.
— Augmentez l’amplitude des mouvements, qu’observe-t-on ? Expliquer.
— Ouvrir dans le schéma le terme de recalage L(y − ŷ) de sorte que l’attitude soit recons-
truite seulement à partir des mesures gyrométriques. Qu’observe-t-on ?
2.4.4 Implémentation de l’algorithme d’estimation d’attitude

En utilisant les mesures délivrées par les magnétomètres et le gyromètre de lacet gyrz ,
réalisez un observateur qui estime l’angle de cap de la centrale MTI. Pour les développements
théoriques, vous pouvez vous appuyer sur le document Supervision des drones et sur le bureau
d’études Étude d’une centrale de cap.
58 F. BATEMAN
TP 3
ESTIMATION DE HAUTEUR PAR FILTRAGE DE KALMAN
3.1 Objectif
Au cours de cette séance vous réaliserez un capteur de hauteur et de vitesse ascensionnelle

pour un drone en hybridant les mesures issues d’un accéléromètres et celles d’un capteur à
ultrason. En particulier, on ne dispose pas de capteur de vitesse ascensionnelle, aussi cette
variable doit être estimée. En outre, la mesure de position réalisée par le capteur à ultrason n’est
pas rafraı̂chie suffisamment rapidement pour permettre le contrôle de l’altitude. Enfin, comme
toutes ces mesures sont bruitées, ces estimations sont dévolues à un filtre de Kalman. Dans ce
TP Vous aurez à :
1. établir les équations du modèle du système et du filtre de Kalman,
2. caractériser les bruits de mesure de l’accéléromètre et du capteur à ultrason qui joueront

respectivement les rôles de bruit d’état et de bruit de mesure du filtre,
3. simuler le filtre en vue d’estimer la hauteur et la vitesse ascensionnelle,
4. implémenter ce filtre sur le microcontrôleur et à évaluer la qualité des estimations.
— 1 module contenant un accéléromètre et un télémètre à ultrason,

— 1 Module et 1 clé Bluetooth,
— 1 boitier de programmation ICD3 + 2 câbles USB + câble de programmation,
— 1 batterie LiPo 7.2 V, 800 mAH,
— PC + MATLAB-SIMULINK R2010b, MPLAB,
59
TP 3. ESTIMATION DE HAUTEUR PAR FILTRAGE DE KALMAN
3.2 Modélisation des signaux et du système

3.2.1 Modèle
— Dans le cas d’un mouvement de translation, la vitesse ascensionnelle v et la hauteur
h sont obtenues successivement en intégrant l’accélération γ puis v. En pratique, on
dispose de la mesure bruitée de l’accélération, soit γm = γ + wγ cette mesure. En vous
inspirant du cours (Chapitre 7 - Observateurs déterministes), établissez dans le cas discret
l’équations d’état de h et de v tandis que l’accélération mesurée γm joue le rôle d’entrée
de ce système. Ici wγ est le bruit d’état généré lors de la mesure de l’accélération. Cette
dernière est mesurée selon l’axe sensible toutes les 10ms. On rappelle que l’équation d’état
d’un système soumis à un bruit d’état s’écrit :
Xk+1 = FXk + GUk + HWk (3.1)
Wk est supposé gaussien centré, de matrice de covariance Qw ∈ Rn×n , où n est la

dimension du vecteur d’état et blanc.
— Établissez l’équation d’observation de ce système sachant que la hauteur mesurée par le
capteur à ultrason joue le rôle de sortie de ce système. Soit hm = h + vh l’équation de la
mesure opérée toutes les 20ms. Ici vh est le bruit de mesure de la hauteur. Vous mettrez
l’équation d’observation sous la forme :
Yk = CXk + DUk + Vk (3.2)
À propos du bruit d’état
3.2.2 Équations du filtre de Kalman

Rappelez les cinq équations du filtre de Kalman. Vous pouvez reprendre les notations utilisées
dans le cours.
— Estimation a priori ou prédiction, toutes les 10ms :
1. Déduisez de ce qui précède l’équation de l’estimation a priori de l’état X̂k+1|k
2. Donnez l’équation de la covariance de l’erreur d’estimation a priori Pk+1|k
— Estimation a posteriori ou recalage, toutes les 20ms :
1. Équation de la covariance de l’erreur d’estimation a posteriori Pk+1|k+1
2. Équation du gain de Kalman Lk+1
3. Équation d’estimation a posteriori de l’état X̂k+1|k+1
— Pour chacun des vecteurs et des matrices, précisez sa dimension.
3.3 Présentation de la maquette

— Le boitier contient un microcontrôleur 33fj256mc710, un capteur à ultrason qui délivre
une information de position toutes les 20ms et un accéléromètre qui renvoie l’accélération
mesurée selon l’axe sensible toutes les 10ms.
— Une batterie LiPo pour alimenter le boitier.
60 F. BATEMAN
3.3. Présentation de la maquette
Figure 3.1 – Le boitier ICD3
— Un programmateur ICD3 pour flasher le microcontrôleur avec le programme édité sous

SIMULINK est compilé depuis MATLAB R2010b 1 . Le programme compilé *.hex est im-
plémenté sur le microcontrôleur au moyen du logiciel MPLAB IPE.
— Les mesures peuvent être recueillies sur MATLAB via un une liaison Bluetooth au moyen
de la fonction rs232gui.
3.3.1 Collecte de mesures

Vous réaliserez une première fois les essais qui suivent en régime statique (capteurs immobiles)
de manière à calibrer les capteurs et à modéliser les bruits de mesure. Dans un second temps,
vous procéderez à un essai en régime dynamique. Pensez lors de chacun des essais à sauvegarder
les variables dans un fichier *.mat de manière à garder une trace des essais.
1. Ouvrez le fichier CollectData.mdl, analysez sa structure (séquence 3.5 et 3.6) et le com-

piler.
2. Reliez le PC au boitier ICD3 via le câble USB puis le boitier ICD3 à la maquette via le
câble ICD3 comme illustré sur la figure 3.3.
3. Depuis le bureau, ouvrir le programme MPLAB IPE
— Sélectionnez le microcontrôleur dsPIC33FJ256MC710,
— ❀ Apply ❀ Connect
— Browse ❀ Import importez le fichier CollectData.hex
— Cliquez sur l’icôle Program afin d’implémenter ce fichier sur le microcontrôleur.
4. Ouvrez MATLAB et exécuter rs232gui, identifiez le port série utilisé et cliquez sur le
bouton plot int16 pour observer des nombres signés puis visualisez les signaux issus de
l’accéléromètre et du télémètre à ultrason.
1. En fait MATLAB appelle un compilateur dédié à ce microcontrôleur C30 de Microchip.
F. BATEMAN 61
3.3.2 Caractérisation des bruits et étalonnage des capteurs

Les mesures d’accélération et de hauteur sont stockées dans les variable R et Rn, les instants
auxquels sont associées ces mesures sont définis dans le tableau t R et t Rn. Comme les mesures
d’accélération sont prélevées à une fréquence double de celles de hauteur, le tableau R a la
structure suivante Tab.3.2) :
NaN y
x NaN
x NaN
Nan y
x NaN
x NaN
NaN y
... ...
Figure 3.2 – Structure de R
Où NaN est l’acronyme de Not a Number. Il faut donc dans un premier temps reconstruire
un tableau dans lequel les NaN n’apparaissent pas.
— Écrivez un script sous MATLAB qui permette de stocker dans deux vecteurs, gamma et
height les données numériques contenues dans Rn. Vous pouvez utiliser avec profit les
fonctions suivantes :
— Rn( :,1), Rn( :,2) permettent respectivement d’accéder à la première et à la seconde
colonne de Rn.
— isnan
— ˜ l’opérateur logique NON
— find
— Représentez l’histogramme des valeurs contenues dans gamma et height ❀ hist.
— Calculez la moyenne et l’écart-type des bruits de mesure accéléromètre et capteur à
ultrason ❀ mean, std
— Proposez des procédures pour l’étalonnage des capteurs afin d’obtenir des mesures cali-
brées en m.s−2 et en m. Vous vous reporterez au §2.3.2 pour prendre connaissance de ce
que mesure effectivement un accéléromètre.
— Pour l’étalonnage du télémètre, opérez plusieurs mesures et exprimez la hauteur en
mètre par une relation affine en fonction du nombre entier délivré par le capteur.
— Pour l’étalonnage de l’accéléromètre, commencez par vérifier la planéité du support
avec le niveau à bulle puis alignez successivement l’axe sensible du capteur dans
une direction parallèle à la verticale locale et faites la lecture du nombre délivré par
le capteur. Réitérez cette opération en orientant l’axe sensible dans une direction
perpendiculaire à la verticale locale. Vous exprimerez l’accélération en m.s−2 par une
relation affine en fonction du nombre entier délivré par le capteur.
— Proposez un modèle (au sens des probabilités) pour les bruits de mesure de l’accéléromètre
et du capteur à ultrason exprimés dans des unités adh’oc .
62 F. BATEMAN
3.4. Implémentation du filtre de Kalman
3.3.3 Simulation du filtre de Kalman
Avant d’implémenter l’algorithme du filtre de Kalman sur le microcontrôleur, on le simule

sur SIMULINK. Pour cela, on a besoin des mesures délivrées par l’accéléromètre et le capteur à
ultrason en régime dynamique. Ces mesures sont contenues dans les vecteurs gamma et height
respectivement de taille 2N et N (N dépend évidemment de la durée de votre expérience, vous
pouvez y accéder avec la fonction size). C’est à partir de ces mesures que vous allez estimer la
hauteur h et la vitesse ascensionnelle v. Vous avez donc à créer pour chacune des variables un
vecteur qui contient les instants associés à chaque mesure. Vous pouvez procéder comme suit :
— Faites l’acquisition d’un échantillon de mesures d’accélération et de hauteur tandis que

ces capteurs sont en mouvement. Ces mouvements ne doivent pas comporter d’à-coups.
— t gamma = [0 :0.01 : 0.01*(2N-1) ]’ génère un vecteur de longueur 2N par pas de 0.01.
— de la même manière, créer un vecteur temps t height pour les mesures du capteur à
ultrason.
— Ouvrez un nouveau Model et paramétrez-le de sorte que le Fixed-step size soit égal à
10ms avec un discrete Solver.
— Insérez deux blocs Sources❀Simin et les paramétrer avec les vecteurs gamma, t gamma,
height et t height. Vérifiez au moyen de Scopes la bonne restitution de ces mesures.
— Copiez-collez un bloc User Defined Functions❀ Embedded Matlab Function, (déjà utilisé
au §3.7.2). Vous noterez en particulier l’utilisation du type persistent qui permet de
sauvegarder en mémoire les variables calculées entre deux appels de la fonction. Cela sera
particulièrement utile pour propager l’état estimé et la covariance de l’erreur d’estimation.
— En vous inspirant du programme proposé au §3.7.2, implémentez les équations du filtre
de Kalman en prenant soin de traiter l’accélération mesurée toutes les 10ms et la mesure
du capteur à ultrasons toues les 20ms. Pratiquement le bloc Embedded Matlab Function
est appelé toutes les 10 ms et il faut mettre en œuvre un test qui ne prenne en compte la
mesure des ultrasons qu’une fois sur deux.
— Simulez et restituez les résultats pour des essais préalablement conduits avec le capteur
immobile puis en mouvement. Vous évaluerez notamment les effets de la méconnaissance
des conditions initiales sur le comportement du filtre.
— Visualisez les gains de Kalman et les coefficients p11 et p22 de la matrice de covariance
de l’erreur d’estimation et décrivez le comportement du filtre d’après leur évolution.
3.4 Implémentation du filtre de Kalman

— Copiez-collez l’Embedded Matlab Function simulée précédemment dans le fichier Col-
lectData.mdl. Comme les données pour être visualisées, doivent être mises au format
uint16 (données∈ [0, 1, 2, . . . , 216 − 1]), il n’est pas possible de restituer les mesures de
hauteur avec précision (l’affichage de 0.25m renverrait 0). Il vous faut donc amplifier,
d’un facteur 100 ou 1000 les sorties calculées par l’Embedded Matlab Function pour les
lire directement en cm ou en mm.
— Insérez les blocks TX Labview Matlab de manière à visualiser la hauteur estimée et la
F. BATEMAN 63
hauteur mesurée, la vitesse ascensionnelle estimée. Compiler et implémenter le fichier

*.hex sur la cible.
— Visualisez et relevez la hauteur et la position estimée par le filtre. Comparez la hauteur
estimée à celle mesurée.
— Visualisez la vitesse estimée, les gains de kalman, les variances des erreurs d’estimation
et tous les signaux que vous jugez intéressants.
— Faits l’analyse des variances des erreurs et évaluez la qualité des estimations.
3.4.1 Filtrage complémentaire
Dans cette dernière partie, on met en œuvre un filtre de Kalman stationnaire c.-à-d un filtre
dont les gains dépendent des seuls bruits d’état et de mesure et pas des conditions initiales.
L’intérêt de cette structure réside dans sa simplicité d’implémentation. Pratiquement, lorsque
k → +∞, on peut démontrer et on a observé que la matrice de covariance de l’erreur d’estimation
Pk|k → P = cte et par suite le gain de Kalman Lk → L = cte. Dans ces conditions, le filtre a la
même structure qu’un observateur déterministe tel qu’illustré sur la figure 3.3.
Uk Yk
Système
+
L
X̂k+1 -
+
G retard C
+ + T
Ŷk
F
X̂k
Figure 3.3 – Structure de l’observateur à temps discret
— Relevez sur les simulations précédentes la valeur du gain de Kalman L en régime perma-
nent.
— Réalisez le schéma du filtre de Kalman stationnaire sous SIMULINK dans le modèle de
simulation et testez-le.
— Copiez le schéma du filtre de Kalman stationnaire dans une copie de Collect Data.mdl,
insérez les blocs Tx Labview, compilez-le et visualisez la hauteur et la vitesse estimées
par le filtre.
On montre dans cette dernière partie que cet observateur peut être décrit par un filtre dont
64 F. BATEMAN
3.4. Implémentation du filtre de Kalman
la fonction de transfert s’exprime comme suit :
X̂k+1 = FX̂k + GUk + L(hk − Ŷk ) (3.3)

X̂k+1 = FX̂k + GUk + L(hk − CX̂k ) (3.4)
!
γk
X̂k+1 = (F − LC)X̂k + (G, L) (3.5)
hk
On a par ailleurs l’équation de l’estimation de la mesure :
Ŷk = CX̂k (3.6)
En appliquant pour la transformée en Z de Xk le théorème de l’avance, il vient :
!
γ(z)
z X̂(z) = (F − LC)X̂(z) + (G, L) (3.7)
h(z)
!
γ(z)
(zI − (F − LC)) X̂(z) = (G, L) (3.8)
h(z)
X̂(z) = (zI − F + LC)−1 G γ(z) + (zI − F + LC)−1 L h(z)
| {z } | {z }
dim 2×1 dim 2×1
Que l’on met sous la forme :
! ! !
ĥ(z) P11 (z) P12 (z)
= γ(z) + h(z) (3.9)
v̂(z) P21 (z) P22 (z)
Le calcul du gain de Kalman et des fonctions de transfert P11 (z), P21 (z), P12 (z) et P22 (z)
peuvent être conduits en suivant la démarche suivante :
— Relevez sur les simulations précédentes la valeur du gain de Kalman L en régime perma-
nent.
— Ouvrez un script et saisissez les matrices F, G, C, L.
— Saisissez avec la fonction ss à temps discret (Ts=10ms) de la représentation d’état sui-
vante : !
γk
X̂k+1 = (F − LC)X̂k + (G, L) (3.10)
hk
ζ̂k = I2 X̂k (3.11)
où ζ sont les sorties du filtre qui ne sont autres que les variables d’état, position et vitesse,
estimées.
— Calculez les fonctions de transfert correspondant à ce système avec la fonction tf. Vous
pouvez tracer leur diagramme de Bode
— La fonction tfdata permet d’accéder aux numérateurs et au dénominateurs des fonctions
de transferts. Au moyen de blocs Discrete Transfer Fcn, réalisez le schéma de ce filtre de
Kalman sous SIMULINK dans le modèle de simulation et testez-le.
F. BATEMAN 65
— Copiez le schéma du filtre complémentaire dans une copie de Collect Data.mdl, insérez
les blocs Tx Labview, compilez-le et visualisez la hauteur et la vitesse estimées par le
filtre.
66 F. BATEMAN
TP 4
CONTRÔLE DE L’ASSIETTE D’UN DRONE À VOILURE TOURNANTE
4.1 Objectifs
Mettre en œuvre différentes lois de commande dans le but de contrôler l’assiette d’un hexa-
coptère.
— Hexacoptère Mikrokopter,
— support à 4 d.d.l,
— boitier de programmation ICD3, câble de programmation, câble USB,
— câble FTDI pour le transfert des données entre l’hexacoptère et le PC,
— radiocommande SPEKTRUM 6 voies, 2.4GHz,
— PC + MATLAB-SIMULINK, MPLAB
— Lunettes, blouse et gants de protection à porter impérativement lors des essais.
4.1.2 Présentation du matériel
L’hexacoptère à contrôler est représenté sur la figure 4.2. Le bras rouge matérialise l’axe de
roulis et porte l’hélice 1. L’axe de tangage est dirigé vers la droite de l’axe de roulis et l’axe de
lacet complète le trièdre. Les hélices sont comptées de 1 à 6 dans le sens horaire.
La radiocommande représentée sur cette même figure permet avec le joystick droit de contrô-
ler les gaz (déplacement vertical), l’angle de gı̂te (déplacement horizontal), le joystick gauche
contrôle l’assiette (déplacement vertical) et la vitesse de lacet (déplacement horizontal). Deux
switchs Gear et Flap servent à commuter entre les différents modes de fonctionnement du drone.
67
TP 4. CONTRÔLE DE L’ASSIETTE D’UN DRONE À VOILURE TOURNANTE
Figure 4.1 – L’hexacoptère et la radiocommande
4.2 Modélisation
Le contrôle des angles de gı̂te et de cap est déjà réalisé. La poussée est contrôlée en boucle
ouverte via la commande des gaz, vous avez seulement à contrôler l’assiette. Pour cela vous
disposez :
— de la consigne d’assiette élaborée à partir de la radiocommande θref (pitch angle ref ),
— des mesures d’assiette θ (pitch angle) et de vitesse de tangage q (pitch). Ces mesures sont
opérées toutes les 10 ms.
Données sur le drone :

Coefficient de portance de l’hélice b 6.4.10−4 N/(tr/s)2
Longueur du bras de levier ℓ 27.5cm
masse du drone + pied coulissant (Drone seul 1.102 kg) m 1.36kg
Moment d’inertie autour de l’axe de tangage Iy 0.022kg.m2
On désigne par N1 et N4 les vitesses de rotation des hélices 1 et 4 en tr/s. Comme les
moteurs sont asservis, ces vitesses sont égales à leurs consignes N1ref et N4ref . M est le moment
de tangage. Pour cette étude simplifiée, le modèle du drone est :
Iy q̇ = M (4.1)
M = bℓ(N12 − N42 )
θ̇ = q
Ni = Niref avec i = {1, 4}
4.2.1 Equilibre
— En vol stationnaire, que valent l’assiette θ et la vitesse de tangage q ?
— Que valent les vitesses de rotation des hélices à l’équilibre N1e , N4e
68 F. BATEMAN
4.3. Lois de commande
4.2.2 Modèle du drone linéarisé
— Autour de l’équilibre et pour de petites variations de vitesse des hélices n1 , n4 autour de

Ne = N1e = N4e , linéarisez les équations 4.1.
— Établissez l’équation d’état, vous prendrez comme entrées de commande le moment de
tangage linéarisé autour de l’équilibre noté m.
q(s) θ(s)
— Établissez les fonctions de transfert et
m(s) m(s)
— Représentez le schéma fonctionnel de la commande d’axe de tangage de l’hexacoptère
dont l’entrée de commande est m(s) et la sortie θ(s).
— Autour de l’axe de tangage, l’hexacoptère en boucle ouverte est-il asymptotiquement
stable ?
En pratique, le moment de tangage est produit par le différentiel de vitesse des hélices n1 et
n4 . On suppose également que les vitesses de rotation des hélices n1 et n4 sont asservies à leurs
consignes n1ref et n4 ref .
— Modifiez le schéma précédent de sorte que les entrées de commande soient n1ref et n4ref .
Le schéma ainsi représenté est celui du drone dont les entrées de commande sont les vitesses de
consignes des moteurs n1ref et n4ref et la sortie à contrôler l’assiette θ. Encadrez ce schéma et
nommez-le drone. Cela permettra de bien distinguer l’objet à commander de la loi de commande
implémentée sur l’autopilot et qui est étudiée dans la section suivante.
4.3 Lois de commande
Dans cette partie on construit le schéma de la commande et on synthétise différents types

de correcteurs.
Les lois de commande (correcteurs PD, PID, commandes par retour d’état simple et aug-
menté) génèrent un moment de tangage calculé mcalcul à partir duquel on calcule les vitesses de
rotation de consignes de hélices, soit n1ref et n4ref avec la contrainte n4ref = −n1 ref .
— Exprimez n1ref et n4ref en fonction du moment de tangage calculé mcalcul lequel sera
obtenu par les lois de commande qui seront étudiées infra.
— Complétez le schéma fonctionnel du drone linéarisé en y ajoutant le schéma correspondant
à cette partie de la loi de commande. Mettez en évidence les parties du schéma qui
décrivent le drone (objet physique) de celles qui représentent la commande (implémentée
sur l’autopilot).
Dans ce qui suit, on synthétise les correcteurs qui génèrent mcalcul à partir des mesures de
l’assiette θ et de la vitesse de tangage q mesurées par la centrale d’attitude.
4.3.1 Correction Proportionnelle-Dérivée
On met en œuvre une première loi de commande de type Proportionnelle-Dérivée :
F. BATEMAN 69
 
 
mcalcul = kd kp (θref − θ) −q  (4.2)
| {z }
qref
— Complétez le schéma fonctionnel de l’hexacoptère en lui adjoignant celui de la loi de

commande (4.2).
— Calculez kp et kd de sorte que ce système
√ se comporte comme un ordre deux dont le
2
facteur d’amortissement est égal à et le temps de réponse égal à 0.3s. Justifiez le
2
choix de ces paramètres.
— Affinez les paramètres des correcteurs sous MATLAB sisotool et testez-les sur le modèle
de simulation Template Simu Hexa.slx.
4.3.2 Commande par retour d’état

Le système est décrit par l’équation d’état linéarisée établie au §4.2.2. Les variables θ et q
sont toutes deux mesurées.
— Donnez les expressions des matrices d’état A, de commande B, de sortie C et de transfert
direct D.
La commande réalisée est de la forme
mcalcul (t) = hθref (t) − k1 θ(t) − k2 q(t) (4.3)
— Calculez avec les gains k1 et k2 pour que les pôles du système corrigé soient égaux à
−10± 10i. Quelles performances dynamiques et statiques sont attendues pour ce réglage ?
— Calculez h de sorte qu’en régime permanent et en réponse à un échelon de consigne
d’amplitude θ(∞) = θref .
4.3.3 Commande Proportionnelle-Intégrale-Dérivée

On met en œuvre une loi de commande de type Proportionnelle-Intégrale-Dérivée :
 
 Z t 
 
mcalcul = kd kp (θref − θ) + ki (θref − θ)dτ −q  (4.4)
{z 0
 
| }
qref
— Complétez le schéma fonctionnel de l’hexacoptère en lui adjoignant celui de la loi de

commande (4.4).
— Pour la boucle interne, calculez kd de sorte que la boucle interne de ce système se comporte
comme un ordre un dont le temps de réponse est égal à 150ms (il ne peut être plus rapide
que celui des moteurs étudiés lors du TP ??.)
70 F. BATEMAN
4.4. Expérimentations
— Quel type de correcteur réalise la loi de commande de la boucle externe ? Montrez qu’il
Ti s + 1
peut se mettre sous la forme kp
Ti s
— En vous inspirant de la méthode dite de l’optimum symétrique http://eavr.u-strasbg.
fr/~laroche/student/MasterIT-ComMach/ComMach1/node58.html, calculez kp et ki .
Vous adopterez pour ce réglage a = 4.
4.3.4 Commande par retour d’état augmenté

La commande a pour expression :
Z t
mcalcul (t) = h (θref (τ ) − θ(τ ))dτ − k1 θ(t) − k2 q(t) (4.5)
0
L’ajout d’un effet intégral vise à rendre le système davantage robuste aux perturbations. On
va opérer à une stratégie de placement de pôle sur le système augmenté, pour cela, on définit
Rt
une nouvelle variable d’état z = 0 (θref (τ ) − θ(τ ))dτ et par conséquent ż = θref − θ.
— Écrire l’équation d’état associée au système dont le vecteur d’état est désormais X =
T
θ q z et l’entrée θref .
— Montrez que la matrice d’état augmentée corrigée se met sous la forme :
   
0 1 0 0
  1
Aaug − Baug Kaug =  0 0 0 −  Iy  k1 k2 −h
−1 0 0 0
— Calculez avec la fonction place de MATLAB les gains k1 , k2 et h pour que les pôles du
système corrigé soient égaux à −5, −5 ± 5i. Attention à modifier le signe de h calculé par
MATLAB.
4.4 Expérimentations
Lors de toutes les phases d’expérimentation vous devrez impérativement porter lunettes de
protection et blouse.
Avant chaque test, assurez-vous que les hélices et les moteurs sont bien fixés, resserrez les
vis avec une clé 6 pans si nécessaire. Vérifiez que le drone ne risque pas de se désolidariser de
la liaison rotule sur laquelle il est monté.
Implémentation des lois de commande
— Depuis le bureau, copiez et renommez le dossier TME TP6 à votre nom puis ouvrez le
fichier Commande hexa template.mdl 1 . Sauvegardez ce fichier sous un autre nom dans
1. L’étude détaillée de la structure du programme représenté figure 4.2 de l’autopilot sera vue dans la dernière
partie du TME. Ce programme gère la radiocommande SPEKTRUM, la centrale d’attitude (IMU) NAVEOL ainsi
F. BATEMAN 71
le dossier précédemment crée. Vous noterez que la maquette utilise un microcontrôleur

DsPic 33fj256mc710 cadencé à 40 MIPS.
— Double-cliquez sur le bloc Chart, cette fonction intègre une machine à état illustré sur
la figure 4.3. Pratiquement, on accède aux états en commutant les switchs Flap et Gear
(tous deux à 0 en position basse, à 1 en position haute) de la radiocommande.
1. Initial ❀ Flap=0 et Gear =0 : moteurs arrêtés
2. Open Loop ❀ Flap=1 et Gear =0 : commande de la poussée seule. Celle-ci est bornée
par mesure de sécurité.
3. Closed Loop P ❀ Flap=1 et Gear =1 : Une loi de commande est déjà implémentée,
elle permet de valider le bon fonctionnement du drone lors des essais. Vous ne devez
absolument pas la modifier.
4. Closed Loop PI ❀ Flap=0 et Gear =1 : Vous y implémenterez les lois de commande
proportionnelle-dérivée (4.2) et par retour d’état (4.3). Si vous en avez le temps, vous
y implémenterez également les lois de commande qui mettent en œuvre un terme
intégral, soit (4.4) et (4.5). Vous noterez la présente d’une entrée logique reset mise
à 0 uniquement dans cet état et à 1 dans les autres états. Elle est à connecter aux
entrées reset des blocs discrete integrator de sorte que ces derniers ne soient actifs
que dans l’état Closed Loop PI.
— Depuis la machine à états (StateFlow Chart), cliquez sur le bloc Loi4 représenté fi-
gure 4.2 et complétez la commande de l’axe de tangage avec la structure de la com-
mande Proportionnelle-Dérivée. Les blocs que vous insérez doivent être paramétrés avec
un Sample Time égal à -1 afin d’hériter de celui de la machine à états.
— Insérez la fonction qui permet de transformer la commande mcalcul en commande de
vitesse des moteur n1ref à n6ref . Pratiquement, il s’agit d’un bloc gain qui réalise le
produit d’une matrice par un vecteur. Ici :
   
ω1 g1
ω2  g2 
   
ω  g 
 3  3
  =   u1 (4.6)
ω4  g4 
   
ω5  g5 
ω6 g6
où g1 , . . . , g6 sont des gains qui transforment mc en vitesse de rotation des hélices, en
particulier celles des hélices 1 et 4.
— Insérez des blocs TX Matlab Labview, ces blocs sont associés à l’UART 2 Vous relèverez
en particulier la consigne θref , l’assiette θ, la vitesse de tangage q et les vitesses de rotation
des moteurs 1 et 4. Les positions et les vitesses angulaires sont en radians et rad/s, il
180
convient de les multiplier par un facteur et de convertir le résultat en UINT16 pour
π
lire ces signaux avec rs232gui en degrés. Pour davantage de précision, utilisez un facteur
1800
.
π
que les six moteurs brushless et les cartes de contrôle (Bl-Ctrl).
72 F. BATEMAN
Figure 4.2 – Le programme SIMULINK de l’autopilot
— Montrez votre schéma de programmation à un enseignant et compilez-le. Un fichier

Nom Fichier.hex est généré.
4.4.1 Programmation de l’autopilot

1. Reliez le PC au boitier ICD3 via le câble USB puis le boitier ICD3 à la maquette via le
câble ICD3 comme illustré sur la figure 3.3.
2. Mettez la commande des gaz de la radiocommande (située à droite) en position basse
(gaz à zéro) et vérifier que les switchs Flap et Gear sont en position basse à l’état logique
bas (ou repoussés)
3. Mettez la radiocommande sous tension.
4. Reliez les connecteur d’alimentations de la batterie et de l’hexacoptère. La mise sous
tension des moteurs est signalée par un signal sonore.
5. Depuis le bureau, ouvrez le programme MPLAB IPE
— Sélectionnez un microcontrôleur 33fj256mc710,
— Cliquez sur Connect,
— Browse ❀ importez le fichier Nom Fichier.hex,
— Cliquez sur l’icôle Program afin d’implémenter ce fichier sur le microcontrôleur.
F. BATEMAN 73
Figure 4.3 – La machine à états contrôlée par les switchs de la radiocommande
Figure 4.4 – La loi de commande à compléter
74 F. BATEMAN
6. Test des lois de commande :

(a) Commutez le switch Flap en position haute à l’état logique haut (vers vous) et aug-
mentez progressivement les gaz. Vérifiez que toutes les hélices tournent puis ramener
les gaz à zéro. Le switch Flap reste en position haute.
(b) Commutez le switch Gear en position haute à l’état logique haut, augmentez les gaz
pour amener l’appareil à se sustenter et contrôlez avec le joystick gauche le mouvement
de l’appareil autour de l’axe de tangage.
(c) Commutez le switch Flap en position basse à l’état logique bas (vers l’avant), le
switch Gear étant maintenu à l’état logique haut pour amener l’appareil dans la loi
de commande que vous avez implémentée.
(d) Via la liaison bluetooth ou le cable FDTI entre l’hexacoptère et le PC est opération-
nelle, relevez les chronogrammes du tangage et de l’assiette sous rs232gui.
— Ajoutez à la consigne un signal carré de période égal à 5 s, de rapport cyclique égal à 0.5
et d’amplitude égale à 15°. Vous utiliserez pour cela un bloc Source ❀ Pulse Generator
que vous ferez suivre d’un bloc Commonly Used Blocks❀ Convert. Vous transformerez
ce signal en type Single avec un Sample Time de 10 ms.
— Compilez, programmez et visualisez les signaux.
4.4.2 Autres lois de commande

Commande par retour d’état
— Dans Loi4 remplacez la loi de commande Proportionnelle-Dérivée (4.2) par la commande

par retour d’état 4.3.
— Vous adopterez la même procédure que celle conduite précédemment pour tester cette loi
de commande.
Commande Proportionnelle-Intégrale-Dérivée
— Dans Loi4 insérer la loi de commande Proportionnelle-Intégrale-Dérivée (4.4) pour le

contrôle de l’assiette. En vous inspirants de ce qui a été fait pour le contrôle des axes de
roulis et de lacet, vous utiliserez des intégrateurs discrets (Discret❀Discrete Integrator)
cadencés avec un Sample Time égal à -1 (hérité du Chart). Vous noterez que lorsque l’on
entre dans Loi4, le signal raz=0, les intégrateurs sont activés. Lorsque l’on quitte Loi4,
raz=1 et ces mêmes intégrateurs voient leurs sorties forcées à zéro.
— Adoptez la même procédure que celle conduite précédemment pour tester cette loi de
commande.
Commande par retour d’état augmenté
— Dans Loi4 insérer la loi de commande par retour d’état augmenté (4.5) pour le contrôle
de l’assiette. vous traiterez l’intégrateur à temps discret comme au paragraphe précédent.
— Testez cette loi de commande.
F. BATEMAN 75
76 F. BATEMAN
TP 5
PLANIFICATION DE TRAJECTOIRES
5.1 Présentation du problème

Une trajectoire est l’ensemble des points par lequel passe le centre d’un robot au cours de
son mouvement depuis sa position initiale vers sa position finale. Plusieurs trajectoires peuvent
permettre de réaliser cet objectif, elles sont fonction des contraintes d’environnement (obstacles)
et du robot (sens de déplacement, rayon de courbure, etc.). Le choix et la construction d’une
trajectoire constituent la planification de trajectoires.
L’objet de cette étude est l’étude et l’implémentation d’algorithmes visant à générer et à
réaliser des trajectoires pour un véhicule autonome ; en l’occurrence un robot à deux roues non-
holonome 1 . Un tel robot est représenté sur la figure 5.1. Le choix de ce véhicule est lié à l’existence
de cette contrainte sur son mouvement qui ne lui permet pas de se déplacer perpendiculairement
à sa direction. Si d’autre part on impose le sens d’avancement et qu’on limite son rayon de
gyration alors le mouvement de ce robot a les mêmes propriétés que celui d’un aéronef à voilure
fixe évoluant dans un plan. Dans le plan, un quadrirotor est au contraire un véhicule holonome,
il peut atteindre tout l’espace des configurations (x,y,ψ) et réaliser toutes les trajectoires qui y
mènent.
Après avoir établi le modèle pour la commande du robot, vous étudierez et mettrez en œuvre,
pour un tel véhicule se déplaçant à vitesse constante et dans un environnement libre d’obstacles,
des trajectoires à longueur (ou temps) de parcours minimum. Ces trajectoires sont aussi appe-
lées chemins de Dubins. Dans un second temps, vous mettrez en œuvre et implémenterez une
stratégie de navigation par champs de potentiel artificiels, dans un environnement libre d’obs-
tacle ; puis dans le cas d’obstacles fixes dont les positions sont préalablement connue ; enfin dans
le cas d’obstacles dont mobiles. Ces différents scénarii seront joués dans un environnement de
simulation sous MATLAB.
1. Un robot non-holonome est tel que, en l’absence de glissement, la tangente à la trajectoire est portée par la
direction du véhicule, laquelle est perpendiculaire à l’entraxe des roues.
77
TP 5. PLANIFICATION DE TRAJECTOIRES
Figure 5.1 – Robot à deux roues non-holonome
~xb
ψ
2a
r
~y
~x
~z
Figure 5.2 – Repères et notations
5.2 Modèle du robot pour la commande

Le robot est décrit par les équations cinématiques suivantes :
ẋ = v cos ψ
ẏ = v sin ψ
ψ̇ = r (5.1)
avec

ω1 + ω2 ω1 − ω2
v = R r = R (5.2)
2 2a
où x, y,v, ψ, r, ω1 , ω2 désignent respectivement les coordonnées de la position, le cap, la vitesse
de lacet et les vitesses de rotation des roues droite et gauche (vue de dessus). R et 2a désignent
respectivement le rayon l’entraxe des roues. Pour les robots considérés R = 21mm et a = 45mm.
v
Comme on borne volontairement le rayon de gyration ρ = , on a la contrainte :
ω

aR ω1 + ω2 < ρmax

(5.3)
ω1 − ω2
78 F. BATEMAN
5.2. Modèle du robot pour la commande
Trouver une commande pour ce système non linéaire consiste à calculer les vitesses de rotation
des roues qui permettent par exemple au robot de réaliser les coordonnées vx = ẋ et vy = ẏ de
la vitesse v. Or pour ces deux coordonnées la relation n’est pas inversible.

ω1 + ω2
ẋ = R cos ψ
2

ω1 − ω2
ẏ = sin ψ
2a
ψ̇ = r (5.4)
Pour pouvoir inverser cette relation, on va non plus piloter la position du centre du robot
mais celle d’un point situé sur l’axe −
→
x b à l’avant du robot à une distance ℓ1 du centre dont on
exprime les coordonnées :
x1 = x + ℓ1 cos ψ
y1 = y + ℓ1 sin ψ (5.5)
Question 1 : Déduire de ces relations celles de ẋ1 et de ẏ1 en fonction de ω1 et ω2 .
On montre qu’il est possible d’exprimer ce résultat comme un produit de matrice :
! ! ! !
R R
ẋ1 cos ψ −ℓ1 sin ψ 2 2 ω1
= R R (5.6)
ẏ1 sin ψ ℓ1 cos ψ 2a − 2a ω2
Question 2 : Comment montrez que cette relation est inversible ? Autrement dit, que l’on pourra
réaliser les vitesses de rotation des roues du robot à partir des vitesses dotx1 = vx1 et x˙2 = vy2
désirées.
On a en effet :

1 a 1 a
ω1 = cos ψ − sin ψ ẋ1 + sin ψ + cos ψ ẏ1 (5.7)
R ℓ1 R ℓ1

1 a 1 a
ω2 = cos ψ + sin ψ ẋ1 + sin ψ − cos ψ ẏ1
R ℓ1 R ℓ1
Ce qu’il faut bien comprendre c’est que le mouvement du robot est décrit par les équations
(5.6) et qu’on réalise une commande externe au robot décrite par les équations (5.7) dans les-
quelles on remplace ẋ1 et ẏ1 par ẋ1d et ẏ1d qui sont les vitesses désirées pour le robot ; on les
note vx1d et vy1d . C’est ce que représente le bloc appelé Inversion dynamique de la figure 5.3.
Question 3 : Exprimez dans ces conditions les équations d’état du robot. Par quels systèmes
linéaires simples le robot muni de sa loi de commande peut-il être représenté.
F. BATEMAN 79
x1d + εx ψ
correcteur vx1d ω1d ω1 x1
- cinématique ω1
y1d + εy robot
correcteur vy1d ω2d ω2 y1
-
Inversion Dynamique Robot
Loi de Commande
Figure 5.3 – Commande du robot
Ce modèle très simple du robot ne peut pas être contrôlé dans l’état, on propose de doter
chacun des axes d’un correcteur proportionnel intégral.
Question 4 :Vous trouverez le bloc cinématique robot dans la librairie Trajectographie. Construi-
sez sous SIMULINK le bloc correspondant aux équations (5.7) qui réalise l’inversion dynamique.
Associez-le au bloc cinématique robot et validez son fonctionnement.
Question 5 : Précisez pour quelle raison le modèle du robot établi à la question précédente n’est
pas satisfaisant en l’état pour contrôler sa position ? Saisissez la fonction de transfert d’un des
axes du robot sous MATLAB 2 et synthétisez un correcteur proportionnel-intégral qui respecte les
conditions sur les vitesses de rotation des roues
Question 6 : Construisez cette loi de commande sur le modèle du robot précédemment établi.
Testez-le avec des consignes de position x1d et y1d en échelon ou en rampe. Observez les réponses
et les vitesses de rotation des roues qui ne doivent pas excéder ±15rad/s.
5.3 Trajectoire de Dubins

5.3.1 Génération des trajectoires
Un chemin de Dubins [2] est une trajectoire lisse (continue, dérivable, accélérations bornées)
entre deux points (départ et arrivée) associés à deux orientations (le cap initial et le cap final)
pour laquelle un rayon de courbure minimal est précisé. Un tel chemin est représenté sur la
figure 5.4. Cette courbe est décrite par un mot, celui-ci est constitué d’un ensemble de lettres C
(Circle) et S (Straight). Dubins adopte pour les cercles les notations suivantes :
— un arc de cercle dans le sens trigonométrique par rapport à l’orientation du vecteur de
départ est noté L,
2. Le modèle est on ne peut plus simple, pas de cos ψ, sin ψ, etc.
80 F. BATEMAN
5.3. Trajectoire de Dubins
— un arc de cercle dans le sens antrigonométrique par rapport à l’orientation du vecteur de

départ est noté R,
— chaque lettre S, L, R est suivie par un indice qui exprime la longueur du segment ou de
l’arc.
Dubins a démontré en 1957 qu’entre deux configurations de départ et d’arrivée, il existe une
courbe sans point de rebroussement et de longueur minimale constituée de la succession d’un arc
de cercle, d’un segment et d’un arc de cercles {Ct , Su , Cv } ou de trois arcs de cercle {Ct , Cu , Cv }.
Ces deux types de trajectoires définissent six mots qui permettent de relier deux points (avec
un cap initial, un cap final et un rayon de gyration donnés) de manière optimale en distance (ou
en temps à vitesse constante), et cela sans manœuvre :
{Lt Su Rv }, {Lt Su Lt }, {Rt Su Lv }, {Rt Su Rv }, {Lt Ru Lv }, {Rt Lu Rv } (5.8)
Figure 5.4 – Trajectoire de Dubins RSL
La détermination de la courbe consiste à tracer les quatre cercles tangents aux configurations
initiales et finales, à calculer les tangentes entre ces cercles et à conserver la trajectoire de
longueur minimale réalisable sans rotation du robot sur lui-même. Le rayon de courbure de la
trajectoire correspond alors au rayon des cercles de construction.
Pratiquement, la génération de trajectoire de Dubins est implémentée dans les fonctions
dubins core.m et dubins curve.m sous MATLAB. La première renvoie les caractéristiques d’une
trajectoire dont on donne les configurations de départ, d’arrivée et le rayon de gyration minimal ;
la seconde renvoie les coordonnées de cette même trajectoire. Vous consulterez l’aide de ces
fonctions pour prendre connaissance de la syntaxe.
Question 7 : En choisissant judicieusement et librement les configurations initiales dans un espace
de [−1, 1] × [−1, 1] et un rayon de gyration de 0.25, générez les quatre premières trajectoires
de Dubins de (5.8) avec dubins core.m et visualisez-les avec dubins curve.m. Vous devez pour
accéder à ces fonctions définir le path de MATLAB de sorte qu’il pointe dans le dossier où ces
fonctions sont déposées.
Question 8 : Calculez la longueur de l’une de ces trajectoires. Vous utiliserez avantageusement

les fonctions diff, sum, sqrt et .2 , le point devant le carré traduit le fait que pour un tableau A,
F. BATEMAN 81
l’opération A. ∗ A est effectuée pour élément à élément et le résultat est stocké dans un tableau
de même taille.
Question 9 : Au moyen d’un bloc From Worskpace, réalisez une trajectoire de Dubins RLR ou
LRL, calculez la longueur du chemin et déduisez-en un ordre de grandeurs pour la durée du
parcours. Générez ensuite un vecteur contenant les instants de simulation ( même longueur que
le tableau contenant le chemin de Dubins) et appliquez-là comme consigne de position au modèle
du robot muni des lois de commande établies précédemment.
5.3.2 Implémentation des trajectoires
La planification des trajectoires doit tenir compte des limites physiques du robot. En par-
ticulier, la vitesse v et le rayon de gyration ρ sont bornés. En effet, les vitesses de rotation des
roues sont supposées comprises dans l’intervalle [0, 15]rad/s et le contrôle du robot s’opère à une
période d’échantillonnage Ts = 50ms. Dans ces conditions, on cherche à réaliser des consignes
pour les trajectoires de Dubins compatibles avec le robot étudié.
Détermination graphique de la vitesse du robot
On va représenter dans un même espace à trois dimensions les courbes de niveau de v(ω1 , ω2 )
et ρ(ω1 , ω2 ) − ρmin dans le but de maximiser la vitesse tout en respectant la contrainte sur le
rayon de gyration ρmin = 0.25m.
Question 10 : Générez l’espace des vitesses de rotation (ω1 , ω2 ) réalisables en utilisant meshgrid,
calculez et tracez avec la fonction contour les lignes de niveau de v et δρ = ρ − ρmin . Déduire des
isoδρ les vitesses ω1 et ω2 pour lesquelles la vitesse du robot est maximale. On suppose que la
vitesse v reste constante et égale à la vitesse maximale précédemment trouvée ; en ligne droite
comme sur les arcs de cercle.
Question 11 : Déduire de cette vitesse l’incrément de distance parcouru par le robot pendant une
période d’échantillonnage et recalculez la trajectoire avec ce pas.
Question 12 : Implémentez ces consignes de position dans un bloc From Workspace, pensez pour
faire fonctionner ce bloc à générer un vecteur temps de même longueur cadencé à la période
d’échantillonnage Ts . Pour stopper proprement le robot sur la consigne terminale, validez le
menu déroulant Form output after final data value by : Holding Final Value.
Question 13 : Simulez et représentez sur une même figure la trajectoire de consigne et la trajectoire
réalisée. Proposez et réalisez avec les outils de simulation un indicateur qui rende compte de la
qualité de la trajectoire réalisée par le robot.
Question 14 : Comment améliorer ce suivi de trajectoires ?
82 F. BATEMAN
5.4. Champs de potentiel artificiels
Détermination numérique de la vitesse du robot
Les vitesses de rotation des roues qui maximisent la vitesse sous les contraintes de rayon de
gyration ρmin et de vitesses de rotation des roues dans l’intervalle [0,o megamax ] peuvent être
calculées avec des algorithmes de minimisation sous contraintes égalité et inégalité à l’instar
de l’algorithme SQP (Sequential Programming Algorithm) implémenté sous MATLAB avec la
fonction fmincon. Maximiser une fonction f (x), c’est évidemment minimiser −f (x).
Question 15 : En utilisant l’aide de la fonction fmincon sous MATLAB, calculez les valeurs op-
timales de la vitesse des roues sous le contraintes précitées. Il est conseillé de s’inspirer de
l’exemple qui figure à la fin de l’aide. La fonction à maximiser et la fonction qui décrit la
contrainte non linéaire doivent figurer dans deux scripts distincts. Le nom du fichier afférent
doit être identique à celui de la fonction.
5.4 Champs de potentiel artificiels

Ce concept consiste à attribuer à l’espace du robot un champ de potentiel artificiel constitué
par deux composantes [4] :
— un champ attractif ϕb calculé en fonction de la position à atteindre relativement à celle
du robot, ce champ est convexe et minimal au but.
— un champ répulsif ϕo calculé en fonction de la forme et de la position relative des obs-
tacles à celle du robot, ce champ est d’autant plus important que le robot est proche de
l’obstacle.
Le champ total :
n
X
ϕt = ϕb + ϕoi (5.9)
i=1
Il est important de comprendre que ces champs n’existent pas dans l’environnement, ils sont
calculés par le contrôleur du robot. Il s’agit en fait d’un artifices de calcul à partir duquel sont
dérivés les efforts à appliquer aux actionneurs, ici les moteurs qui contrôlent les vitesses de
rotation des roues. Un tel champ de forces est représenté sur la figure 5.5 et la force qui en
dérive a pour expression :
−
→ −−→
F = −gradϕt (5.10)
Ses composantes sont :
∂ϕt
Fx = − (5.11)
∂x
∂ϕt
Fy = −
∂y
De fait le robot se déplace dans la direction de la plus grande pente.
F. BATEMAN 83
Figure 5.5 – Champs de potentiel
On propose les modèles suivants pour les champs de potentiel [5] :
1
ϕb = − ζ (x − xb )2 + (y − yb )2 (5.12)
2
 !2
 1
 1 1
η p − d(x, y, xo , yo ) ≤ d0
ϕo = 2 2
(x − xo ) + (y − yo )2 d0 (5.13)


0 d(x, y) > d0
où d0 > 0 est une distance qui reflète l’influence de l’obstacle, ζ et η des paramètres qui per-
p
mettent de modeler les champs de potentiels et d(x, y) = (x − xo )2 + (y − yo )2 .
On montre que les forces qui dérivent du champ de potentiel ont pour expression :

 1 1 x − xo
 η
 − 3
d(x, y) ≤ d0 , 0 si d(x, y) > d0
Fo = d(x, y) d0 d (x, y) (5.14)
 1 1 y − yo
 η
 − d(x, y) ≤ d0 , 0 si d(x, y) > d0
d(x, y) d0 d3 (x, y)
Question 16 :Calculez la force φb qui dérive du potentiel attractif ; puis, sous SiMULINK, construi-
sez pour les forces d’attraction et de répulsion les modèles paramétrables qui correspondent à un
but et un obstacle. Chacune de ces forces doit être implémentée dans un bloc sous-système distinct
paramétrable. Consultez le Webinar https: // fr. mathworks. com/ videos/ creating-and-masking-subsystems-6
html pour apprendre à créer un bloc paramétrable ou masque de sous-système.
Les forces Fx et Fy calculées par le contrôleur du robot procèdent de la somme des forces
élémentaires. Elles doivent néanmoins être normalisées, de sorte qu’elles ne tendent pas vers
l’infini lorsque le robot est loin du but. Mais cette normalisation ne doit pas conduire à une
indétermination lorsque le robot est à proximité du but. On propose pour le modèle des forces
84 F. BATEMAN
5.4. Champs de potentiel artificiels
normalisées :
Fx
fx = q (5.15)
Fx2 + Fy2 + ε
Fy
fy = q (5.16)
Fx2 + Fy2 + ε
On choisit ε petit.
Question 17 : Construisez le modèle des forces normalisées et implémentez l’ensemble des fonctions
qui réalisent les forces dans un sous-système.
Question 18 : Le robot est toujours muni du bloc de contrôle Inversion Dynamique mais les correc-
teurs proportionnel-intégral sont supprimés et remplacés par les modèles des forces d’attraction
et de répulsion. Appliquez les forces normalisées aux entrées du bloc Inversion Dynamique.
On définit l’environnement du robot en précisant les coordonnées du but à atteindre et celles

des obstacles. Les variables qui contiennent ces coordonnées sont respectivement notées xb, yb,
xo1, yo1, xo2, yo2, xo3, yo3, leur modèle figure dans la librairie.
Question 19 : Construisez un espace comportant un but et trois obstacles. Les coordonnées du

robot devront être stockées dans des blocs out.x1, out.y1. Ouvrez le fichier Plot Potential field.m
et simulez la trajectoire du robot.
Question 20 :Modifier le schéma pour rendre une des cibles mouvantes et contraindre le robot à
changer de trajectoire. On pourra par exemple utiliser une rampe retardée pour modifier l’une
des coordonnées de l’obstacle. Une telle trajectoire est illustrée sur la figure, elle n’est clairement
pas optimale.
F. BATEMAN 85
Figure 5.6 – Trajectoire sur champ de potentiel artificiel
86 F. BATEMAN
TP 6
CONTRÔLE DE LA TRAJECTOIRE D’UN DRONE
Ce TP a pour objet la mise en œuvre d’un système de capture de mouvements constitué de

six caméras Qualisys Miqus ultra-rapides (1 Mpixels, 250 images/s). Ces dernières sont associées
à un logiciel de traitement d’images qui restitue les positions et les angles d’attitude d’objets
identifiés évoluant dans le champ visuel couvert par les caméras. Vous aurez dans un premier
temps à traiter ces informations pour estimer la vitesse d’un quadrirotor puis à contrôler sa
trajectoire. Dans un second temps, vous mettrez en œuvre deux quadrirotors au moyen d’une
stratégie de commande par consensus avec pour but le contrôle de la hauteur de ces drones.
6.1 Calibration du système de capture de mouvements (Motion CAP-

ture)
6.1.1 Calibration des caméras
Branchez sur le réseau électrique le bloc d’alimentation des caméras puis mettez le PC 3
écrans sous tension, le mot de passe est projet. Depuis le bureau du PC 3 écrans, exécutez le
programme Qualisys Track Manager (QTM) et cliquez sur le bouton New Project que vous
nommerez TMEGroupeX où X est le numéro de votre groupe de travail défini au début des
enseignements de TME.
87
TP 6. CONTRÔLE DE LA TRAJECTOIRE D’UN DRONE
Figure 6.1 – Nouveau projet
Dans le champ Base the new project on, choisissez l’option Default settings puis Ok. La
fenêtre suivante s’ouvre :
Figure 6.2 – La fenêtre principale de QTM
Cliquez sur Tools > Project Option > Camera System puis sur le bouton Locate System.
Lorsque les caméras sont localisées, l’adresse IP de la carte sur laquelle elles sont connectées est
affichée. Le bouton System Info renvoie l’adresse et des informations sur chacune des caméras.
Figure 6.3 – La présence des caméras sur le réseau à l’adresse IP indiquée
En revanche, le MoCap reste à calibrer. Cliquez sur Ok. File ❀ New ❀ les vues prises par
88 F. BATEMAN
6.1. Calibration du système de capture de mouvements (Motion CAPture)
les six caméras apparaissent, les boutons Marker, Intensity et Video renvoient les images dans
différents modes. En particulier, le mode Marker permet seulement de visualiser les marqueurs
utilisés pour identifier et suivre la trajectoire d’un mobile. Le mode Intensity est utilisé pour
régler les seuils permettant de discriminer les marqueurs et suivre les mobiles ; le mode Video
permet à quant à lui de visualiser les zones imagées par les caméras. Notez la présence des
boutons All/None et 1, 2, 3, 4, 5, 6 qui permettent de visualiser les images prises par les caméras
sélectionnées.
Figure 6.4 – Les six vues en mode Vidéo
Positionnez l’équerre munie de marqueurs au centre de l’arène et vérifiez qu’en mode Inten-
sity, pour les caméras sur lesquelles elle est visible, que les marqueurs présentent une couleur
jaune ou rouge (ces couleurs sont caractéristiques d’un seuillage efficace qui permet de discrimi-
ner les marqueurs). Passez ensuite en mode Marker. Des artefacts peuvent apparaı̂tre à l’instar
de ce que montre la figure 6.6. Il peut s’agir d’un mauvais masquage de la lumière du soleil ou
des flashs émis dans l’IR par les caméras auxquelles les marqueurs sont sensibles. Pour masquer
ces effets, on peut introduire des retards dans l’émission de ces flashs, de sorte que l’instant
d’émission de la caméra pollueuse et l’instant d’acquisition de la caméra polluée ne soient plus
synchronisés.
F. BATEMAN 89
Figure 6.5 – L’équerre et le wand
Figure 6.6 – Vue de la courone de LeDs IR d’une caméra par une autre caméra
Identifiez le numéro de la caméra polluée, puis faites Tools>Project Option>Caméra system

et sélectionnez la caméra que vous souhaitez isoler.
Sélectionnez le champ Exposure Delay Mode ❀ Camera Group ; par défaut toutes les caméras
90 F. BATEMAN
6.1. Calibration du système de capture de mouvements (Motion CAPture)
sont dans Group 1. Passez la caméra sélectionnée dans un groupe différent.
Figure 6.7 – Définition des graoupes de caméras
Tools>Project Option>Calibration
Choisissez la calibration de type Wand et le Wand Kit 300 mm dont la longueur exacte est
300,8 puis validez en cliquant sur Apply et Ok. Utilisez pour l’orientation du repère les indications
suivantes, soit −
→
x E pointé vers le mur Est, −
→
y E vers le Sud et − →z E dirigé vers la terre. Toujours
en mode Marker, Capture ❀ Calibrate, choisissez un temps de calibration d’au moins 60 s, vous
pouvez également introduire un retard au déclenchement de la calibration, typiquement 10s.
Munissez-vous de la baguette de calibration qu’il faut manipuler avec le plus grand soin. Cliquez
sur Ok et positionnez-vous dans l’arène de vol, évoluez-y avec grâce en maniant la baguette de
manière à couvrir au mieux l’espace de l’arène. Pendant toute la durée de la calibration, les
couronnes de Leds des caméras clignotent.
F. BATEMAN 91
Figure 6.8 – Réglage de la durée de la phase de calibration
A l’issue de cette opération, le MOCAP est calibré et la précision de la mesure à 1 σ est

calculée. On considère que cette dernière est acceptable si σ est inférieur à 1,5 mm. Vous pouvez
désormais passer en mode 3D et visualiser le repère, la zone calibrée, les champs de vision des
caméras.
Figure 6.9 – Réglage de la durée de la phase de calibration
6.1.2 Identification d’un objet

Retirez le kit de calibration en L de l’arène et positionnez un drone muni de marqueurs sur
l’origine du repère de référence, cliquez sur Capture ❀ Start. Cette action initie une séquence
de prises de vues de l’objet à identifier pendant une durée de 10s (valeur par défaut). Dans
la partie droite de l’écran, les marqueurs, sont définis comme des trajectoires non identifiées.
Si le nombre de marqueurs référencé est identique au nombre de marqueurs physiques, cela
92 F. BATEMAN
6.2. Contrôle automatique de la trajectoire du drone
signifie que ces derniers ont été identifiés, il faut alors les sélectionner et les faire glisser dans la
fenêtre Labeled trajectories. Cliquez droit sur ces marqueurs préalablement sélectionnés et choisir
l’option Define Rigid body 6 DOF. Nommez l’objet (Drone1 par exemple) et validez. Puis dans
Tools>Project Options ❀ Processing, cochez les cases Calculate 6 DOF dans les menus Real time
Actions et Capture Actions, cliquez sur Apply et OK. Vérifiez que le repère associé au drone
a une orientation identique à celle du repère de référence. Si ce n’est pas le cas, modifiez son
orientation et sa position depuis Tools>Project Options ❀ 6DOF Tracking, sélectionnez Drone1
et modifiez la position de l’origine de son repère et son orientation avec les boutons Tranlate
et Rotate. On vérifie maintenant que le drone est bien identifié et que le MOCAP restitue sa
position. Déplacez le drone dans l’arène. Faites :
File ❀ New ❀ 3D et vérifiez que l’objet Drone1 a bien été déplacé.
Figure 6.10 – Objet labellisé et muni d’un repère
Retirez le premier drone de l’arène de vol et procédez de même pour identifier le second
drone appelé Drone2.
6.2 Contrôle automatique de la trajectoire du drone

6.2.1 Contrôle manuel du drone dans l’arène de vol
Vérifiez que la clé WIFI est insérée dans le port USB de la façade avant du PC 3 écrans
(adresse 192.168.0.2) et mettez sous tension le routeur TPLink (adresse 192.168.0.11). Connectez
le PC 3 écrans au réseau WIFI TPLINK A692. Connectez le joystick au PC 3 écrans. Connectez
la batterie de l’ARDrone 0/3 (adresse 192.168.0.100/103), ce dernier se connecte automatique-
ment au routeur TPLINK. Vous pouvez vous assurer que la liaison est établie en exécutant un
ping depuis l’invite de commande du PC 3 écrans.
Depuis le bureau du PC 3 écrans, exécutez le programme ARDroneController.
Depuis la barre des menus Options ❀ Adresse IP, saisissez celle du drone que vous souhaitez
piloter. Assurez-vous que le joystick est reconnu par le programme et paramétrez un bouton
pour le décollage/atterrissage et l’arrêt d’urgence. Ouvrez la connection au drone. Effectuez un
vol pour vous assurer du bon fonctionnement du drone.
F. BATEMAN 93
Figure 6.11 – La fenêtre principale du programme ARDrone Controler
Depuis le menu de QTM, lancez une capture d’une durée d’une minute et effectuez un
vol ; assurez-vous de maintenir l’appareil dans la zone couverte par les caméras. Sauvegardez
la trajectoire capturée (non fichier.qtm). Pour visualiser la position, la vitesse, etc. du drone,
dans la fenêtre Labeled trajectories, sélectionnez le marqueur qui définit l’origine du repère drone
puis, sous la barre des menus, cliquez sur le bouton Analyze Trajectory et affichez les courbes
de position, vitesse, accélération. Notez qu’il est possible de traiter ces signaux (lissage, filtre
à moyenne glissante) et de les exporter vers un fichier *.TSV. Ces derniers s’ouvrent avec un
éditeur de texte et il est possible d’importer le tableau de points depuis MATLAB. Il faut toutefois
reconstruire la variable temps, par défaut la période d’échantillonnage vaut 10ms.
6.2.2 Estimation de la vitesse du drone

Dans cette partie vous allez, sous MATLAB 2013a, en temps réel, estimer la vitesse du
drone à partir des mesures de position délivrées par QTM. Pour ne pas à faire voler le drone,
vous rejouerez de manière virtuelle et répétée le vol précédemment effectué. Les données de
position sont émises depuis QTM sur le réseau et accessibles en temps réel sur les PC qui y sont
connectés : Play ❀ Play with real time output.
Dans le même temps, sur une des machines du laboratoire, ouvrez MATLAB et définissez le
chemin pointant sur le dossier Arène. Si le PC utilisé pour QTM et MATLAB est le même, il
faut dans le fichier QMC conf3.txt utiliser le localhost soit choisir l’adresse IP 127.0.0.1, ce qui
est réalisé en supprimant le caractère de commentaire # devant cette adresse IP. Si les deux PC
sont différents, vous devrez utiliser l’adresse IP 192.168.0.2 qui est celle serveur utilisé par QTM
hébergé sur le PC 3 écrans. Sous le Command Windows de MATLAB, à l’invite de commande,
tapez et exécutez :
>> q= QMC(’QMC conf3.txt’)
Le fichier QMC conf3.txt définit en particulier l’adresse du serveur, le type de données et

le nombre de drones pouvant être traités par MATLAB. La commande : >> data=QMC(q)
renvoie un tableau 6 lignes/4 colonnes, soit les 3 positions en mm et les 3 positions angulaires de
4 drones identifiés 0,1,2,3.. Comme seuls les drones 0 et 3 sont en état de fonctionner, les autres
coordonnées sont portées à 0. Lorsqu’une coordonnée n’est pas définie, MATLAB renvoie NaN
(Not a Number). On acquiert les positions en temps réel avec SIMULINK depuis le programme
94 F. BATEMAN
MOCAP Acquisition.slx.
Figure 6.12 – L’acquisition des données issues du MoCap sous Simulink
Ce bloc est réalisé par une Embedded Matlab Function, commencez par le renommer Mon-
Nom MOCAP Acquisition.slx puis, vous y coderez un programme qui permet de calculer les
trois composantes de la vitesse du drone. Il faut également pouvoir renvoyer un message à
l’écran lorsque le drone n’est plus dans le champ visuel des caméras. Cette fonction doit ren-
voyer les coordonnées et les trois composantes de la vitesse du drone qu’il vous faut calculer dans
le repère de l’arène. Elle admet comme argument le numéro du drone (ici 0 ou 3) et la variable
q associée à la fonction QTM, celle-ci commande l’acquisition des positions toutes les 30 ms,
cette valeur est définie par le Sample Time de la constante associée à q. A ce sujet, pour le choix
de la période d’échantillonnage, les caméras délivrent théoriquement jusqu’à 100 informations
de positions par seconde. Il faut toutefois savoir que l’ARDrone 2 est contrôlé avec une période
d’échantillonnage de 30 ms. Lors de la rédaction du sujet de ce TP, c’est cette valeur de 30 ms
qui a été retenue, toutefois, rien ne vous empêche de conduire des essais à une cadence plus
élevée, dans le but par exemple de traiter les mesures de position au moyen d’un filtre RIF.
% i n i t i a l i z a t i o n du t a b l e a u data au p r e m i e r a p p e l de l a f o n c t i o n
data=z e r o s ( 6 , 4 ) ;
% i n i t i a l i z a t i o n de v a r i a b l e s u t i l e s au c a l c u l de l a v i t e s s e e a u
xa0 = 0 ;
ya0 = 0 ;
za0 = 0 ;
xa 1 =0;
ya 1 =0;
z a 1 =0;
end
% A c q u i s i t i o n d es p o s i t i o n s e t d es v i t e s s e s a n g u l a i r e s dans l a v a r i a b l e data
data = QMC( q ) ;
% C a l c u l d es v i t e s s e s
F. BATEMAN 95
% Renvoi d es s o r t i e s c a l c u l é e s
xa=
ya=
end
6.2.3 Repères et forces

Cette étude a été conduite en première année, on rappelle toutefois quelques résultats.
— Rb : un repère attaché au drone défini supra,
— RE : le repère de référence attaché à l’arène de vol, supposé inertiel et défini supra,
— Rv un repère ayant pour origine le centre de gravité du drone et dont les vecteurs qui
le définissent ont à tout instant la même direction que ceux qui définissent RE . Soit − →xv
→
− →
− →
− →
− →
−
colinéaire à x E , y v colinéaire à y E et z v colinéaire à z E .
— Rn est le repère de navigation. Son origine coı̈ncide avec le centre de gravité du drone, il
est obtenu en opérant à une rotation d’angle ψ de Rv autour de l’axe − →
z v.
Du fait de la faible vitesse de déplacement du drone, la trainée est négligée, seuls le poids
mg z E et la force de portance −P −
→
− →z b développées par les hélices sont considérés. Le PFD
appliqué au drone :
   
0 0
E    
F = TbE  0  +  0  (6.1)
−P mg
Où TbE est la matrice de passage du repère drone au repère terrestre :
 
cos θ cos ψ sin φ sin θ cos ψ − cos φ sin ψ cos φ sin θ cos ψ + sin φ sin ψ
 
TbE =  cos θ sin ψ sin φ sin θ sin ψ + cos φ cos ψ cos φ sin θ sin ψ − sinφ cos ψ  (6.2)
− sin θ sin φ cos θ cos φ cos θ
L’expression des forces dans le repère de navigation :
     
cos ψ sin ψ 0 0 0
n      
F =  − sin ψ cosψ 0  TbE  0  +  0 
0 0 1 −P mg
| {z }
R(ψ)
Où R(ψ) désigne la matrice de rotation d’un angle ψ autour de l’axe de lacet. Cette matrice
est orthogonale et R(ψ)−1 = R(ψ)T = R(−ψ).
A l’équilibre, la portance équilibre le poids et P = mg. Montrez pour des petits angles φ et
θ que les forces dans le repère de navigation ont pour expression :
 
−mgθ
Fn =  mgφ 
 
(6.3)
0
96 F. BATEMAN
Principe du guidage
Figure 6.13 – Suivi de waypoints
Le calcul de l’erreur de position dans le repère terrestre :

!E !E
εx xEref − xE
= (6.4)
εy yEref − yE
où (xEref , yEref ) sont les coordonnées du pont à atteindre.
Figure 6.14 – Erreurs de position dans RE
F. BATEMAN 97
Calcul de l’erreur de position dans le repère de navigation :
!n !E
εx εx
= R2×2 (ψ) (6.5)
εy εy
et génération d’une force de poussée orientée vers le waypoint à atteindre :
 
−mgθ
Fn ≈  mgφ 
 
(6.6)
0
Figure 6.15 – Erreurs de position dans RE
6.3 Loi de commande

Le PFD appliqué au drone :
! ! !
E ẍE cos ψ − sin ψ −mgθ
F =m = (6.7)
ÿE sin ψ cosψ mgφ
A cap constant, la transformée de Laplace de ces équations s’écrit :
g
xE (s) = − (cos(ψ)θ(s) − sin(ψ)φ(s)) (6.8)
s2
g
yE (s) = (sin(ψ)θ(s) + cos(ψ)φ(s)) (6.9)
s2
98 F. BATEMAN
6.3. Loi de commande
On calcule les lois de commande en supposant le cap nul et on suppose les angles de gı̂te et
l’assiette parfaitement asservis à leur consigne. Ce sont ces consignes de gı̂te et d’assiette qui
jouent le rôle d’entrée de commande des boucles d’asservissement de trajectoire du drone. Soit
les lois de commandes et le schéma fonctionnel afférents :
 
 
θref = −kd kp (xEref − xE ) −µ (6.10)
| {z }
µref
 
 
φref = kd kp (yEref − yE ) −ν  (6.11)
| {z }
νref
où (µ, ν) désignent les coordonnées du vecteur vitesse du drone dans le repère de navigation.
Figure 6.16 – Les lois de commande
Les gains kd et kp sont réglés pour que le système en boucle fermée tende vers une fonction
de transfert de référence :
xE (s) −gkd kp kωn2

= 2 = 2 (6.12)
xEref (s) s − sgkd − gkd kp s + 2ξωn s + ωn2
yE (s) gkd kp kωn2

= 2 = 2 (6.13)
yEref (s) s + sgkd + gkd kp s + 2ξωn s + ωn2
6.3.1 Modèle de simulation

Dans ce TP, on utilise la version 2013a de MATLAB. Calculez les valeurs numériques de kd et
kp pour que le drone se comporte comme un système du second ordre de facteur d’amortissement
√
unitaire et de pulsation propre non amortie égale à 2rads−1 .
Réalisez sous Simulink le modèle de simulation décrit sur la figure précédente.
F. BATEMAN 99
Vous construirez les matrices de rotation au moyen de blocs User Defined Functions ❀
MATLAB Function et encapsulerez le modèle du drone dans un subsystem.
Générez la trajectoire de consigne suivante :
1. Décollage et maintien en vol stationnaire pendant 5s,
2. Trajectoire circulaire de rayon 1m parcourue en 4πs. Pratiquement, vous pouvez avanta-
geusement utiliser les blocs Sources ❀ Sine Wave Function.
On envisage trois stratégies de commande pour le suivi de trajectoire :
1. Contrôle des axes de tangage et de cap : le drone se déplace de sorte que l’axe − →
x b (axe
de visée de la caméra) soit colinéaire à celui du vecteur vitesse. Pour cela, réalisez une
fonction qui calcule le cap à suivre à partir des consignes de position. Après vous être
documentés sur les fonctions Atan et Atan2, vous les implémenterez au moyen du bloc
blocs Maths operation ❀ Trigonometric Function.
2. Contrôle des axes de tangage et de gı̂te à angle de cap constant. Pratiquement, l’axe − →xb
pointe toujours dans la même direction.
3. Contrôle des axes de tangage et de gı̂te tandis que la caméra est contrainte de viser un
point fixe.
6.3.2 Implémentation
Ouvrez le fichier Control ARdrone.slx et copiez-y le bloc Embedded Matlab Function réalisée
dans MonNom MOCAP Acquisition.slx et qui renvoie la position et la vitesse du drone.
Figure 6.17 – Programmation des lois de commande sous Simulink
Vous devez connecter le joystick au PC. La gâchette et le contrôleur de vues (bouton actionné
avec le pouce et situé sur le manche) permettent respectivement de faire décoller/atterrir le
quadrirotor et de le poser en cas d’urgence. Le bloc Joystick contient des bascules T pour
maintenir les états logiques après que les boutons poussoirs aient été relâchés. La machine à
état, bloc Chart, réalise :
1. Une séquence d’initialisation consistant en un recalage de la centrale d’attitude,
2. L’enfoncement de la gâchette fait décoller l’appareil qui est alors en boucle ouverte,
3. Après trois secondes, les lois de commande sont opérantes,
100 F. BATEMAN
6.4. Pour aller plus loin
4. Un appui sur la gâchette pose le drone.

On peut à tout moment forcer le drone à se poser en amenant le bouton PDV dans la position
180° (vue arrière). Dans le bloc UDP, précisez l’adresse IP du drone, le port 5556 est utilisé pour
écrire les commandes sur l’ARDrone et le port local doit être choisi à 10000 + numéro drone
(à vérifier par défaut il s’agit des adresses 10000 et 10001 lorsque deux drones volent en même
temps)
Vous implémenterez les lois de commandes proportionnelles-dérivées pour le contrôle des
coordonnées (xE , yE ) du drone dans le bloc Controller1. La tenue de hauteur est déjà réalisée.
wref = −0.9(zEref − zE ) (6.14)
1. Positionnez le drone sur l’origine du repère et testez son comportement du drone en vol
stationnaire pour des coordonnées de référence.
2. Testez ensuite les trajectoires circulaires simulées précédemment. Avant chaque vol, pré-
sentez votre schéma à un enseignant.
6.4 Pour aller plus loin

Faites une recherche sur les courbes de Dubin et générez des trajectoires au moyen de la
fonction dubins curves.m. On suppose une trajectoire de l’ARDone à hauteur constante contrô-
lée par l’angle d’assiette θ et le cap ψ. Testez une trajectoire générée au moyen de la fonction
dubins curves.m sur le modèle de simulation puis voyez à l’implémenter sur le modèle de pro-
grammation. Il faut pour cette fonction ajouter l’argument false ou true selon que vous souhaitez
ou non visualiser la trajectoire.
F. BATEMAN 101
102 F. BATEMAN
TP 7
COMMANDE D’UN ESSAIM DE DRONES PAR CONSENSUS
7.1 Présentation du problème

Ce TP traite de la commande par consensus qui est une stratégie de commande étudiée
depuis le début des années 2000. Celle-ci permet à un ensemble d’agents de coopérer entre eux
en échangeant des informations sur leur état dans le but d’atteindre un même état final, et cela
quelque soit leur état initial. Il s’agit d’une technique de commande non supervisée en ce sens
où la génération des commandes n’est pas opérée par un agent externe au groupe mais relève
de l’action de chacun des agents. La figure 7.1 illustre une expérience simple mettant en œuvre
cette stratégie de commande avec un essaim de deux drones qui doivent rejoindre une même
hauteur.
Cette activité comporte deux études, la première porte sur la commande par consensus du
premier ordre, la seconde sur la commande par consensus au second ordre. Chacune se décom-
posant en trois parties. Dans la première partie, vous étudierez les propriétés de la commande
d’un essaim de drones par consensus. Dans la seconde partie, vous simulerez le comportement de
l’essaim ainsi contrôlé. Ces simulations seront restituées dans un environnement d’animation 3D.
Dans la troisième partie, vous mettrez expérimentalement en œuvre un essaim de deux drones
dans l’arène de vol pour réaliser un consensus sur la hauteur la position horizontale selon un
axe. On lira avec intérêt l’article de [3] sur ce sujet.

Pour les simulations, vous êtes invités à utiliser les postes informatiques munis de MATLAB
2019 et de la toolbox Simulink Animation 3D. Pour les expérimentations, vous utiliserez les
matériels et logiciels suivants :
— système de capture de mouvement,
— logiciel Qualisys Track Manager installé sur le PC attenant à la volière de drones,
— 2 ARDrones,
— 1 Routeur,
103
TP 7. COMMANDE D’UN ESSAIM DE DRONES PAR CONSENSUS
Figure 7.1 – Consensus pour un essaim de 2 ARDrones - EPRE EA2015
— 1 Joystick
— MATLAB 2013a,
— une paire de crocs ...
Les fichiers utiles sont dans le dossier TP Consensus 2020 sur le bureau et sous Moodle dans
l’espace dédié à ce TME.
7.2 Commande par consensus du premier ordre

Dans cette partie du TP, on s’intéresse à une stratégie de commande dite par consensus du
premier ordre , qui vise à amener les N = 4 drones d’un essaim à une même hauteur. Tous les
drones de l’essaim sont identiques et l’équation d’état de la hauteur du drone i est celle d’un
système du premier ordre :
żi = ui (7.1)
Où ui est la commande du drone i. La hauteur de chaque drone est mesurée, soit zim cette
mesure de hauteur. Cette dernière est supposée parfaite c-à.d zim = zi .
Question 21 : Établissez les équations d’état et d’observation de l’essaim de drones, soit le vecteur
d’état X, de commande U, de mesures U et les matrices A, B, C et D.
7.2.1 Cas d’un graphe des liaisons non-orienté

Pour cette stratégie de commande, chaque agent i de l’essaim élabore sa commande ui
d’après les informations de hauteur que lui transmettent les drones avec lesquels il communique.
Le réseau de communication de ces données est décrit par un graphe tel que celui représenté sur
la figure 7.2 et la loi de commande afférente pour le drone i s’écrit :
N
X
ui = −kij (zi − zj ) (7.2)
j=1
104 F. BATEMAN
7.2. Commande par consensus du premier ordre
kij = 1 si le robot j communique sa position au robot i

où
kij = 0 sinon
4 3
bc bc
bc bc
1 2
Figure 7.2 – Graphe non orienté décrivant les liaisons entre les drones
Question 22 : Pour les graphe des liaisons de données de la figure 7.2, écrivez les équations
d’état de l’essaim ainsi contrôlé et montrez que ces équations ont la même structure que celle
d’un système commandé par retour d’état pour lequel il n’y a pas d’entrée de consigne. Vous
préciserez en particulier l’expression de la matrice d’état corrigée qu’on notera −L. La matrice
L est aussi appelée en théorie des graphes matrice laplacienne.
Question 23 : Au vu de la structure de la matrice laplacienne, montrez que zéro est une valeur
propre de cette matrice et proposez une expression possible pour le vecteur propre associé.
Notez que la matrice laplacienne est réelle et symétrique, que par conséquent elle est toujours
diagonalisable sur R. Qu’en outre, la matrice de passage constituée des vecteurs propres associée
aux valeurs propres de L est orthogonale.
Question 24 : Pour le graphe des liaisons de données inter-drones qui vous a été communiqué,
saisissez sous MATLAB les matrices d’état et de commande de la représentation d’état corrigée.
Vous vérifierez que zéro est bien une des valeurs propres de la matrice d’état corrigée et que la
matrice de passage dans la base modale est orthogonale.
Question 25 : En utilisant la matrice de passage dans la base modale et les valeurs propres de
la matrice d’état corrigée calculées à la question précédente, établissez les solutions des équa-
tions d’état du drone t
corrigé dans la base modale en fonction des hauteurs initiales Z (0) =
z1 (0) . . . zN (0) .
Question 26 :
1. Montrez qu’il y a consensus c-à.d que les hauteurs convergent toutes vers une même valeur
non définie a priori et fonction des seules conditions initiales.
2. Que représente dans ces conditions le noyau de L ?
3. Précisez en justifiant votre réponse quelle sera la nature des modes et l’ordre de grandeur
du temps de réponse pour que l’essaim réalise le consensus.
Ouvrez le fichier Consensus 4 drones.slx. Ce fichier contient les modèles de quatre drones
dont les entrées de commande sont les consignes de gı̂te ψref , de tangage θref , de vitesse de lacet
rref et de vitesse ascensionnelle vzref . Vous pouvez accéder aux conditions initiales de chaque
F. BATEMAN 105
Figure 7.3 – Animation 3D du consensus sous SIMULINK 3D
drone en double-cliquant sur le bloc représentant le drone considéré. Notez que les modèles im-
plémentés sont ceux utilisés lors des TP conduits sur l’ARDrone dans la volière en première
année.
Dans ce qui suit, la consigne de vitesse ascensionnelle vzref i du drone i joue le rôle de la com-
mande ui .
Question 27 : Réalisez la commande par consensus et testez-là. Visualisez et enregistrez les chro-
nogrammes des hauteurs et des commandes des drones. Relevez les caractéristiques des régimes
transitoires et comparez-les à ceux établis dans la partie théorique.
Question 28 : Sur des essais successifs, appliquez comme conditions initiales les vecteur propre
associés aux valeurs propres non nulles. Que constatez-vous ? Ce résultat était-il prévisible ? .
Question 29 :Donnez une interprétation qualitative des résultats obtenus en étudiant la structure
du graphe et la manière dont l’information est partagée pour réaliser le consensus.
7.2.2 Cas d’un graphe des liaisons orienté
Question 30 : Pour le graphe des liaisons de la figure 7.4, reprenez l’étude précédente sans refaire
les calculs théoriques. Vous observerez que la matrice L n’est pas symétrique et n’a donc plus les
propriétés de celle obtenue pour un graphe non-orienté. Ceci a évidemment des conséquences que
vous mettrez en évidence sur les simulations que vous ne manquerez pas de réaliser sur le même
modèle que précédemment. Cette fois cependant, la variable sur laquelle le consensus opère pour
le drone i est le cap ψi et la variable de commande est la vitesse de lacet de consigne rref i .
4 3
bc bc
bc bc
1 2
Figure 7.4 – Graphe non orienté décrivant les liaisons entre les drones
106 F. BATEMAN
7.2.3 EXPÉRIMENTATION
L’objet de cette expérimentation est de mettre en œuvre une commande par consensus pour
un essaim constitué de deux drones 1
Vous devrez dans un premier temps réaliser un programme codé sous MATLAB qui restitue
les positions et les vitesses de deux drones.
Dans un second temps, vous testerez les lois de commande étudiées en première année. Vous
pourrez modifier les réglages initiaux des gains pour l’action proportionnelle (kpθ = kpφ = 1)
et dérivée (−kdθ = kpφ = 0.4) en vue d’améliorer les performances dynamiques du drone. A ce
sujet, vous testerez ces commandes sur les deux drones.
Dans un troisième temps, vous mettrez en œuvre une stratégie de commande par consensus
du premier ordre dans le but de réaliser un consensus sur la hauteur.
7.2.4 Estimation de la vitesse du drone
Dans cette partie vous allez, sous MATLAB 2013a, en temps réel, estimer la vitesse du
drone à partir des mesures de position délivrées par QTM. Pour l’utilisation de QTM, vous vous
reporterez au TP 6. Pour ne pas à faire voler le drone, vous rejouerez de manière virtuelle et
répétée un vol précédemment effectué. Les données de position sont émises depuis QTM sur le
réseau et accessibles en temps réel sur les PC qui y sont connectés : Play ❀ Play with real time
output. Le fichier qui rejoue en continu ce vol virtuel est Rejoue Vol.qtm. Il doit être installé
et ouvert depuis le PC qui héberge QTM et qui contrôle le système de capture de mouvement
(MoCap).
Dans le même temps, sur une des machines du laboratoire, ouvrez MATLAB et définissez le
chemin pointant sur le dossier TME TP8. Si le PC utilisé pour QTM et MATLAB est le même,
il faut dans le fichier QMC conf3.txt utiliser le localhost soit choisir l’adresse IP 127.0.0.1, ce
qui est réalisé en supprimant le caractère de commentaire # devant cette adresse IP. Si les deux
PC sont différents, vous devrez utiliser l’adresse IP 192.168.0.2 qui est celle du serveur utilisé
par QTM et qui est hébergé sur le PC qui contrôle le MoCap. Sous le Command Windows de
MATLAB, à l’invite de commande, tapez et exécutez :
>> q= QMC(’QMC conf3.txt’)
Le fichier QMC conf3.txt définit en particulier l’adresse du serveur, le type de données et

le nombre de drones pouvant être traités par MATLAB. La commande : >> data=QMC(q)
renvoie un tableau 6 lignes/4 colonnes, soit les 3 positions en mm et les 3 positions angulaires
de 4 drones identifiés 1,2,3,4. Comme seuls deux drones sont dans l’arène de vol, les autres
coordonnées sont portées à 0. Lorsqu’une coordonnée n’est pas définie, MATLAB renvoie NaN
(Not a Number). On acquiert les positions en temps réel avec SIMULINK depuis le programme
MOCAP Acquisition.slx présenté infra.
1. Les capacités temps réels de SIMULINK d’une part et la taille conséquente des ARDrone ne permettent pas
de faire évoluer de façon satisfaisante plus de deux drones dans l’arène.
F. BATEMAN 107
Figure 7.5 – Acquisition de position et calcul de la vitesse d’un drone sous Simulink
Ce bloc est réalisé par une Embedded Matlab Function. Codez-y un programme qui permet de
calculer les trois composantes de la vitesse des deux drone. Il faut également pouvoir renvoyer un
message à l’écran lorsque le drone n’est plus dans le champ visuel des caméras. Cette fonction
doit renvoyer les coordonnées et les trois composantes de la vitesse du drone qu’il vous faut
calculer dans le repère de l’arène. Elle admet comme arguments les numéros identifiants les
drones (∈ [0, . . . , 3] ) et la variable q associée à la fonction QTM, celle-ci commande l’acquisition
des positions toutes les 30 ms, cette valeur est définie par le Sample Time de la constante associée
à q. A ce sujet, pour le choix de la période d’échantillonnage, les caméras délivrent théoriquement
jusqu’à 100 informations de positions par seconde. Il faut toutefois savoir que l’ARDrone 2 est
contrôlé avec une période d’échantillonnage de 30 ms. Lors de la rédaction du sujet de ce TP,
c’est cette valeur de 30 ms qui a été retenue, toutefois, rien ne vous empêche de conduire des
essais à une cadence plus élevée, dans le but par exemple de traiter les mesures de position au
moyen d’un filtre à réponse impulsionnelle finie (RIF).
f u n c t i o n [ xa , ya , za , vxa , vya , p s i a , xb , yb , zb , vxb , vyb , p s i b ]= f c n ( q , a , b )
c o d e r . e x t r i n s i c ( ’QMC’ )
p e r s i s t e n t xa0 ya0 za0 xa 1 ya 1 z a 1 xb0 yb0 zb0 xb 1 yb 1 zb 1

i f is em p ty ( xa0 )
data=z e r o s ( 6 , 4 ) ;
data = QMC( q ) ;
xa0 = 0 ;
ya0 = 0 ;
za0 = 0 ;
xb0 = 0 ;
yb0 = 0 ;
zb0 = 0 ;
end
data = QMC( q ) ;
% P o s i t i o n s en mètre e t cap en rad

% Drone a
108 F. BATEMAN
xa = 0 . 0 0 1 ∗ data ( 1 , a ) ;
ya = 0 . 0 0 1 ∗ data ( 2 , a ) ;
za = 0 . 0 0 1 ∗ data ( 3 , a ) ;
psia = data ( 6 , a ) ∗ p i / 1 8 0 ;
% Drone b
xb = 0 . 0 0 1 ∗ data ( 1 , b ) ;
yb = 0 . 0 0 1 ∗ data ( 2 , b ) ;
zb = 0 . 0 0 1 ∗ data ( 3 , b ) ;
p s i b = data ( 6 , b ) ∗ p i / 1 8 0 ;
% T es te l a p ré s e n c e d ’ un NaN
i f is em p ty ( f i n d ( i s n a n ( data ( : , a ) ) ) )
% C a l c u l de l a v i t e s s e
% Pas de c a l c u l de l a v i t e s s e p o s s i b l e
else
d i s p ( ’ marche pas ’ )
end
end
Contrôle de la trajectoire simultanée de deux drones
Le contrôle de la trajectoire d’un drone a été étudié en première année. Vous vous reporterez
au TP 6 pour la structure de la loi de commande. Vous testerez successivement chacun des drones
seuls mais ils doivent tout deux être dans l’arène vus par les caméras pour que leurs positions
puissent être calculées. Il faut régulièrement depuis l’invite de commande exécuter des ping pour
s’assurer que les drones sont bien connectés. L’une des raisons aux dysfonctionnements observés
est le faible niveau des batteries ou une mauvaise orientation des repères attachés aux drones
( à ce sujet, vérifiez que les axes du trièdre sont colinéaires aux axes du drone et au besoin,
opérez depuis QTM aux corrections nécessaire). Des diodes Leds sur les batteries permettent
d’évaluer leur niveau de charge. Ouvrez le fichier Control ARDrone Duo et ajoutez-y le fichier
Mocap Acquisition préalablement modifié et testé. Pour ne faire voler qu’un seul des deux drones,
sélectionnez avec la souris le contrôleur et le chart que vous ne voulez pas mettre en vol, cliquez-
droit et validez l’option comment out. Testez séparément les drones puis testez les deux drones
simultanément en vol stationnaire.
Commande par consensus de la hauteur de deux drones
Les ARDrones se prête particulièrement bien à la commande par consensus du premier ordre
lorsque celui porte sur la hauteur h (−z) et le cap ψ. En effet les entrées de commande naturelles
F. BATEMAN 109
Figure 7.6 – Graphe des essaims pour le consensus dans l’arène de vol
d’un l’ARDrone sont la vitesse ascensionnelle w (vzref ) et la vitesse de lacet r, ainsi on peut
écrire :
ḣ = w (7.3)
ψ̇ = r (7.4)
Ces équations ont la même structure que l’équation du modèle d’un agent de l’essaim 7.1,
laquelle a été ensuite utilisée pour étudier la commande par consensus. Dans cette partie, l’étude
expérimentale du consensus se fera sur la hauteur des drones.
Pour réaliser la commande par consensus, il est nécessaire d’amener dans un premier temps
chacun des drones à une hauteur initiale. Cette hauteur initiale sera réalisée par l’asservissement
de hauteur des deux drones initialement implémenté dans le fichier Control ARDrone Duo. Un
système de commutation utilisant des blocs Signal Routing❀Switch doit ensuite permettre
d’activer la commande par consensus.
— Modifiez le schéma du fichier Control ARDrone Duo pour réaliser la commande par
consensus sur la hauteur. La hauteur des drones ne devra pas dépasser 1.5 m. Pour
des hauteurs supérieures, on court le risque que les drones ne soient plus vus par les
caméras. Il vous faut pour cela prévoir :
— Une phase de contrôle des drones les amenant à leur hauteur initiale.
— La commutation sur la commande par consensus.
— La visualisation des données que vous récupèrerez dans le bloc Sinks❀ToWorkspace.
Par défaut, le format sous lequel sont enregistrées les données est de type TimeSerie et
la variable de sauvegarde est nommée simout, vous pouvez évidemment la renommer.
Vous accéderez au signal et au temps en appelant simout.Time et simout.Data
— Il est possible depuis QTM de réaliser en images de synthèse une vidéo des évolutions
des deux drones.
7.3 Consensus du second ordre

Le but dans cette partie est d’opérer à un consensus des drones et de leur faire tenir une for-
mation géométrique au choix parmi celles décrites sur la figure 7.7. Les échanges d’informations
entre les drones se font au sens du graphe des liaisons représenté sur la figure 7.7. Dans le cas
présent, les drones communiquent leur position et leur vitesse.
110 F. BATEMAN
7.3. Consensus du second ordre
Les équations du drone i ∈ {1 . . . N } sont :
ẍi = vi (7.5)
ÿi = wi (7.6)
Comme ce modèle est décrit par des équations différentielles d’ordre deux, le consensus est dit
du second ordre. Pour chaque drone, les coordonnées de sa position (xi , yi ) et de sa vitesse (vxi ,
vyi ) du drone i sont mesurées et ces mesures sont supposées parfaites. Par souci de simplicité
et jusqu’à nouvel ordre, on étudie le mouvement du drone et la loi de commande par consensus
uniquement dans la direction ~x.
Question 31 : Etablissez les équations d’état et d’observation pour un essaim de N = 4 drones.
Vous adopterez t
comme vecteur d’état X = (x1 . . . xn , vx1 . . . vxn ) qu’on notera de façon conden-
sée xt vx t . On notera Y le vecteur des mesures.
7.3.1 Lois de commande

Pour le drone i, la loi de commande par consensus dite du second ordre a pour expression :
n
X
ẍi = − kij (xi − xj ) + ξkij (ẋi − ẋj ) (7.7)
j=1
Xn
ÿi = − kij (yi − yj ) + ξkij (ẏi − ẏj ) (7.8)
j=1
où ξ est un paramètre homogène à un facteur d’amortissement.

Question 32 : Pour le graphe des liaisons de la figure 7.2 et pour le vecteur d’état xt vxt ,
exprimez l’équation d’état des N = 4 drones ainsi commandés. Il est recommandé d’adopter une
notation synthétique en utilisant la matrice laplacienne L définie dans la première partie.
7.3.2 Le consensus
Où l’on montre que les drones, initialement dans des positions quelconques, font consensus,
c-à.d qu’ils se retrouvent tous en un même point de l’espace.
Le calcul des valeurs propres de la matrice d’état montre qu’elle possèdent des valeurs propres
ayant un ordre de multiplicité égal à deux et pour lesquelles les vecteurs propres associés sont
colinéaires. Dans ces conditions, la matrice de passage n’est pas inversible. On peut néanmoins
faire apparaı̂tre les modes propres en opérant à une réduction Jordan de la matrice d’état. On
exprime alors les équations d’état dans la base de Jordan en utilisant les mêmes formules de
changement de base que celles utilisées pour passer dans la base modale. On note ζ le vecteur
d’état dans la base de Jordan.
Question 33 :Avec MATLAB, fonction jordan, calculez pour votre essaim la forme de jordan de
matrice d’état et la matrice de passage afférente.
Question 34 : Exprimez les équations d’état dans la base de Jordan, intégrez-ces équations. Donnez
les expressions des ζi (t) en régime permanent et montrez que les drones font consensus.
F. BATEMAN 111
Question 35 : Pour des conditions initiales x(0) de votre choix et v(0) = 0, calculez numériquement
au moyen de la matrice de passage dans la base de Jordan et des coordonnées de ζ le vecteur
d’état X en régime permanent et concluez sur l’existence d’un consensus.
Question 36 : Sur le fichier Consensus 4 drones.slx de l’essaim réalisé sous SIMULINK, implé-
mentez la commande par consensus au second ordre. La commande −θref i joue ici le rôle de vi
pour le contrôle de xi et φref i joue ici le rôle de vi pour le contrôle de yi . Faites attention à
prendre le signe − qui apparaı̂t dans le contrôle de l’assiette ; vous devrez multiplier par −1 la
commande calculée par consensus avant de l’appliquer à θref i .
7.3.3 Evolution en formation

On ajoute des entrées de consigne en vue de contrôler les écarts entre les drones afin de
réaliser la formation désirée pour le graphe des liaisons donné.
n
X
ẍi = − kij (xi − xj − rij ) + ξkij (ẋi − ẋj ) (7.9)
j=1
Xn
ÿi = − kij (yi − yj − ρij ) + ξkij (ẏi − ẏj ) (7.10)
j=1
où rij (resp. ρij ) est l’écart souhaitée entre les drones i et j selon ~x (resp. ~y. On peut reformuler
ces équations :
n
X
ẍi = − kij (xi − xj ) + ξkij (ẋi − ẋj ) + ri (7.11)
j=1
Xn
ÿi = − kij (yi − yj ) + ξkij (ẏi − ẏj ) + ρi (7.12)
j=1
Pn Pn
où ri = j=1 mij rij et ρi = j=1 mij ρij
Question 37 :Modifiez le modèle sous SIMULINK pour réaliser cette mise en formation. Vérifier
qu’en régime permanent les écarts entre les drones sont ceux désirés.
112 F. BATEMAN
7.4. Formations étudiées
7.4 Formations étudiées

2 2
1 b
1 b
1 1
0 b b
0 b b
4 2 4 2
-1 b
-1 b
3 3
-2 -2
-2 -1 0 1 2 -2 -1 0 1 2
α β
2 2
1 1 b b
4 1
0 b b b b
0
4 3 2 1
-1 -1 b b
3 2
-2 -2
-2 -1 0 1 2 -2 -1 0 1 2
γ δ
Figure 7.7 – Exemple de formation
F. BATEMAN 113
Bibliographie
Bibliographie
[1] Edgar G. Johnson and Alfred O. Nier. Angular aberrations in sector shaped electromagnetic
lenses for focusing beams of charged particles. Physical Review, 91(1), jul 1953.
[2] Matthieu Massonneau. Conception d’un planificateur de trajectoires pour un robot mobile.
[3] Wei Ren and Randal W. Beard. Distributed Consensus in Multi-vehicle Cooperative
Control : Theory and Applications. Springer Publishing Company, Incorporated, 1st edi-
tion, 2007.
[4] Joe Sfeir. Navigation d’un robot mobile en environnement inconnu utilisant les champs de
potentiels artificiels. PhD thesis, École de technologie supérieure, 2009.
[5] Ramon Silva-Ortigoza, Celso Márquez-Sánchez, Fernando Carrizosa-Corral, Victor Ma-
nuel Hernández-Guzmán, Jose Rafael Garcia-Sánchez, Hind Taud, Magdalena Marciano-
Melchor, and Jesus Antonio Alvarez-Cedillo. Obstacle avoidance task for a wheeled mobile
robotâ=
C”a matlab-simulink-based didactic application. MATLAB : Applications for the Prac-
tical Engineer, pages 79–102, 2014.
115

Book TMEAutomatic

Transféré par

Droits d'auteur :

Formats disponibles

Book TMEAutomatic

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Book TMEAutomatic

Transféré par

Droits d'auteur :

Formats disponibles

ÉCOLE DE L’AIR

DÉPARTEMENT DES VÉHICULES AÉROSPATIAUX

TABLE DES MATIÈRES i

I SIMULATION ET PROGRAMMATION SOUS SIMULINK 3

1 RAPPELS SUR LES SIGNAUX ET LES SYSTÈMES 5

3 PROGRAMMATION DES PERIPHERIQUES DU DSPIC 19

1 MODÉLE D’UN DRONE Á VOILURE TOURNANTE 45

1.2 Équations d’état d’un drone à voilure tournante . . . . . . . . . . . . . . . . . . . 45

3 ESTIMATION DE HAUTEUR PAR FILTRAGE DE KALMAN 59

4 CONTRÔLE DE L’ASSIETTE D’UN DRONE À VOILURE TOURNANTE 67

6 CONTRÔLE DE LA TRAJECTOIRE D’UN DRONE 87

7 COMMANDE D’UN ESSAIM DE DRONES PAR CONSENSUS 103

Ce fascicule rassemble l’ensemble des travaux de modélisation et d’expérimentation d’auto-

RAPPELS SUR LES SIGNAUX ET LES SYSTÈMES

1.1 Aspects temporels

1.1.2 Signaux et systèmes à temps continu, discret et hybride

Système échantillonné-bloqué décrit par sa fonction de transfert en Z :

Systèmes continu à commande numérique : On qualifie de système hybride ou mixte un système

— Comment appelle-t-on ce correcteur, quelles performances garantit-il ?

1.1.3 Quantification du signal échantillonné-bloqué

1.2 À propos des nombres sous SIMULINK

1.2.1 Retour sur les signaux et les systèmes à temps discret

2.1 Microcontrôleur DsPic

Les microcontrôleurs de la famille DsPic (Digital Signal Peripheral Interface Controller) de

2.1.1 Caractéristiques du DsPic 30F6014A

On se reportera à la documentation du constructeur sur le site http://microchip.com. On

Parameter Name Value

2.2 Programmation du DsPic sous SIMULINK

2.3 Présentation du blockset Embedded Target Microchip

Figure 2.2 – Librairie du blockset

Le bloc Compiler configuration

Le bloc Port info

Le bloc Simulink Configuration ❀ Compile

a. Tbusy =k cycles machine b.

Fixed step time (solver) Fixed step time (solver)

Fixed step time (solver) Fixed step time (solver)

Figure 2.3 – Le temps sous SIMULINK

2.4 Premier exemple

2.4.1 Schéma de simulation

2.4.2 Schéma de programmation et compilation

2.4.3 Programmation du DsPic

2.4.4 Visualisation du temps de calcul du microcontrôleur

PROGRAMMATION DES PERIPHERIQUES DU DSPIC

3.1 Les ports numériques

avec une bascule D a pour équation :

3.2 Les UART

3.2.1 Le protocole de liaison série RS232

Figure 3.1 – Une liaison série

Figure 3.2 – La trame d’une liaison série

Figure 3.3 – Connecteur DB9

3.2.2 Programmation des UARTs du DsPic

RF2 (UART1 RX) RF3 (UART1 TX)

Transmission de données par port série RS232

Figure 3.4 – Le menu du programme Realterm

Réception-Emission de données 2 Modifiez ce programme de sorte que seul le caractère ASCII

3.2.3 Visualisation des signaux

ces données sous MATLAB.

3.3 Le bus SPI