Aaaa

Abonnez-vous à DeepL Pro pour traduire des fichiers plus volumineux. Visitez pour en savoir plus.
Guide pratique : Blockset Simulink2.0 pour

ArduPilot
Fran¸cois Hugon
Robert F. Hartley
Brian DeRosa
Gulfstream Aerospace Corporation
Embry-Riddle Aeronautical
University Savannah, Géorgie
Christopher Carvalho
Embry-Riddle Aeronautical
University Daytona Beach, Floride
Novembre 2,2012
Remerciements
Merci à nos épouses et à nos proches - Sara, Laura, Bailey et Lauren - qui ont
supporté patiemment les longues nuits, les corvées négligées et qui ont été nos
plus grands soutiens pour réussir cette aventure.
Merci à Brian DeRosa de nous avoir permis de prendre possession de sa
maison et de transformer sa table de salle à manger en hangar.
Merci à George Hicks, pilote radio-commandé de renommée mondiale,
pour avoir été notre pilote de sécurité, pour avoir été une grande source de
conseils et d'astuces pour les avions radio-commandés, pour avoir toujours eu
les pièces dont nous avions besoin, y compris des cellules entières, et pour
avoir toujours été prêt à voler sans préavis.
Merci à Richard Ruff de Mathworks pour son expertise technique et ses
conseils lors du développement de l'APM2 Blockset.
Résumé
Dans le cadre du développement d'un nouveau cours de troisième cycle sur le

guidage, la navigation et le contrôle à l'Embry-Riddle Aeronautical University,
un blockset Simulink a été développé pour permettre aux étudiants de
travailler uniquement dans Matlab/Simulink pour le développementdu code GNC. Ce
code peut être téléchargé directement sur l'ArduPilot.
2.0 un ensemble intégré de capteurs et de traitement permettant aux étudiants
de développerfacilement desvéhicules aériens sans pilote. Le blockset est utile dans
la mesure où il élimine la nécessité d'avoir un programmeur compétent et un
ingénieur électricien compétent pour intégrer le matériel et le logiciel à la
cellule. Ce guide a pour but de décrire la fonctionnalité du blockset, de fournir
des recommandations sur la façon d'implémenter les conceptions de contrôle,
et des étapes sur la façon d'intégrer le code sur l'ArduPilot directement à partir
de Simulink. Le blockset n'en est qu'au début de son développement et peut
encore être amélioré ; il est prévu que les futurs étudiants ou la communauté
universitaire dans son ensemble fassent progresser les capacités à l'avenir.
Contenu
1 Introduction 7
2 Configuration et utilisation 8
2.1 Matlab...................................................................................................8
2.2 Paramètres de configuration Simulink..................................................8
2.3 Matériel Run On Target........................................................................9
2.4 Répertoire des noyaux cibles Arduino..................................................9
2.5 Fichier IOWrappers.cpp............................................................................9
2.6 Chemin Simulink..................................................................................9
2.7 S-Function Build...................................................................................9
2.8 Téléchargement d'un modèle...................................................................10
3 2.0Blocs de la bibliothèque ArduPilot Mega 11
3.1 Blocs de capteurs.....................................................................................11
3.1.1 Unité de mesure inertielle.......................................................11
3.1.2 Capteur de pression barométrique...........................................12
3.1.3 Magnétomètre..............................................................................14
3.1.4 GPS..........................................................................................15
3.1.5 Sonde de Pitot.........................................................................19
3.2 Entrée récepteur / Sortie servo...................................................20
3.2.1 RC Read..................................................................................20
3.2.2 Écriture RC..............................................................................21
3.3 Timing..................................................................................................... 22
3.3.1 Horloge........................................................................................22
3.3.2 Moniteur en temps réel...........................................................22
3.4 Sortie de données............................................................................23
3.4.1 Télémétrie...................................................................................23
3.4.2 Sortie USB...............................................................................25
3.4.3 Puce de mémoire flash................................................................25
3.4.4 Téléchargement des données.......................................................26
3.5 Autres blocs divers..................................................................................27
3.5.1 Entrée discrète.........................................................................27
3.5.2 Sortie discrète..........................................................................29
3.5.3 LED Bleu.....................................................................................29
1
3.5.4 LED jaune...................................................................................29
3.5.5 LED rouge...................................................................................29
3.5.6 Entrée analogique........................................................................30
3.5.7 Sortie analogique.....................................................................30
3.5.8 Lecture en série...........................................................................30
3.5.9 Conversion d'un flotteur en uint8............................................30
4 Exemples 32
4.1 Exemple de base......................................................................................32
4.2 Exemple d'IMU et de sortie de données.............................................33
4.3 Exemple de capteurs................................................................................33
4.4 Téléchargement d'un modèle...................................................................35
4.5 Les prochaines étapes.........................................................................35
5 Architecture du jeu de blocs Simulink 36
5.1 Base de code C/C++ d'APM...............................................................36
5.2 Niveau S-Fonction2.................................................................................39
5.3 Compilateur du langage cible..................................................................39
6 Travaux futurs 42
6.1 Travaux futurs.....................................................................................42
7 Soutien 44
2
Liste des figures
3.1 Bloc et masque IMU................................................................................12

3.2 Bloc de pression barométrique............................................................14
3.3 Bloc et masque magnétométriques.....................................................16
3.4 Bloc et masque GPS............................................................................17
3.5 Bloc de capteurs de pression différentielle..............................................19
3.6 RC Bloc de lecture et masque.............................................................20
3.7 RC Bloc et masque d'écriture..............................................................21
3.8 Bloc d'horloge et masque.........................................................................22
3.9 Bloc et masque du moniteur en temps réel.........................................23
3.10 Bloc et masque de l'impression série des flottants.............................24
3.11 Bloc et masque de mémoire flash............................................................26
3.12 Menu d'interaction avec la mémoire flash - sans données.................27
3.13 Menu d'interaction avec la mémoire flash - avec données.................28
4.1 Modèle Simulink de base utilisant des blocs RC....................................32

4.2 Sortie des mesures IMU sur le port série............................................33
4.3 Modèle Simulink utilisant tous les blocs de capteurs, de synchronisation et de
mémoire flash. 34
5.1 Simulink2.0
ArduPilotMega.........................................................................................37
3
Liste des tableaux
2.1Dossiersà ajouter au chemin de Matlab....................................10
3.1 Bloc IMU 6-DOF, entrées.......................................................................13

3.2 Bloc IMU 6-DOF, Sorties.......................................................................13
3.3 Bloc du capteur barométrique, entrées...............................................14
3.4 Bloc du capteur barométrique, sorties................................................14
3.5 Bloc magnétomètre, entrées................................................................16
3.6 Bloc magnétomètre, sorties.................................................................17
3.7 Bloc GPS, Entrées...............................................................................18
3.8 Bloc GPS, Sorties................................................................................18
3.9 Bloc de la sonde de Pitot, entrée........................................................19
3.10 Bloc de la sonde de Pitot, sortie.........................................................19
3.11 Bloc de lecture RC, entrées.....................................................................20
3.12 Bloc de lecture RC, sorties.................................................................21
3.13 Bloc d'écriture RC, entrées......................................................................21
3.14 Bloc d'écriture RC, sorties..............................................................22
3.15 Bloc d'horloge, sortie..........................................................................23
3.16 Bloc moniteur en temps réel, sortie....................................................23
3.17 Bloc d'impression série des flottants, entrée......................................25
3.18 Bloc d'écriture en série, entrée................................................................25
3.19 Écriture d'un bloc de tableau flottant, entrée......................................26
3.20 Écriture d'un bloc de tableau flottant, sortie.......................................26
3.21 Bloc d'entrées discrètes, sortie............................................................28
3.22 Bloc de sorties discrètes, entrée..........................................................29
3.23 Bloc LED bleu, entrée.............................................................................29
3.24 Bloc jaune LED, entrée...........................................................................29
3.25 Bloc de LED rouge, entrée......................................................................29
3.26 Bloc d'entrée analogique, sortie..........................................................30
3.27 Bloc de sortie analogique, entrée........................................................30
3.28 Bloc de lecture en série, sortie............................................................30
3.29 Bloc de conversion de flottant en UINT8, entrée...............................31
3.30 Bloc de conversion de flottant en UINT8, sortie................................31
4
Nomenclature
bx Intensité du champ magnétique sur l'axe x du corps

by Intensité du champ magnétique sur l'axe y du
corps bz Intensité du champ magnétique sur l'axe z du
corps n xAccélération sur l'axe x du corps
ny Accélération le long de l'axe y du
corps n zAccélération le long de l'axe z
du corps pRoll Rate, deg/sec
q Taux de tangage, deg/sec
r Vitesse de lacet,
deg/sec
A/DAnalogiqueà
numérique APM1
ArduPilot Mega APM21.0
ArduPilot Mega
CGCentre2.0 de
gravité
ERAU Embry-Riddle Aeronautical University
GACGulfstreamAerospace
Corporation GPSSystème de positionnement
mondial
2
ICInter -Circuit intégré
I/OInput/Output
IDEIntegratedDevelopment
Environment (environnement de
5
développementintégré)
IMUInertialMeasurement Unit
(unité de mesure inertielle
LEDDiode électroluminescente
6
MbMegabyte
MEMS Système micro-électro-mécanique
MHzMegahertz
MIMO entrées multiples sorties multiples
msmilliseconds
NVM Mémoire non volatile
PWM Modulation de largeur
d'impulsion QFNQuadFlat No-
Leads
RCRemoteControl
ROTH Run On Target Hardware
SISOSingleInput Single
Output SPISerialPeripheral
Interface TMTelemetry
UAVUnmanned Aerial
Vehicle UINTEntier non signé
USBBus sériel universel
Temps universel coordonné (UTCCoordinatedUniversal Time), également
connu sous le nom de "temps zoulou".
7
Chapitre 1
Introduction
L'ArduPilot 2.0 est un produit prêt à l'emploi qui intègre une suite de capteurs
avec un processeur Atmega 2560 pour une utilisation en tant que pilote
automatique. Ce document décrit comment utiliser le blockset Simulink qui a
été développé pour ce produit, et décrit comment un modèle Simulink unique
peut être développé et intégré directement à l'ArduPilot 2.0. Ce modèle
comprendra le code nécessaire à la lecture des capteurs, à la lecture des
signaux PWM de l'émetteur RC, à la sortie des signaux PWM pour contrôler
les servos et un moteur, à la sortie des données vers un système de télémétrie
et à l'enregistrement des données sur une puce mémoire flash.
8
Chapitre 2
Configuration et utilisation
2.1 Matlab
Pour que les modèles Simulink puissent être intégrés au matériel cible,
l'utilisateur doit avoir accès à une version 2012a ou plus récente de Matlab. À
partir de la version 2012a, Mathworks a inclus une fonction Run On Target
Hardware (ROTH) qui remplit essentiellement la même fonction que le codeur
embarqué, mais le code compilé réel n'est pas visible par l'utilisateur. ROTH
est inclus dans la licence standard de Simulink, mais il convient de noter,
cependant, que ROTH ne fonctionne actuellement que sous Windows.
Mathworks a indiqué qu'il fonctionnera éventuellement sous Linux ou sur un
Mac, mais au moment de la publication de ce document, cette capacité n'a pas
été mise en œuvre.
Un compilateur supporté doit également être installé. Le document d'aide
de Matlab donne des indications sur les compilateurs pris en charge et sur la
manière de les faire reconnajtre par Matlab [6].
2.2 Paramètres de configuration Simulink

Le modèle réel qui est intégré dans l'ArduPilot doit avoir certains paramètres
de configuration définis. Le modèle doit avoir les paramètres suivants :
• Type : Étape fixe
- Pas de temps : Il s'agit du temps de trame de votre carte, qui doit donc
être déterminé de manière à ce que la carte fonctionne en temps réel.
Utilisez les blocs de timing, comme décrit dans la section 3.3pour vous
aider à déterminer le temps de calcul de votre code.
• Solveur : Discret (pas d'états continus)
• Implémentation matérielle -> Fournisseur du dispositif : Atmel
9
2.3 Matériel Run On Target
La première fois que ROTH est utilisé, le logiciel cible réel doit être installé.
Comme il s'agit d'un ArduPilot, avec une puce Arduino Mega 2560,
l'utilisateur doit installer le matériel cible Arduino. Pour ce faire, à partir de
Simulink, sélectionnez le menu Tools, puis Run On Target Hardware, et enfin
Install Target. Sélectionnez Arduino. Simulink installera la cible dans
l'emplacement suivant : C:/MATLAB-
/Targets/R2012b.
2.4 Répertoire des noyaux cibles Arduino

L'IDE Arduino est inclus dans l'installation de la cible. L'IDE comprend un
dossier de fichiers standard pour la compilation du code. Ces fichiers ont dû être
modifiés pour le Simulink Blockset. Le chemin du dossier est
C:/MATLAB/Targets/R2012b-
/arduino-1.0/hardware/arduino/cores /arduino.
Ce guide d'utilisation comprend un nouveau dossier cores/arduino, qui
remplacera le dossier par défaut. Il est recommandé de sauvegarder le dossier
par défaut avec un nom de fichier modifié (c'est-à-dire arduino default), dans
le cas où l'IDE Arduino brut doit être utilisé.
2.5 Fichier IOWrappers.cpp

Il y a deux fichiers inclus dans le téléchargement de la cible qui doivent être
modifiés. Ces fichiers pourront éventuellement être supprimés au fur et à mesure
des améliorations apportées à ce blockset. Cependant, à l'heure actuelle, des
modifications doivent être apportées à ces fichiers pour éviter les erreurs de
compilation. Les deux fichiers sont src/io wrapper.cpp et include/io
wrapper.h, dans le répertoire C:/MATLAB/Targets/R2012b/arduino. Pour les
deux fichiers, l'utilisateur doit simplement ajouter la ligne #if 0 avant tout
code, et ajouter la ligne #endif à la dernière ligne des fichiers. Il est
recommandé de sauvegarder des copies de sauvegarde des fichiers originaux, ou
au moins de commenter les nouvelles lignes à
indiquent qu'il s'agit de modifications par rapport au fichier d'origine.
2.6 Chemin Simulink

Les dossiers indiqués dans le tableau doivent2.1 être ajoutés au chemin d'accès à Matlab.
2.7 S-Function Build

L'étape finale de la configuration consiste à compiler le code pour les blocs
Simulink. Un script Matlab a été inclus pour faire cela. Il suffit de naviguer
dans le dossier APM2 pour le répertoire Matlab et d'exécuter le fichier
ArduinoBuildMexFiles.m. Le script appelle les fichiers dans la structure du
répertoire à partir de cet emplacement de dossier. Il convient de noter qu'un
compilateur compatible avec Matlab est nécessaire pour que cela fonctionne.
1
Une liste des compilateurs supportés par Matlab est fournie dans la référence
[6].
1
Blocs
ArduPilot/AP
M2 Arduino
Analog IO
Auxiliaire
Baro
DataTypeConversions
Discrete IO
FlashMemory
GPS
IMU
Magnétomètre
Pitot
RCChannels
Série
Timing
Tableau 2.1 : Dossiers à ajouter au chemin de Matlab
2.8 Téléchargement d'un modèle

Une fois que l'environnement a été configuré comme décrit ci-dessus et qu'un
modèle Simulink a été construit et testé en simulation (voir le chapitre 4 pour
des exemples de modèles à utiliser), le téléchargement du modèle vers le
matériel APM2 est une tâche simple. Tout d'abord, connectez l'APM2 à
l'ordinateur à l'aide d'un câble mini-USB. Cela permettra à la carte de
s'allumer ; cependant, le bus USB n'alimente pas les servos, donc ne vous
inquiétez pas si les servos semblent inopérants. A partir du modèle Simulink,
sélectionnez le menu Tools, puis le menu Run On Target Hardware. Si c'est la
première fois que le modèle est téléchargé sur l'APM2, ROTH devra préparer
le modèle pour le téléchargement. Sélectionnez le menu Prepare, qui ouvrira
la fenêtre Configuration Parameters. Utilisez simplement les paramètres par
défaut (y compris le débit en bauds9600 pour les ports série).
Une fois les paramètres de configuration ROTH définis, naviguez dans les
mêmes menus ROTH, puis sélectionnez Run. Simulink commencera le
processus automatique de génération du code d'exécution, de compilation de
l'exécutable et de téléchargement vers l'APM2. Le processus peut prendre plus
d'une minute pour les modèles plus complexes et le succès sera indiqué dans
la zone de la barre d'état de la fenêtre du modèle Simulink.
1
Chapitre 3
Blocs de la bibliothèque
ArduPilot Mega 2.0
3.1 Blocs de capteurs

3.1.1 Unité de mesure inertielle
L'InvenSense MPU-6000 est un dispositif MEMS qui incorpore un céleromètre à
3 axes et un gyroscope à 3 axes dans un minuscule bojtier QFN de 4x4x0,9 mm.
Ce dispositif numérique contient un convertisseur A/N 16 bits qui permet une
résolution très fine des paramètres inertiels. De plus, comme la puce se charge de
la conversion analogique-numérique, l'intégration dans le modèle utilisateur est
simplement une question de mise à l'échelle d'un nombre entier. Le dispositif
communique avec le microprocesseur via le bus d'interface périphérique commun
de la carte, SPI.
Pour éviter l'anticrénelage, la puce dispose de filtres passe-bas numériques
intégrés avec des fréquences de coupure sélectionnables par l'utilisateur. Il
s'agit d'un avantage majeur car il permet une utilisation avec un processus plus
lent sans matériel supplé±m±entaire. L'accéléromètre a une portée
maximale de 16g, tandis que les gyroscopes ont une portée maximale de
deg/sec2000. La température, en degrés Celsius par rapport au jour standard,
est également disponible.
Le dispositif dispose également d'un auto-test intégré qui est utilisé par le
micrologiciel de la carte pour évaluer la santé de l'unité au démarrage. Plus
d'informations concernant ce dispositif peuvent être trouvées à la référence
[5].
Le bloc IMU dispose de trois options que l'utilisateur doit sélectionner
dans le masque du bloc IMU. Tout d'abord, la fréquence du filtre passe-bas
doit être fixée à la moitié ou moins de la fréquence d'échantillonnage de base.
La plage des gyroscopes et des accéléromètres doit également être définie.
Enfin, le temps d'échantillonnage doit correspondre au temps
d'échantillonnage global de l'ArduPilot. La figure montre3.1 le bloc IMU et le
masque.
Les entrées du bloc sont simplement les valeurs simulées de chacune des
accélérations et des vitesses angulaires ainsi que de la température, qui sont
1
détaillées dans le tableau ci-dessous.
3.1. Ces données passent par le bloc en simulation et ne sont pas utilisées
lorsque le modèle est intégré à l'APM2.
1
de la centrale de mesure inertielle, dont chacune est détaillée dans le Tableau
3.2.
Figure 3.1 : Bloc et masque IMU
Calibration Dans les coulisses, l'ArduPilot va calibrer l'IMU au

démarrage. L'avion doit être laissé à l'horizontale et immobile pendant la mise
sous tension jusqu'à ce que la carte abandonne le contrôle à l'émetteur du
pilote. Toute perturbation pendant la routine de calibration pourrait entrajner
des mesures d'accélération et de vitesse angulaire inexactes.
3.1.2 Capteur de pression barométrique

Le MS5611 de MEAS Switzerland est un appareil numérique de petite taille
qui contient un impressionnant CAN de 24 bits calibré en usine. La puce a
nécessité très peu de configuration autre que la définition des taux de bus de
données et était capable de fournir une pression statique si précise que
l'altitude de l'avion pouvait être déterminée à quelques centimètres près. Le
taux de mise à jour du capteur est de Hz75.
1
Port n°. Étiquette Unité Description
s
1 p (sim) deg/s Valeur simulée du taux de roulis
de la carrosserie
2 q (sim) deg/s Valeur simulée de l'inclinaison
du corps
taux
3 r (sim) deg/s Valeur simulée de la vitesse de
lacet du corps
4 nx (sim) g Valeur simulée de l'axe x du
corps
composante de l'accélération
5 ny (sim) g Valeur simulée de l'axe y du
corps
6 nz (sim) g Valeur simulée de l'axe z du
corps
7 Température (sim) degC Valeur simulée de la températura
ture de l'IMU
Tableau 3.1 : Bloc IMU 6-DOF, entrées

s
1 p deg/s Taux de roulis de la carrosserie
2 q deg/s Taux de tangage du corps
3 r deg/s Vitesse de lacet du corps
4 nx g Composante de l'axe x du corps
de l'accel-
eration
5 ny g Composante de l'axe y du corps
de l'accel-
eration
6 nz g Composante de l'axe z du corps
de l'accel-
eration
1
7 Température degC Température de l'IMU
Tableau 3.2 : Bloc IMU 6-DOF, sorties
1
Pour plus d'informations concernant ce dispositif, voir la référence [11].
Les entrées de ce bloc sont simplement les valeurs simulées de la pression
statique et de la température, qui sont détaillées dans le tableau suivant 3.3.
Ces valeurs passent par le bloc en simulation et ne sont pas utilisées lorsque le
modèle est intégré à l'APM2. Les sorties du bloc sont les valeurs mesurées de
la pression statique et de la température, détaillées dans le Tableau . 3.4.
Figure 3.2 : Bloc de pression barométrique

Le bloc de capteurs barométriques fournit la pression barométrique
locale. Il fournit également la température ambiante.
Port n°. Étiquette Unités Description

1 Pression statique inHg Valeur simulée de l'atmo-
(sim)
pression statique sphérique
2 Température (sim) degC Valeur simulée de l'atmo-
température sphérique
Tableau 3.3 : Bloc du capteur barométrique, entrées
Port n°. Étiquette Unités Description

1 Pression inHg Pression statique atmosphérique
statique
2 Température degC Température atmosphérique
Tableau 3.4 : Bloc du capteur barométrique, sorties
3.1.3 Magnétomètre
Le magnétomètre numérique à 3 axes Honeywell HMC5843 mesure l'intensité
du champ magnétique dans chacun des trois axes de l'appareil. Comme l'IMU,
il s'agit d'un dispositif numérique qui communique avec le microprocesseur
par l'intermédiaire d'un bus série à haute vitesse. Comme l'IMU, il possède
des fonctions d'auto-test qui sont excitées lors du démarrage de la carte afin de
calibrer l'unité à un offset induit connu.
1
Comme le champ terrestre est très faible, le magnétomètre est
extrêmement sensible. Si cela est bon pour la résolution, cela signifie
également que l'appareil est très sensible au bruit électromagnétique et aux
biais constants dus aux matériaux conducteurs locaux à proximité du capteur.
Le moteur, avec ses aimants en rotation et son important champ magnétique
induit, dégrade encore les performances de l'appareil en fonction de la vitesse du
moteur. Ces problèmes sont aggravés par l'obligation d'installer l'APM2 près
du centre de gravité - et donc près de l'axe de rotation du moteur.
afin de réduire les effets de la localisation inertielle. Un magnétomètre à circuit
2
intégré situé à distance qui se connecte au port de circuit intégré externe 2 de
l'APM2 est une option.
pour améliorer ce problème, mais n'a pas fait l'objet de recherches pour ce
projet ni d'un bloc Simulink créé dans le cadre du blockset APM2.
Pour calibrer le champ magnétique local, la référence [10] a été utilisée
pour obtenir l'intensité totale connue du champ magnétique pour un
emplacement donné. Ensuite, l'avion a été configuré pour enregistrer les trois
composantes du champ pendant que la cellule était tournée dans toutes les
positions possibles dans une zone exempte d'interférences et de gros objets
métalliques. Une fois les données téléchargées, une routine de minimisation
non linéaire telle que fmincon ou fminsearch de Matlab a été utilisée
pour trouver le
vecteur, C, qui minimise la fonction de coût suivante,
(
J 2
J = BT - Kbx(b x+ Ox) 2+ Kby(by + Oy) 2+ Kbz(bz + Oz)2 (3.1)
où,
Kbx
Kb
C= y
Kbz
Ox
Oy
Oz
et BT était l'intensité totale connue du champ.
Une fois le vecteur, C, déterminé, il a été entré directement dans le masque
du bloc magnétométrique, comme le montre la figure, et3.3 a donc été
appliqué à toutes les mesures en sortie du bloc.
Il convient de noter qu'une logique supplémentaire doit être insérée pour
tenir compte des décalages dy- namiques introduits par le moteur. Ce blockset
est destiné à reproduire les mesures brutes du capteur, donc tout effet sur le
moteur devra être traité séparément par l'utilisateur.
Les entrées du bloc sont simplement les valeurs simulées des composantes
du champ magnétique, qui sont détaillées dans le tableau ci-dessous. 3.5. Ces
valeurs passent par le bloc en simulation et ne sont pas utilisées lorsque le
modèle est intégré à l'APM2. Les sorties du bloc sont les champs magnétiques
mesurés, détaillés dans le Tableau . 3.6.
3.1.4 GPS
Le récepteur 10GPS MediaTek MT3329 Hz comprend un récepteur GPS, un
processeur et une antenne patch, le tout dans un très petit bojtier. Il
communique
1
Figure 3.3 : Bloc et masque du magnétomètre

s
1 bx, nT (sim) nT Valeur simulée du magnétisme
champ, composante de l'axe x du
corps
2 par, nT (sim) nT Valeur simulée du magnétisme
champ, composante de l'axe y du
corps
3 bz, nT (sim) nT Valeur simulée du magnétisme
champ, composante de l'axe du
corps z
Tableau 3.5 : Bloc magnétomètre, entrées
2
Port n°. Étiquett Unité Description
e s
1 bx, nT nT Champ magnétique, axe x du corps
com-
ponent
2 par, nT nT Champ magnétique, axe y du corps
com-
ponent
3 bz, nT nT Champ magnétique, axe du corps z
com-
ponent
Tableau 3.6 : Bloc magnétomètre, sorties
avec le microprocesseur AT Mega via une liaison série standard RS-232.

Les entrées de ce bloc sont simplement les valeurs simulées des mesures GPS,
qui sont détaillées dans le tableau suivant 3.7. Ces valeurs passent par le bloc en
simulation, et ne sont pas utilisées lorsque le modèle est intégré à l'APM2. Les
sorties du bloc sont les paramètres GPS mesurés, détaillés dans le Tableau . 3.8.
La sortie Fix Type du bloc GPS est une simple représentation numérique de l'état
de l'unité GPS. Une valeur de zéro indique qu'aucun dispositif GPS n'est
disponible pour le processeur. Cela ne devrait jamais être vu, et si c'est le cas,
cela indique presque certainement une défaillance matérielle. Une valeur de un
indique que le processeur et l'unité GPS communiquent normalement mais que le
GPS n'a pas encore de verrou. Inversement, une valeur de deux signifie que le
GPS a acquis un verrouillage 3D sur la position de l'unité et est prêt pour la
navigation. Le bloc va également
allumer en permanence la LED bleue lorsqu'elle est verrouillée.
Il convient de noter que l'heure et la date sont basées sur l'UTC, l'heure
étant exprimée en millisecondes après minuit. La figure 3.4 présente le bloc et
le masque GPS.
Figure 3.4 : Bloc et masque GPS
2
1Latitude(sim) deg Simulé valeur de lati-
Numéro
tude deport
LabelUnitsDescription
2Longitude(sim) deg Simulé valeur de la
longévité
tude
3Altitude(sim) ft Simulé valeur de l'alti-
tude
4 au sol(sim) ft/sec Valeur simulée du sol
vitesse
5 au sol(sim) deg Valeur simulée du sol
cours
6Nombrede satellites - Valeur simulée du num-
(sim)
Nombre de satellites
utilisés pour
GPS
7 fixation(sim) - Valeur simulée du type de
fixation
comme décrit ci-dessus
8 UTC(sim) chajn Valeur simulée de l'UTC
e de
caract
ères
Date
9 UTC(sim) ms Valeur simulée de l'UTC
temps
10HDOP(sim) ft Valeur simulée de hori-
dilution horizontale de la précision
Tableau 3.7 : Bloc GPS, entrées

s
1 Latitude deg Valeur de la latitude
2 Longitude deg Valeur de la longitude
3 Altitude ft Valeur de l'altitude
4 Vitesse au sol ft/sec Valeur de la vitesse sol
5 Cours de base deg Valeur du terrain
6 Nombre de - Valeur du nombre de satel-
satellites
lites utilisées pour le GPS
7 Type de fixation - Valeur du type de fixation
comme de-
2
inscrite ci-dessus
8 Date UTC chajn Valeur de la date UTC
e de
caract
ères
9 Heure UTC ms Valeur du temps UTC
10 HDOP ft Valeur de la dilution
horizontale
tion de la précision
Tableau 3.8 : Bloc GPS, sorties
2
3.1.5 Sonde de Pitot
La mesure de la vitesse de l'air est un paramètre très important pour
l'estimation de l'état et le contrôle. L'APM2, cependant, ne comprend pas de
moyen de mesurer la vitesse de l'air. Par conséquent, une sonde pitot
miniature a été installée dans le nez de l'avion pour mesurer la pression
d'impact à l'emplacement de la sonde. Les ports de la sonde ont été connectés
à un capteur de pression différentielle Freescale MPXV7002DP. Le capteur a
ensuite été connecté à l'APM2 via l'un des jeux de broches d'entrée
analogique. Ce capteur était le seul capteur analogique à bord de l'avion et
devait être calibré en utilisant un champ d'écoulement connu. Une fois calibré,
la sortie de ce capteur était une tension proportionnelle à la pression
dynamique et ce signal était utilisé pour calculer la vitesse aérodynamique
réelle.
Un comportement curieux concernant cette sonde était sa performance
atroce à basse vitesse. Par exemple, lorsque l'avion était à l'arrêt, il était
courant de voir la sonde Pitot rapporter un bruit très élevé de 20
pieds/seconde. Heureusement, la précision de l'appareil s'est améliorée et le
bruit a diminué lorsque la pression dynamique a augmenté.
L'entrée du bloc est simplement les valeurs simulées de la pression
dynamique, qui sont détaillées dans le tableau suivant 3.9. Cette valeur est
transmise par le bloc en simulation et n'est pas utilisée lorsque le modèle est
intégré à l'APM2. La sortie du bloc est la pression dynamique mesurée par la
sonde de Pitot et le capteur de pression différentielle, comme indiqué dans le
tableau. 3.8.
Figure 3.5 : Bloc du capteur de pression différentielle
Numéro deport
1 P dyn (sim) psfValeur simulée de la pres-
dynamique
sûr
Tableau 3.9 : Bloc de la sonde de Pitot, entrée
Numéro deport
1 P dyn (sim)psfPression dynamique
2
Tableau 3.10 : Bloc de la sonde de Pitot, sortie
2
3.2 Entrée récepteur / Sortie servo
3.2.1 RC Read
Le bloc RC Read lit les signaux PWM connectés aux canaux RC Input de l'APM.
Ces entrées sont généralement les sorties du récepteur RC. Les signaux PWM
sont exprimés en microsecondes de largeur d'impulsion. La figure 3.6 montre le
bloc et le masque de lecture RC. Les tableaux 3.11 et 3.12 détaillent les entrées
et les sorties du bloc RC Read.
Figure 3.6 : Bloc et masque de lecture RC

s
1 Ch (1sim) µs Valeur simulée de canal 1
Signal PWM
Signal PWM
Signal PWM
Signal PWM
Signal PWM
Signal PWM
Signal PWM
Signal PWM
Tableau 3.11 : Bloc de lecture RC, entrées
2
Port n°. Étiquet Unité Description
te s
1 Ch 1 µs Valeur du signal PWM1 du canal
Tableau 3.12 : Bloc de lecture RC, sorties
3.2.2 Écriture RC
Le bloc RC Write émet des signaux PWM vers les canaux de sortie de l'APM
qui sont généralement connectés aux servos. Les signaux PWM sont en
microsecondes de largeur d'impulsion. La figure 3.7 montre le bloc RC Write
et le masque. Tableau
3.13 et le tableau détaillent3.14 les entrées et les sorties du bloc RC Write.
Figure 3.7 : Bloc et masque d'écriture RC
Port n°. Étiquet Unité Description

te s
Tableau 3.13 : Bloc d'écriture RC, entrées
2
s
Signal PWM
Signal PWM
Signal PWM
Signal PWM
Signal PWM
Signal PWM
Signal PWM
Signal PWM
Tableau 3.14 : Bloc d'écriture RC, sorties
3.3 Timing
3.3.1 Horloge
Le bloc horloge fournit le temps, en millisecondes, depuis la mise sous tension
de la carte. Il est exécuté à chaque pas de temps. La figure 3.8 montre le bloc
et le masque de l'horloge. Le tableau détaille3.15 les sorties du bloc Clock.
Figure 3.8 : Bloc d'horloge et masque
3.3.2 Moniteur en temps réel

Le bloc de surveillance en temps réel émet une valeur booléenne qui est vraie
si la carte effectue tous ses calculs dans le délai spécifié. Ce bloc
2
s
1 Temps écoulé ms Temps écoulé depuis que la
carte a été mise sous tension
Tableau 3.15 : Bloc d'horloge, sortie
est utile pour déterminer si le code est trop complexe ou si la fréquence de la

carte est trop élevée. La figure 3.9 montre le bloc et le masque du moniteur en
temps réel. Le tableau 3.16 détaille les sorties du bloc Real Time Monitor.
Figure 3.9 : Bloc et masque du moniteur en temps réel

Le bloc de surveillance en temps réel émet une valeur booléenne qui est
vraie si la carte effectue tous ses calculs dans le délai spécifié. Ce bloc est très
utile comme indicateur que le code est trop complexe pour le temps
d'échantillonnage spécifié.
Port n°. Étiquette UnitsDescription

1 En temps -Vrai si le conseil fonctionne en temps
réel ? réel
Tableau 3.16 : Bloc moniteur en temps réel, sortie
3.4 Sortie de données

3.4.1 Télémétrie
Il existe des blocs2 qui peuvent être utilisés pour transmettre des données
au sol à l'aide de l'émetteur-récepteur XBee. Le premier fournira un flux de
données lisibles qui
2
peuvent être affichées à l'aide d'une interface de terminal. La deuxième
méthode fournit les données brutes, non codées et binaires, qui peuvent être
post-traitées au sol. Ceci est utile pour un protocole de station au sol qui peut
lire les données brutes et les analyser de manière appropriée pour le protocole
de la station au sol.
Impression en série des flottants

Afin de sortir les données dans un format simple et lisible, un bloc Serial Print
Floats a été créé. La figure montre3.10 le bloc Serial Print Floats et le
masque.
Figure 3.10 : Bloc et masque de l'impression série des flottants

Le bloc Serial Print Floats prend un tableau (mux) de valeurs à virgule
flottante et le sort sur un bus série afin qu'il puisse être lu et affiché sous
forme de texte dans une interface de terminal telle que Putty. Ceci est très
utile pour le débogage ou pour servir de simple station de base. Le port série
souhaité peut être sélectionné dans le masque, tout comme la vitesse de
transmission. En général, un débit en bauds de ou57,600 produit des données
115,200fiables à des vitesses raisonnables. Notez que plus la vitesse de
transmission est lente, plus le bloc prend du temps pour écrire les données, ce
qui peut avoir un effet négatif sur le temps de trame du système.
Par défaut, l'ArduPilot a le port série USB connecté au même port série
qui est utilisé par le XBee. Cela n'a d'importance que si l'utilisateur veut
pouvoir utiliser le port série USB séparément du port série XBee. Si
l'utilisateur veut avoir des données indépendantes sur le port USB du port
XBee, alors une opération mineure de la carte devra être effectuée. Les
spécificités sont décrites sur le site web ArduPilot XBee, référence [2]. La
procédure consiste simplement à couper les ponts de soudure existants2, et à
en faire 2 différents. Ceci isolera les 2 ports série l'un de l'autre.
3
Numéro deport
1N/AArrayof FloatsAffichele tableau de flottants sur
port série sélectionné
Tableau 3.17 : Bloc d'impression en série de données
flottantes, entrée
Écriture en série
Pour un système de télémétrie plus compliqué qui nécessite des données
binaires brutes, le bloc Serial Write écrit un vecteur d'octets sur le port série
de télémétrie de l'APM. Notez2. que le bus par défaut est UART0, cependant,
comme il est partagé avec le bus USB, on peut suivre les instructions du pont
de soudure sur la page ArduPilot (référence [2]) pour activer UART2 si on le
souhaite. Le bus à utiliser est sélectionnable dans le masque.
Notez que ce bloc écrit les octets bruts qui lui sont fournis. Cela signifie
généralement qu'une certaine quantité de code sera nécessaire du côté de la
réception pour reconstruire les données en un affichage utile.
Numéro deport
1N/AArrayof BytesSortitle tableau d'octets sur se-
port aérien
Tableau 3.18 : Bloc d'écriture en série, entrée
3.4.2 Sortie USB

Le bloc Serial Print Floats peut également être utilisé pour émettre via le port
série USB. Comme décrit dans la section Télémétrie, par défaut, le port série
USB est le même que le port série XBee. Ces données peuvent être
visualisées avec une interface de port série telle que Putty.
3.4.3 Puce de mémoire flash

Le bloc Mémoire Flash écrit un tableau de valeurs flottantes sur la puce
mémoire flash intégrée à l'APM2. Le masque du bloc permet à l'utilisateur
d'entrer les noms de chaque paramètre du tableau. Il convient de noter que le
bloc ne compare pas la liste des titres à la liste des paramètres du tableau.
L'utilisateur doit faire preuve de prudence pour s'assurer que les noms des en-
têtes correspondent bien aux données écrites sur la puce mémoire flash. En
outre, dans le masque, l'utilisateur peut définir les chiffres de précision des
paramètres flottants. Le temps d'échantillonnage doit également être réglé sur
le temps d'échantillonnage global afin de garantir que les données sont
collectées pour chaque pas de temps.
Le bloc de mémoire flash dispose d'une sortie qui peut être utile pour le
débogage. Un bloc d'affichage peut facilement être connecté pour surveiller
3
les données en simulation.
3
L'activation de la puce mémoire flash pour enregistrer des données, ainsi
que le téléchargement des données enregistrées, sont décrits dans la section
3.4.4
La figure montre3.11 le bloc et le masque de la mémoire flash.
Figure 3.11 : Bloc et masque de mémoire flash
Port n°. Étiquet Unités Description

te
1 N/A Tableau de Tableau des flottants à enregistrer
flotteurs
Tableau 3.19 : Bloc d'écriture d'un tableau

flottant, entrée
Numéro deport
1N/A (sim)Float Port de débogage
desimulation ArraySimulation
Tableau 3.20 : Bloc Write Float Array, sortie
3.4.4 Téléchargement des données

Pour télécharger les données qui ont été enregistrées sur la puce mémoire
Flash, l'ArduPilot doit être réinitialisé. Lors d'une mise sous tension ou d'une
réinitialisation, la première chose que fait l'ArduPilot est de vérifier si des
données sont stockées sur la puce mémoire. Un menu est affiché via le port
série USB avec lequel l'utilisateur peut interagir en utilisant Putty. Si la puce
3
mémoire ne contient pas de données, l'utilisateur est invité à faire l'une des
choses suivantes :
• Armez le tableau pour l'enregistrement - l'utilisateur appuie sur la touche a.
3
• Effacer le tableau - l'utilisateur appuie sur la touche e
• Ne rien faire, laisser le tableau tranquille - l'utilisateur appuie sur la touche l
Si la puce mémoire contient des données, l'invite de l'utilisateur est
légèrement différente. Le menu est le suivant :
• Ecraser les données sur la carte - l'utilisateur appuie sur la touche o
• Effacer le tableau - l'utilisateur appuie sur la touche e
• Imprimer les données sur le terminal Putty - l'utilisateur appuie sur la touche p
• Ne rien faire, laisser le tableau tranquille - l'utilisateur appuie sur la touche
l La Figure et3.12 la Figure montrent 3.13l'affichage du terminal putty de
chacun des menus décrits ci-dessus.
Figure 3.12 : Menu d'interaction de la mémoire flash - sans données
3.5 Autres blocs divers

Il existe plusieurs autres blocs qui sont utiles pendant le développement du
logiciel APM2. Bien qu'ils puissent ou non être utilisés dans la conception
finale, ils sont disponibles et décrits dans les sections suivantes.
3.5.1 Entrée discrète

Ce bloc lit une valeur discrète à partir d'une broche spécifiée sur la carte Arduino.
3
Figure 3.13 : Menu d'interaction de la mémoire flash
- avec données

1 Numéro de - Sort un 0 ou un 1 pour un signal bas
la broche ou haut (respectivement) lu sur la
broche spécifiée.
Tableau 3.21 : Bloc d'entrées discrètes, sortie
3
3.5.2 Sortie discrète
Ce bloc envoie une valeur discrète à une broche spécifiée sur la carte Arduino.

1 Numéro de -La broche spécifiée sera haute ou
la broche basse si l'entrée est ou
1respectivement.0
Tableau 3.22 : Bloc de sorties discrètes, entrée
3.5.3 LED Bleu

Ce bloc allume la LED bleue.
Numéro deport
1On - Une entrée de allume1 la LED bleue
et éteint 0la LED bleue
Tableau 3.23 : Bloc de la LED bleue, entrée
3.5.4 LED jaune

Ce bloc allume la LED jaune.
Numéro deport
1On - Une entrée de fait tourner1 le bouton jaune
s'allume et éteint 0la LED jaune
Tableau 3.24 : Bloc jaune LED, entrée
3.5.5 LED rouge

Ce bloc allume la LED rouge.
Numéro deport
1On - Une entrée de allume1 la LED rouge
et éteint 0la LED rouge
Tableau 3.25 : Blocage de la LED rouge, entrée
3
3.5.6 Entrée analogique
Ce bloc lit l'entrée de tension analogique à partir de la broche d'entrée
analogique spécifiée sur la carte Arduino. La plage de l'entrée sur la broche
est comprise entre 0 et 5 volts, ce qui correspond à une sortie de bloc de to
01023.
Numéro deport
1Pin NumberIntegerOutputsune valeur entre à0
1023 correspondant à à des
0volts5
Tableau 3.26 : Bloc d'entrée analogique, sortie
3.5.7 Sortie analogique

Ce bloc reproduit approximativement une sortie analogique sur la broche
spécifiée sur la carte Arduino en utilisant un signal PWM avec une fréquence
d'environ 490 Hz. L'entrée de ce bloc doit être un nombre entier entre 0 et 255
correspondant à des 0volts5.
Port No. LabelUnitésDescription

1 brocheEntier Délivre un signal analogique sur
broche spécifiée entre 0 et 5V
correspondant à une entrée de 0 à
255
Tableau 3.27 : Bloc de sortie analogique, entrée
3.5.8 Lecture en série

Ce bloc lit un octet à partir de l'interface série spécifiée dans le masque. Il
sortira -1 si aucune donnée n'est disponible pour être lue.
Numéro deport
1N/AByteLectureun octet à partir de l'interface
série.
interface
Tableau 3.28 : Bloc de lecture en série, sortie
3.5.9 Conversion d'un flotteur en uint8

Ce bloc prend un seul nombre à virgule flottante et le convertit en quatre
3
octets qui peuvent être transmis via le bloc Serial Write. Ceci est très utile
pour construire
3
un paquet de télémétrie.
Numéro deport
1 point flottant
Tableau 3.29 : Bloc de conversion de flottant en
UINT8, entrée
Numéro deport
1N/Auint8uint8valeur
Tableau 3.30 : Bloc de conversion de flottant en
UINT8, sortie
4
Chapitre 4
Exemples
Depuis la version initiale de l'APM2 Simulink Blockset, le code embarqué

actuel ne fonctionne pas avec les modèles de référence. Il fonctionnera
cependant avec les modèles de bibliothèque. Les améliorations futures
ajouteront la capacité d'utiliser des modèles de référence, mais pour l'instant,
l'utilisateur doit les éviter dans le modèle qui est réellement intégré à
l'ArduPilot. Le fichier décrit dans les exemples ci-dessous est inclus dans le
fichier
Le fichier .zip fourni avec ce guide dans l'emplacement /Arduino
Code/ArduPilot/- APM2/Sensors Example.mdl.
4.1 Exemple de base

La fonctionnalité minimale requise pour intégrer du code sur l'ArduPilot serait
simplement le bloc RC Read avec ses sorties connectées au bloc RC Write. Ce
modèle fera simplement fonctionner l'avion en mode manuel pur. L'ArduPilot
traitera les commandes du pilote et émettra les commandes PWM équivalentes
pour le servo ou l'accélérateur. La figure montre4.1 ce modèle de base.
Figure 4.1 : Modèle Simulink de base utilisant des blocs

RC
4
4.2 Exemple d'IMU et de sortie de données
Pour tester l'APM2 au sol, le bloc IMU peut être connecté à un bloc de sortie
série pour une simple surveillance des accélérations linéaires et des taux de
rotation. Le bloc IMU fournira les valeurs mesurées et le bloc Serial Print
Floats produira un flux de données en série séparé par des virgules. Un simple
programme de lecture des données série à partir du port USB (Putty est un
choix populaire) peut être utilisé pour visualiser le flux de données série en
temps réel, ainsi que pour enregistrer les données pour une utilisation
ultérieure. La figure montre 4.2ce modèle simple, y compris les blocs de
synchronisation pour permettre les données horodatées.
Figure 4.2 : Sortie des mesures IMU sur le port série
4.3 Exemple de capteurs

Un modèle d'exemple plus complexe inclut les blocs de capteurs et
d'enregistrement de données en plus des blocs RC. Ce modèle permettra à
chaque composant de l'ArduPilot de fonctionner, avec les valeurs brutes des
capteurs, en unités d'ingénierie, enregistrées pour un traitement ultérieur. Ces
données peuvent être utilisées pour aider à identifier la dynamique du système
pour la simulation. La figure 4.3 montre un modèle Simulink utilisant tous les
blocs de capteurs, de synchronisation, de sorties série et de mémoire flash.
Elle montre comment les matrices peuvent être utilisées pour le bloc de
mémoire flash ainsi que pour les sorties série (USB et XBee). Il faut noter
que le bloc de mémoire flash et les blocs d'impression en série nécessitent une
valeur à virgule flottante pour l'entrée, donc un bloc de conversion est placé
sur tous les signaux qui ne sont pas une valeur à virgule flottante par défaut.
Au total, 23 paramètres seront écrits sur la puce mémoire flash avec ce
modèle. La figure
4.3 ne montre pas les blocs RC de base de la Figure 4.1mais ils sont inclus
dans cet exemple de modèle.
4
Figure 4.3 : Modèle Simulink utilisant tous les blocs de capteurs, de
synchronisation et de mémoire flash.
4
4.4 Téléchargement d'un modèle
La section 2.8 décrit toutes les étapes nécessaires pour télécharger le modèle
sur l'APM2 en utilisant ROTH. Une fois la configuration terminée, il suffit de
connecter l'APM2 à l'ordinateur à l'aide d'un câble mini-USB, puis, à partir du
modèle, de sélectionner le menu Outils, suivi du menu Exécuter sur le
matériel cible, puis de l'option Exécuter.
4.5 Les prochaines étapes

Avec les exemples de base ci-dessus, des sous-systèmes ou modèles Simulink
supplémentaires peuvent être inclus pour utiliser les données du capteur pour
l'estimation de l'état et le contrôle en boucle fermée. C'est la partie amusante.
Bonne chance !
4
Chapitre 5
Architecture du
jeu de blocs
Simulink
Une bibliothèque Simulink a été créée avec un ensemble de blocs comme le

montre la Figure 5.1 qui permettront d'interagir avec les composants matériels
de la carte ArduPilot Mega 2.0 via Simulink. Il existe des blocs permettant
d'accéder à l'unité de mesure inertielle, d'écrire des données sur les ports série,
d'allumer les LED et de nombreuses autres opérations. La plupart des blocs
comprennent des entrées qui leur permettent d'être utilisés à la place et de
transmettre des données de capteur simulées lorsque le modèle est exécuté
dans le cadre d'une simulation de bureau. Une fois le modèle validé et jugé
apte au vol, une nouvelle fonctionnalité de Simulink appelée Run On Target
Hardware peut être utilisée pour générer automatiquement du code C/C++,
compiler le code et flasher l'exécutable sur la carte, le tout via USB et sans
aucune interaction de l'utilisateur. Lorsque ces blocs sont auto-codés, ils
remplacent automatiquement leurs entrées de simulation par des appels au
matériel réel. Les détails concernant les blocs individuels peuvent être trouvés
dans la section 3.
Les sections suivantes traitent du fonctionnement interne des blocs, dont la
plupart partagent un format similaire. Dans le but de fournir un guide à ceux
qui poursuivent le développement, les deux sections suivantes ont pour but de
présenter l'architecture de base des blocs. Notez que certains blocs peuvent
s'en écarter légèrement en fonction de leur implémentation individuelle.
5.1 Base de code C/C++ d'APM

Le code sous-jacent qui est devenu le blockset APM2 a été dérivé de trois
sources. Tout d'abord, un blockset supportant la carte APM1 a été obtenu de
Math-works, et il a été utilisé comme guide pour construire son successeur.
En raison d'un changement majeur de matériel entre l'APM1 et l'APM2, très
peu de code est partagé avec ce projet.
Deuxièmement, une grande majorité du code du firmware a été obtenue à
partir de références [1]. La tâche de l'équipe a alors consisté principalement à
4
créer un code d'enveloppe.
4
Figure 5.1 : Bibliothèque Simulink2.0 d'ArduPilot Mega
qui serait lié à ces classes et s'interfacerait avec Simulink. De nombreuses

modifications cosmétiques ont été apportées à ce code, comme la suppression des
chemins relatifs dans les instructions include, la modification des signes ou des
unités, mais la majorité du code est restée intacte.
La dernière source de code de firmware était la génération
personnalisée. Les classes C++ telles que Pitot et TimeStats ont été écrites
par l'équipe puisqu'une solution toute prête n'était pas disponible. En outre,
une quantité importante de fonctions de wrapper, principalement contenues
dans les fichiers Simulink APM2 Wrapper.h et Simulink APM2 Wrapper.cpp,
ont été écrites afin de déclarer les variables globales nécessaires, d'exécuter
les routines de démarrage de la carte à l'échelle du système et de fournir une
interface à Simulink pour accéder aux classes et au matériel APM. La
plupart de ce code C/C++ peut être trouvé dans le dossier cores/arduino qui
est fourni
dans le fichier .zip inclus avec ce guide.
Pour donner un exemple de cette configuration, nous allons examiner
le code C++ nécessaire pour accéder à l'IMU. La plupart des blocs suivent
un processus similaire.
Tout d'abord, les prototypes de fonction ont été déclarés dans Simulink
APM2 Wrapper.h
4
comme,
4
/* Unité de mesure inertielle (calibrée) */
voidimu_init(uint32_t,uint32_t,
uint32_t) ; voidimu_flash_leds(bool) ;
voidimu_update(void) ;
voidimu_get_accels(float*) ;
voidimu_get_gyros(float*) ;
floatimu_temperature(void) ;
Ensuite, dans Simulink APM2 Wrapper.cpp, une instance de la classe AP

IMU INS a été déclarée,
AP_InertialSensor_MPU6000 ins( ) 53; /* la sélection de puce est

unEenfbinro, cdhese w*/r5ap3pAerPs_oInMt Uét_éINdéSfiinmisup(o&uirncsh)a;que fonction qui accède aux
méthodes de classe de la variable imu,
extern "C" void imu_init(uint32_t lpf_filt_freq_hz,
uint32_t gyro_scale,
uint32_t accel_scale)
{
imu.init(IMU::COLD_START,
delay,
imu_flash_leds,
&scheduler,
lpf_filt_freq_hz,
gyro_scale, accel_scale) ;
};
extern "C" void imu_update(void) {imu.update();}
extern "C" void imu_get_accels(float* a)
{
Vector3f accel
;accel = imu.get_accel()
; a[0]=accel.x ;
a[1]=accel.y ;
a[2]=accel.z ;
}
extern "C"
voidimu_get_gyros(floa
t*g)
{
Vector3f gyro ;
gyro = imu.get_gyro() ; g[0]=gyro.x
;
g[1]=gyro.y ;
g[2]=gyro.z ;
}
4
extern "C" floatimu_temperature(void)
{
retourner
} ins.temperature() ;
À ce stade, les fonctions wrapper sont accessibles au code Simulink,

comme nous le verrons plus loin dans la section 5.3.
Une fonction importante à noter est la fonction d'initialisation, Simulink
APM2 Startup, que l'on trouve dans les fichiers Simulink APM2 Wrapper.cpp
et Simulink APM2 Wrapper.h. Cette fonction doit être exécutée avant tout
code de bloc. Elle doit être exécutée avant tout code de bloc et est responsable
du démarrage et de la configuration du matériel, des bus, etc. Chaque bloc de
la bibliothèque APM2 vérifiera, lors de la génération du code, si un appel à
cette fonction a été inséré dans la routine de démarrage et l'insérera si ce n'est
pas le cas. Encore une fois, plus de détails seront discutés dans la section 5.3.
5.2 Niveau S-Fonction2

Chaque bloc de la bibliothèque possède un fichier C spécial qui correspond
au bloc. Sans entrer dans les détails, car ce n'est pas tout à fait pertinent pour
ce projet, il convient de noter que ce fichier définit essentiellement le
comportement du bloc lorsqu'il est utilisé dans une simulation et fournit des
informations au processus de génération de code concernant les paramètres
et les ports. Il est également important que l'utilisateur compile d'abord ces S-
Fonctions avant de tenter d'utiliser les blocs, sinon une erreur sera générée.
La commande Matlab pour compiler, par exemple, la S-Fonction associée au
bloc IMU est mex Arduino IMU sfcn.c.
Pour plus d'informations, voir la référence [8].
5.3 Compilateur du langage cible

Le fichier du compilateur du langage cible, comme les S-Functions décrites
ci- dessus, est un autre fichier qui est associé à chaque bloc. Ce fichier
contient des instructions à l'auto-codeur sur la manière exacte de générer du
code. Il existe un langage entier dédié à ce processus et le lecteur est
encouragé à parcourir la référence [7] pour avoir une idée de la puissance (et
de la légère confusion) de cette configuration.
Les fonctions BlockTypeSetup, Start et Outputs du fichier TLC sont d'un
intérêt primordial pour le lecteur. C'est là que le code C qui relie les ports de
bloc aux wrappers de la section 5.1 est défini. Chaque fonction sera
brièvement expliquée ici.
La première fonction, BlockTypeSetup, est appelée une fois par type de
bloc et a été utilisée pour insérer tout en-tête supplémentaire requis pour ce
type de bloc particulier. En général, tous les blocs s'assurent simplement que
l'en-tête global, Simulink APM2 Wrapper.h, a été déclaré.
La deuxième fonction, Start, insère du code dans la fonction que le
programme compilé exécutera avant de lancer et d'exécuter le code réel du
modèle Simulink.
5
C'est là que les ressources supplémentaires sont démarrées, comme un bus
série nécessaire à l'opération d'un bloc spécifique, ou que les appels pour
calibrer les capteurs sont placés. Cela permet, par exemple, à la carte
d'exécuter sa calibration IMU uniquement lorsque le bloc IMU est
effectivement dans le modèle puisque le TLC pour le bloc IMU utilise la
fonction Start pour insérer un appel à imu init. Le TLC a également accès
aux paramètres de masque et peut insérer leurs valeurs dans le code C généré
pour des opérations telles que le réglage de la vitesse de transmission ou la
sélection des plages de capteurs IMU.
La première opération de chaque fonction Start est de vérifier si un autre
bloc a appelé Simulink APM2 Startup et d'insérer l'appel si nécessaire. Ainsi,
le code TLC suivant est commun à tous les blocs APM2,
%% Démarrage de la carte APM2. Commun à tous les blocs APM2.

où tous les tokens % <> seront remplacés par les valeurs appropriées pendant laêtrgeénération du code. Par exemple, le code
d%es%suisncelsutslenspurivemaniet re!n supposant qu'aucun bloc précédent n'a inséré cet appel
: %if EXISTS("_DONE_SYSTEM_INIT_") == 0
Enfin, la fonction
%assign Output génère le code
: : _DONE_SYSTEM_INIT_ = 1qui est appelé par le
/* Fon/*ctFi onncdteiodnédmeadrréamgeardraugseysdtèumseyAstèPmMe2A. RPMeq2u. iRsepqouuisr tpoouusr lteosus les
ebmlobacrsq.buléocàs.chaque fois que le bloc est exécuté. C'est là que se trouve la majoIrnitséérdéIunpscaéordée: ppao
l'IMUBl,olce (fI%iMc<hUiTe6yr-pTDeL>OCF(%)q:<uIPiMagUréanm6è-SrDeeOtlteFinc*go/sd.FeuCncetisotnmNoamnteré>)c
SimSiumliunlkin_kA_PAMPM2_2S_tSatratrutpu(p)(); ;
%%EnFdoinfction : Outputs ===========================================
%%
%fonction Sorties(bloc, système) Sortie
%if (CompiledModel.TargetStyle!="SimulationTarget")
float imu_accel[3] ; float imu_gyro[3] ; float imu_temp ;
/* Empêcher la puce baro de tenir le bus SPI */
5
pinMode(40, OUTPUT) ; digitalWrite(40, HIGH) ;
imu_update() ; imu_get_gyros(imu_gyro) ; imu_get_accels(imu_accel) ; imu_temp = imu_temperature() ;
/* Degrés par seconde */

%<LibBlockOutputSignal(0, "", "", 0)> = imu_gyro[0] ;
/* G's */
%<LibBlockOutputSignal(3, "", "", 0)> = imu_accel[0] ;
%<LibBlockOutputSignal(4, "", "", 0)> = imu_accel[1] ;
%<LibBlockOutputSignal(5, "", "", 0)> = -imu_accel[2] ;
/* Deg C */
%<LibBlockOutputSignal(6, "", "", 0)> = imu_temp ; Endif
%endfunction
Gardez à l'esprit qu'il existe un fichier TLC pour chaque bloc, et que le
code C généré à l'aide du TLC ci-dessus sera inséré dans une grande fonction
de mise à jour lors des étapes finales du processus de codage automatique.
L'ordre dans lequel Simulink Embedded Coder insère le code est variable et le
code doit être écrit de manière à pouvoir être appelé à tout moment. Les
fonctions qui doivent être prioritaires, par exemple l'initialisation des bus
périphériques partagés avant que les périphériques n'essaient d'y accéder, sont
traitées par la fonction Simulink APM2 Startup, comme décrit précédemment.
5
Chapitre 6
Travaux futurs
6.1 Travaux futurs

Ce blockset pour Simulink a été créé dans un but précis. La robustesse pour
des utilisations variables n'a pas encore été implémentée. Les créateurs
originaux ont pour objectif d'améliorer ce blockset, mais comme de plus en
plus de personnes l'utilisent, on s'attend à ce que certaines d'entre elles soient
en mesure de mettre en œuvre des améliorations. La liste suivante identifie
certains problèmes connus ou domaines à améliorer.
- Actuellement, lors de l'utilisation de ROTH dans Simulink, il ne semble
pas que l'utilisation des modèles de référence soit toujours faible. Cette
fonctionnalité est hautement souhaitable, mais les contraintes de temps
n'ont pas permis de l'implémenter.
- Le bloc de mémoire flash ne permet actuellement que l'utilisation de
types de données flottants. Bien que cela fonctionne, cela utilise plus de
mémoire que ce qui est réellement nécessaire pour certains termes.
L'objectif sera de développer le code de sorte que plusieurs types sur un
seul tableau ou bus puissent être écrits sur la puce Flash.
- Les noms des rubriques du bloc Mémoire Flash doivent actuellement
être saisis manuellement dans le masque. Ce serait bien si les noms
étaient automatiquement déterminés à partir des noms de signaux des
données entrant dans le bloc. Cela nécessiterait bien sûr que les signaux
soient nommés.
- Si le micrologiciel du XBee est modifié à l'aide de XCTU de Digi, le menu
qui s'affiche pour activer l'enregistrement ou télécharger des données ne
s'affiche pas correctement. Ceci est dû au fait que le fichier Simulink
APM2 Wrapper.cpp dans le répertoire des noyaux modifiés a la vitesse
de transmission pour l'affichage du menu de la mémoire codée en dur à
115200 bauds. Idéalement, ce terme devrait pouvoir être réglé dans
Simulink ou dans l'espace de travail de Matlab.
- Modifier les blocs de la bibliothèque pour qu'en simulation, ils puissent
être utilisés pour représenter les capteurs réels. Actuellement, ils
5
transmettent simplement toutes les entrées directement aux sorties dans
la simulation, mais il serait utile d'avoir des bruits,
5
La variance ou les effets de dérive peuvent être modélisés à l'aide du
masque de bloc. Ces paramètres de masque ne seraient utilisés qu'en
simulation, et non lors du chargement réel sur la carte.
- Développez l'automatisation pour effectuer les étapes de configuration
décrites au chapitre 2y compris la définition du chemin.
- Développer des fichiers d'aide Simulink correctement formatés.
Actuellement, ce guide pratique est la meilleure référence pour l'aide sur
le blockset.
5
Chapitre 7
Soutien
Ce guide a pour but de fournir tous les détails nécessaires à l'utilisation du

blockset ArduPilot 2.0 Simulink. Cependant, il y aura inévitablement des
problèmes qui surviendront en raison de nombreuses inconnues au fur et à
mesure que les gens commenceront à utiliser le blockset. Veuillez envoyer un
courriel à apm2.simulink@gmail.com si vous avez besoin d'aide pour utiliser
correctement le blockset Simulink APM2. Tous les efforts raisonnables seront
faits pour aider les utilisateurs de ce blockset.
5
Références
[1] Drones DIY. Source Checkout - ardupilot-mega - Dépôt officiel

d'ArduPlane - Hébergement de projets Google : Oct. 2012. url :
http://code.google. com/p/ardupilot-mega/source/checkout.
[2] Drones de bricolage. Utilisation des radios Xbee pour la télémétrie avec APM2
. Oct. url2012. :
http://code.google.com/p/ardupilot-mega/wiki/APM2Wireless.
[3] Freescale. MPXV7002 : Capteur de pression intégré. Oct. url2012. : http :
//www. freescale. com/webapp/sps/site/prod_summary. jsp ?
code= MPXV7002&fsrch=1&sr=1.
[4] Honeywell. Compas numérique 3 axes - HMC5843. Oct. url2012. : http :
//www51.honeywell.com/aero/common/documents/myaerospacecatalog-
documents/Defense_Brochures-documents/HMC5843.pdf.
[5] InvenSense. MEMS Gyro-Accel - Gyroscope - Accéléromètre - Pro-
cessing - MPU-6000. Oct. url2012.
: http://invensense. com/mems/ gyro/mpu6000.html.
[6] The Mathworks. Compilateurs supportés et compatibles Release 2012a.
Oct. url2012. : http://www . mathworks. com
/ s u p p o r t / c o m p i l a t e u r s / R2012a/win64.html.
[7] The Mathworks. Compilateur du langage cible. Oct. 2012. url :
http:// www.mathworks.com/help/rtw/block-authoring-with-
tlc.html.
[8] The Mathworks. Qu'est-ce qu'une fonction S ? Oct. url2012. :
http://www. mathworks.com/help/simulink/sfg/what-is-an-
s-function.html.
[9] MediaTek. MediaTek - MT3329. Oct. 2012. url : http://www.mediatek.
com/en/Products/product_content.php?sn=50.
[10] NOAA. NOAA's Geophysical Data Center - Geomagnetic Online
Calcu- lator. Oct. url2012. : http://www . ngdc. noaa.
gov/geomagmodels/ IGRFWMM.jsp.
[11] MEAS Suisse. MS5611-01BA01Capteurs de pressionModules de capteurs
de pression pour altimètresMeasurement Specialties : Oct. url2012. :
http://www. meas-
spec.com/product/t_product.aspx?id=8501.

Aaaa

Transféré par

Informations du document

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

Aaaa

Transféré par

Droits d'auteur :

Formats disponibles

Abonnez-vous à DeepL Pro pour traduire des fichiers plus volumineux. Visitez pour en savoir plus.

Guide pratique : Blockset Simulink2.0 pour

Dans le cadre du développement d'un nouveau cours de troisième cycle sur le

3.1 Bloc et masque IMU................................................................................12

4.1 Modèle Simulink de base utilisant des blocs RC....................................32

2.1Dossiersà ajouter au chemin de Matlab....................................10

3.1 Bloc IMU 6-DOF, entrées.......................................................................13

bx Intensité du champ magnétique sur l'axe x du corps

2.2 Paramètres de configuration Simulink

2.4 Répertoire des noyaux cibles Arduino

2.5 Fichier IOWrappers.cpp

2.6 Chemin Simulink

2.7 S-Function Build

2.8 Téléchargement d'un modèle

3.1 Blocs de capteurs

Figure 3.1 : Bloc et masque IMU

Calibration Dans les coulisses, l'ArduPilot va calibrer l'IMU au

3.1.2 Capteur de pression barométrique

Tableau 3.1 : Bloc IMU 6-DOF, entrées

Port n°. Étiquette Unité Description

Tableau 3.2 : Bloc IMU 6-DOF, sorties

Figure 3.2 : Bloc de pression barométrique

Port n°. Étiquette Unités Description

Tableau 3.3 : Bloc du capteur barométrique, entrées

Port n°. Étiquette Unités Description

Tableau 3.4 : Bloc du capteur barométrique, sorties

Port n°. Étiquette Unité Description

Tableau 3.5 : Bloc magnétomètre, entrées

Tableau 3.6 : Bloc magnétomètre, sorties

avec le microprocesseur AT Mega via une liaison série standard RS-232.

Figure 3.4 : Bloc et masque GPS

Port n°. Étiquette Unité Description

Tableau 3.8 : Bloc GPS, sorties

Figure 3.5 : Bloc du capteur de pression différentielle

Tableau 3.9 : Bloc de la sonde de Pitot, entrée

Figure 3.6 : Bloc et masque de lecture RC

Port n°. Étiquette Unité Description

Tableau 3.11 : Bloc de lecture RC, entrées

Tableau 3.12 : Bloc de lecture RC, sorties

Figure 3.7 : Bloc et masque d'écriture RC

Port n°. Étiquet Unité Description

Tableau 3.13 : Bloc d'écriture RC, entrées

Tableau 3.14 : Bloc d'écriture RC, sorties

Figure 3.8 : Bloc d'horloge et masque

3.3.2 Moniteur en temps réel

Tableau 3.15 : Bloc d'horloge, sortie

est utile pour déterminer si le code est trop complexe ou si la fréquence de la

Figure 3.9 : Bloc et masque du moniteur en temps réel

Port n°. Étiquette UnitsDescription

Tableau 3.16 : Bloc moniteur en temps réel, sortie

3.4 Sortie de données

Impression en série des flottants

Figure 3.10 : Bloc et masque de l'impression série des flottants

Tableau 3.18 : Bloc d'écriture en série, entrée

3.4.2 Sortie USB

3.4.3 Puce de mémoire flash

Figure 3.11 : Bloc et masque de mémoire flash

Port n°. Étiquet Unités Description

Tableau 3.19 : Bloc d'écriture d'un tableau

3.4.4 Téléchargement des données

Figure 3.12 : Menu d'interaction de la mémoire flash - sans données

3.5 Autres blocs divers

3.5.1 Entrée discrète