Apprendre et maîtriser LabVIEW par ses applications

Nadia MartajMohand Mokhtari

Apprendre et maîtriser LabVIEW par ses applications

Apprendre et maîtriser LabVIEW par ses applications

Nadia Martaj • Mohand Mokhtari

ISBN 978-3-642-45334-2 ISBN 978-3-642-45335-9 (eBook) DOI 10.1007/978-3-642-45335-9 Springer Heidelberg New York Dordrecht London Library of Congress Control Number: 2014936040 © Springer-Verlag Berlin Heidelberg 2014 This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Exempted from this legal reservation are brief excerpts in connection with reviews or scholarly analysis or material supplied specifically for the purpose of being entered and executed on a computer system, for exclusive use by the purchaser of the work. Duplication of this publication or parts thereof is permitted only under the provisions of the Copyright Law of the Publisher’s location, in its current version, and permission for use must always be obtained from Springer. Permissions for use may be obtained through RightsLink at the Copyright Clearance Center. Violations are liable to prosecution under the respective Copyright Law. The use of general descriptive names, registered names, trademarks, service marks, etc. in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant protective laws and regulations and therefore free for general use. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. Printed on acid-free paper Springer is part of Springer Science+Business Media (www.springer.com)

Nadia M Mohand MokhtariParis, France

Montpellier, France EPF-Ecole d’Ingénieurs

artaj

Additional material to this book can be downloaded from http://extras.springer.com.

A ma mère Fatna, mon père Bouchaïb Mes sœurs et mes frères

Nadia MARTAJ

nadia.martaj@epf.fr

A mes enfants Sonia, Omar et Hachimi

Mohand MOKHTARI mohand.mokhtari@gmail.com

Tous nos remerciements à Rachid Bennacer, Professeur des Universités, ENS de Cachan,

d’avoir lu et corrigé le manuscrit.

Préface

« Apprendre et Maîtriser LabVIEW par ses applications" est un ouvrage complet qui permet une gestion efficace du logiciel LABVIEW à travers ses applications dans les domaines académiques et industriels. En effet, cette approche originale permet à l'ingénieur, le technicien ou l'étudiant à comprendre le langage rapidement et efficacement.

Ce livre, constitué de plusieurs chapitres, est un condensé des connaissances que possèdent les auteurs de par leur expérience académique et industrielle. Il sera un précieux document qui aidera, tant les enseignants, étudiants que les ingénieurs de l’industrie à mener à bien leurs projets.

Cet ouvrage est organisé en 3 parties dont la première concerne l’apprentissage du langage, toujours à travers des applications.

La seconde partie de l’ouvrage concerne l’outil additionnel « Conception du contrôle et simulation » qui permet de simuler des systèmes dynamiques et de mettre au point des régulations, analogiques ou discrètes, en utilisant le traditionnel PID sous ses différentes structures ou par l’approche de la logique floue. Plusieurs applications ont été réalisées avec le souci pédagogique de l’apprentissage du langage.

Enfin, la troisième partie de l’ouvrage traite d’applications de traitement de signal, déterministe et aléatoire ainsi que de la régulation.

Les applications de LabVIEW ont considérablement évolué depuis 27 ans. Ce livre représente une étape importante dans la façon d'apprendre à utiliser ce logiciel. Je suis sûr que le lecteur trouvera beaucoup de plaisir et d'intérêt à lire cet ouvrage !

Dr. Olivier Horner

Directeur de Recherche & Innovation, EPF-Ecole d’Ingénieurs

VII

Introduction

Cet ouvrage, qui traduit l’expérience des auteurs dans le domaine de l’enseignement supérieur et de l’industrie, est organisé en trois parties complémentaires que sont l’apprentissage de LabVIEW, le toolkit ‘‘Conception de contrôle et simulation’’ et les applications.

Dans tous les chapitres, l’apprentissage du langage se fait à travers des exemples d’applications dans de nombreux domaines, académiques et industriels.

Dans le chapitre 1, LabVIEW est présenté à travers des applications dans divers domaines tels que la résolution des systèmes linéaires, déterminés ou surdéterminés, la résolution des équations différentielles, le traitement de signal, l’analyse numérique, etc. Ce chapitre de prise en main, permet d’appréhender la base du langage avant l’étude des autres fonctionnalités dans les chapitres qui suivent.

Après l’étude et la manipulation des chaînes de caractères, complexes et polynômes, dans les chapitres 2 à 4, le cinquième chapitre permet l’étude et la manipulation des tableaux et des clusters permettant des types hétérogènes pour leurs éléments.

Les chapitres 6, 7 et 8 correspond à l’étude des boucles et structures, les sous-VIs (sortes de sous-programmes) et l’interpolation de données.

Dans le chapitre 9, on introduit le nœud et la fenêtre MathScript LabVIEW. Ce nœud MathScript est une boite qui s’intègre au langage graphique de LabVIEW ou langage G, et qui exécute des scripts de MATLAB en fonction de ses variables d’entrée et de celles définies à l’intérieur. Toutes ces variables du script peuvent être renvoyées comme sorties du nœud.

La possibilité d’éditer un script ou importer un script « .m » est possible via la fenêtre de droite qui comporte des menus dédiés.

MathScript LabVIEW, à l’instar de l’environnement MATLAB, est subdivisée en 3 fenêtres, la fenêtre de commande dans laquelle on peut exécuter des commandes de façon interactive, la fenêtre de résultat qui affiche le résultat de cette commande et une fenêtre d’édition de script. Les nœuds de propriété, du chapitre 10, permettent de lire ou d’écrire les propriétés d’un objet ou un instrument virtuel (Virtual Instrument VI).

Le stockage des données et ou des résultats dans des fichiers texte, tableur, ou autre est explicité dans le chapitre 11.

Le chapitre 12 permet d’étudier les fonctionnalités graphiques de LabVIEW.

La partie II du présent ouvrage (chapitres 13 à 17), est consacrée à l’outil additionnel ou toolkit ‘‘Conception de contrôle et simulation ’’ qui permet la modélisation et la simulation des systèmes dynamiques, analogiques et discrets.

IX

X Introduction

L’outil possède plusieurs palettes de VIs pour l’identification AR (AutoRégressif), ARMA (AutoRégressif et Moyenne Ajustée ou mobile), la réalisation de régulations par différentes structures du traditionnel PID, le retour d’état ainsi que par l’approche floue (Fuzzy Logic).

Cet ouvrage propose, dans la partie III, (chapitres 18 à 22), des applications, respectivement, d’analyse numérique, probabilités et statistiques, régulation, traitement de signal, analogique et discret, déterministe et aléatoire.

L’originalité de cet ouvrage réside dans l’apprentissage par applications. Le lecteur peut partir de l’instrument virtuel (VI) et d’obtenir celui qui correspond à son propre besoin.

L’ingénieur, l’étudiant ou l’enseignant en tireront un grand profit pour apprendre, efficacement et surtout rapidement, ce langage et s’inspirer directement des applications proches de leurs besoins.

Rachid BENNACER

Professeur des Universités

Ecole Nationale Supérieure (ENS), Cachan

Table des matières

Chapitre 1

I. Résolution de systèmes d’équations linéaires ................................................................................................. 2 I.1. Système déterminé ..................................................................................................................................... 2 I.2. Système surdéterminé ................................................................................................................................ 5

II. Régression linéaire ........................................................................................................................................ 11

III. Régression exponentielle et polynomiale ................................................................................................... 15

IV. Equations aux récurrences .......................................................................................................................... 18

V. Filtres numériques ........................................................................................................................................ 21 V.1. Filtre de Butterworth .............................................................................................................................. 21 V.2. Filtre à réponse impulsionnelle finie (Finite Impulse Response, FIR) ................................................... 23

VI. Régulation .................................................................................................................................................... 26 VI.1. Réponse indicielle d’un processus du 1er ordre .................................................................................... 26 VI.2. Régulation proportionnelle et intégrale, PI............................................................................................ 28

VII. Analyse numérique .................................................................................................................................... 31 VII.1. Régression linéaire par la méthode de Newton-Raphson ..................................................................... 31 VII.2. Résolution d’équations différentielles.................................................................................................. 35

VII.2.1. Méthode d’Euler ........................................................................................................................... 35 VII.2.2. Méthode de Runge-Kutta ............................................................................................................. 36

VIII. Probabilités et statistiques ....................................................................................................................... 38 VIII.1. Théorème central limite ...................................................................................................................... 38 VIII.2. Corrélation .......................................................................................................................................... 39

VIII.2.1. Calcul théorique de la corrélation et de la covariance ................................................................. 40 VIII.2.2. Corrélation par le calcul matriciel ............................................................................................... 43

IX. Opérations de base d’E/S sur fichiers ........................................................................................................ 47 IX.1. Fichiers texte ......................................................................................................................................... 48

IX.1.1. Ecriture .......................................................................................................................................... 48 IX.1.2. Lecture ........................................................................................................................................... 48

IX.2. Fichiers tableur ...................................................................................................................................... 50 IX.2.1. Sauvegarde ..................................................................................................................................... 50 IX.2.2. Lecture ........................................................................................................................................... 51

IX.3. Fichier de mesures ................................................................................................................................. 52 IX.3.1. En-tête du fichier ........................................................................................................................... 52 IX.3.2. Génération des signaux .................................................................................................................. 53 IX.3.3. Enregistrement des signaux ........................................................................................................... 53 IX.3.4. Tracé des signaux .......................................................................................................................... 54

Chapitre 2 I. Quelques opérations sur les chaînes de caractères ...................................................................................... 58

I.1. Concaténation de chaînes ......................................................................................................................... 59 I.2. Exemple 2 de concaténation de chaînes ................................................................................................... 60

XI

XII Table des matières

I.3. Suppression de chaîne vide au début et à la fin d’une chaîne de caractères ............................................. 61

II. Commandes chaîne et chemin ...................................................................................................................... 62 II.1. Commande chemin, commande et indicateur chaîne .............................................................................. 63 II.2. Chaîne déroulante, recherche, remplacement et portion de chaîne ......................................................... 64

II.2.1. Chaîne déroulante ............................................................................................................................ 64 II.2.2. Recherche, remplacement et portion de chaîne ............................................................................... 65

III. Tableaux de chaînes .................................................................................................................................... 66 III.1. Indexation et suppression d’une portion de tableau ............................................................................... 66 III.2. Formatage .............................................................................................................................................. 67

IV. Fonctions de conversion .............................................................................................................................. 67 IV.1. Conversion de chemin, chaîne et nombre .............................................................................................. 67 IV.2. Chaîne en tableau d’octets ..................................................................................................................... 69 IV.3. Indexation de tableaux de chaînes, recherche et modification de la casse ............................................ 70 IV.4. Recherche de palindrome ...................................................................................................................... 71

V. Création et utilisation des tables .................................................................................................................. 72 V.1. Création de la table par un nœud de propriété ........................................................................................ 72 V.2. Utilisation des tables ............................................................................................................................... 74 V.3. Tables Express ........................................................................................................................................ 76 V.4. Autres propriétés d’une table .................................................................................................................. 77

V.4.1. Création de tables par un nœud MathScript .................................................................................... 78 V.4.2. Création de tables par des nœuds de méthode ................................................................................. 78

VI. Dates et heures et horodatage ..................................................................................................................... 80 VI.1. Attente, temps de calcul et temps écoulé ............................................................................................... 80

VI.1.1. Attente ........................................................................................................................................... 80 VI.1.2. Temps de calcul, temps écoulé ...................................................................................................... 81

VI.2. Dates, heures et horodatage ................................................................................................................... 83 VI.2.1. Dates .............................................................................................................................................. 83 VI.2.2. En-tête d’un fichier texte ............................................................................................................... 84 VI.2.3. Horodatage ..................................................................................................................................... 85

Chapitre 3

I. Palette Complexes ........................................................................................................................................... 90

II. Opérations sur les nombres complexes ....................................................................................................... 91 II.1. Coordonnées cartésiennes et polaires ..................................................................................................... 91 II.2. Approximation de la valeur de ............................................................................................................. 92 II.3. Solutions de l’équation du 2nd degré ..................................................................................................... 93

III. Fonctions de complexes ............................................................................................................................... 94 III.1. Racine, logarithme, exponentielle et puissance réelle de complexes .................................................... 94 III.2. Clusters complexes ................................................................................................................................ 95 III.3. Matrices complexes ............................................................................................................................... 96

III.3.1. Manipulation de matrices complexes ............................................................................................. 96 III.3.2. Analyse de circuit RLC .................................................................................................................. 97

IV. Opérations sur les complexes dans un nœud MathScript ...................................................................... 100 IV.1. Fonctions spéciales de nombres complexes ........................................................................................ 100 IV.2. Représentation graphique .................................................................................................................... 102 IV.3. Racines n-ièmes d'un nombre complexe ............................................................................................. 103 IV.4. Logarithme d’un nombre complexe .................................................................................................... 105

Table des matières XIII

IV.5. Diagramme de Bode d’un circuit RLC ................................................................................................ 106

V. Les complexes dans un script MATLAB ................................................................................................... 109 V.1. Racines n-ièmes d’un nombre complexe .............................................................................................. 109 V.2. Opérations scalaires et matricielles sur les complexes ......................................................................... 110

Chapitre 4 I. Polynômes au sein du nœud de MathScript et la fenêtre MathScript ...................................................... 114

I.1. Opérations sur les polynômes ................................................................................................................ 114 I.1.1. Multiplication, division et racines de polynômes ........................................................................... 115 I.1.2. Division de polynômes ................................................................................................................... 116 I.1.3. Racines d'un polynôme ................................................................................................................... 118

I.2. Manipulation de fonctions polynomiales ............................................................................................... 120 I.2.1. Evaluation de la dérivée et de la primitive d’une fonction polynomiale ........................................ 120 I.2.2. Dérivée, intégrale par les fonctions diff et cumsum ....................................................................... 121

I.3. Interpolation et régression au sens des moindres carrés ......................................................................... 123

II. Utilisation des VIs LabVIEW .................................................................................................................... 125 II.1. Somme, produit et division de polynômes ............................................................................................ 125 II.2. Décomposition en éléments simples, valeurs et vecteurs propres, ........................................................ 127

II.2.1. Décomposition en éléments simples ............................................................................................. 127 II.2.2. Valeurs et vecteurs propres ........................................................................................................... 128

II.3. Polynômes rationnels ............................................................................................................................ 130 II.3.1. Addition, soustraction, décomposition en éléments simples et évaluation .................................... 131 II.3.2. Retour négatif de polynômes rationnels ........................................................................................ 132

III. Polynômes de Bessel et Chebyshev ........................................................................................................... 135 III.1. Polynômes de Bessel ........................................................................................................................... 135 III.2. Polynômes de Chebyshev .................................................................................................................... 136

III.2.1. Forme théorique du polynôme de Chebyshev .............................................................................. 136 III.2.2. Utilisation du VI Chebyshev Polynomial.vi ................................................................................ 137

Chapitre 5

I. Les tableaux .................................................................................................................................................. 140 I.1. Création de tableaux dans le panel et le diagramme .............................................................................. 140

I.1.1. Création de tableaux dans le panel ................................................................................................. 140 I.1.2. Création de tableaux dans le diagramme ........................................................................................ 141

I.2. Création de tableaux par les boucles For et While ................................................................................. 142 I.2.1. Utilisation de boucles For ............................................................................................................... 142 I.2.2. Utilisation de boucles For et While ................................................................................................ 143

I.3. Fonctions de tableaux ............................................................................................................................. 144 I.3.1. Taille et initialisation d’un tableau à une dimension ...................................................................... 144 I.3.2. Construire un tableau, partie d’un tableau, concaténation .............................................................. 147 I.3.3. Indexation d’un tableau .................................................................................................................. 149 I.3.4. Interpolation d’un tableau 1D ......................................................................................................... 151

I.4. Polymorphisme des fonctions sur les tableaux ....................................................................................... 152 I.5. Les matrices et l’algèbre linéaire ........................................................................................................... 153

I.5.1. Sous-palette Tableau Matrice .................................................................................................... 153 I.5.2. Sous-palette Mathématiques Algèbre linéaire ........................................................................... 155

I.6. Applications sur les tableaux.................................................................................................................. 162 I.6.1. Résolution des systèmes linéaires par la méthode Newton-Raphson ............................................. 162 I.6.2. Circuit électrique ............................................................................................................................ 167 I.6.3. Pseudo-inverse d’une matrice ......................................................................................................... 169

XIV Table des matières

II. Les clusters .................................................................................................................................................. 177 II.1. Création de clusters ............................................................................................................................... 177

II.1.1. Création de clusters dans la face-avant ......................................................................................... 177 II.1.2. Création de clusters dans le diagramme ........................................................................................ 179

II.2. Disposition du cluster et modification de l’ordre de ses éléments ........................................................ 182 II.2.1. Disposition du cluster et choix de l’ordre de ses éléments ............................................................ 182 II.2.2. Modification de l’ordre des éléments d’un cluster ........................................................................ 182

II.3. Opérations sur les clusters .................................................................................................................... 183 II.3.1. Opérations sur un cluster constant dans le diagramme .................................................................. 183 II.3.2. Produit de clusters ......................................................................................................................... 184 II.3.3. Modification des éléments d’un cluster ......................................................................................... 185

II.4. Transformation de tableau en cluster et inversement ............................................................................ 186 II.4.1. Cluster numérique et chaîne de caractères .................................................................................... 186 II.4.2. Calculs sur un cluster numérique .................................................................................................. 188

II.5. Tableau de clusters................................................................................................................................ 189 II.6. Les graphes et les clusters ..................................................................................................................... 190

II.6.1. Graphes déroulants ....................................................................................................................... 190 II.6.2. Graphes ........................................................................................................................................ 191

II.7. Cluster et nœud d’expression ................................................................................................................ 193 II.8. Somme de clusters et opérations sur les éléments de clusters ............................................................... 194 II.9. Résumé des fonctions de clusters ......................................................................................................... 195

Chapitre 6

I. Boucle For ..................................................................................................................................................... 200 I.1. Factorielle d’un nombre entier ............................................................................................................... 200 I.2. Equation de récurrence ........................................................................................................................... 202

I.2.1. Boucle For et registre à décalage .................................................................................................... 202 I.2.2. La boucle For et les tableaux .......................................................................................................... 211

II. Boucle While ................................................................................................................................................ 215

III. Boite de calcul ............................................................................................................................................ 216 III.1. Equation de récurrence ........................................................................................................................ 218 III.2. Limitation d’un signal entre des valeurs, minimale et maximale ........................................................ 219 III.3. Calcul de la moyenne et de la variance d’un signal aléatoire .............................................................. 220

IV. Structure Condition ................................................................................................................................... 222 IV.1. Structure à 2 conditions - limitation d’un signal ................................................................................. 222 IV.2. Structure à plusieurs conditions .......................................................................................................... 224

V. Structure Evénement .................................................................................................................................. 227 V.1. Gestion des propriétés d’un tracé ......................................................................................................... 230

V.1.1. Modification de propriétés d’objets graphiques ........................................................................... 230 V.1.2. Modification de la couleur du nuage des points ............................................................................ 231 V.1.3. Modification du type de marqueur sur le nuage de points ............................................................ 232 V.1.4. Gestion de l’appui sur le bouton stop ............................................................................................ 233 V.1.5. Gestion de l’épaisseur du trait ....................................................................................................... 234 V.1.6. Gestion de la couleur du texte de l’affichage des paramètres a et b .............................................. 234 V.1.7. Police des caractères de l’axe des abscisses et du titre du graphique ............................................ 235 V.1.8. Modification de la couleur de la droite de régression ................................................................... 235

V.2. Evénements liés au déplacement de la souris, dialogue utilisateur ....................................................... 237 V.2.1. Sortie de la souris dans la fenêtre du panel du VI ......................................................................... 238 V.2.2. Entrée de la souris dans la fenêtre du panel du VI ........................................................................ 238 V.2.3. Appui sur le bouton Stop............................................................................................................... 239 V.2.4. Fermeture de la face-avant ............................................................................................................ 240

Table des matières XV

VI. Structure Elément en place ....................................................................................................................... 241 VI.1. Opération sur les tableaux et waveforms ............................................................................................. 242 VI.2. Intérêt de la structure Elément en place .............................................................................................. 246

VI.2.1. Temps de calcul avec structure Elément en place ........................................................................ 246 VI.2.2. Temps de calcul sans structure Elément en place ........................................................................ 247

VII. Structure Séquence déroulée ................................................................................................................... 249 VII.1. Structure à 2 étapes ............................................................................................................................ 250 VII.2. Structure séquence déroulée à 3 étapes .............................................................................................. 252

VIII. Structure Séquence empilée ................................................................................................................... 253

IX. Le nœud MathScript ................................................................................................................................. 255 IX.1. Récupération d’une sinusoïde par filtrage passe-bande....................................................................... 255 IX.2. Interpolation exponentielle .................................................................................................................. 259

IX.2.1. Méthode de Newton ..................................................................................................................... 260 IX.2.2. Utilisation des VIs d’interpolation de LabVIEW......................................................................... 261 IX.2.3. Utilisation de la méthode des moindres carrés ............................................................................. 262

IX.3. Distributions, triangulaire et gaussienne, par la méthode de Box-Muller ........................................... 265 IX.4. Equation du 2nd degré ......................................................................................................................... 266 IX.5. Régulation proportionnelle et intégrale, PI.......................................................................................... 268

IX.5.1. Sous-VI du processus................................................................................................................... 269 IX.5.2. Sous-VI du régulateur PID .......................................................................................................... 270 IX.5.3. Programme principal de la régulation PID .................................................................................. 271 IX.5.4. Régulation PI dans une boucle de contrôle et simulation ............................................................ 272

Chapitre 7 I. Sous-VI d’un contrôleur proportionnel et intégral.................................................................................... 274

I.1. VI du régulateur PI ................................................................................................................................. 274 I.2. Edition de l’icône du sous-VI................................................................................................................. 275 I.3. Disposition des connecteurs des entrées-sorties du sous-VI ................................................................. 277

II. Sous-VI du processus du 1er ordre discret ............................................................................................... 279

III. Régulation d’un système du 1er ordre ..................................................................................................... 282 III.1. Réponse indicielle du système à réguler .............................................................................................. 282 III.2. Résultats de la régulation ..................................................................................................................... 283

IV. Sous-VI de limitation d’un signal ............................................................................................................. 284

V. Sous-VI du modèle de moteur à courant continu ..................................................................................... 287

VI. Sous-systèmes de simulation ..................................................................................................................... 291 VI.1. Création d’un sous-système de simulation .......................................................................................... 291 VI.2. Sous-système de simulation d’un pendule amorti ............................................................................... 291 VI.3. Sous-système de simulation d’un modèle de moteur DC .................................................................... 294

Chapitre 8 I. Régression linéaire ........................................................................................................................................ 298

I.1. Calcul scalaire des paramètres a et b ...................................................................................................... 298 I.2. Calcul matriciel ...................................................................................................................................... 300

XVI Table des matières

II. Interpolation exponentielle et logarithmique ........................................................................................... 302 II.1. Interpolation exponentielle ................................................................................................................... 302 II.2. Interpolation logarithmique .................................................................................................................. 305

III. Interpolation polynomiale d’une fonction sigmoïde ............................................................................... 307 III.1. Interpolation par la commande polyfit ................................................................................................ 307 III.2. Interpolation par la fonction Ajustement polynomial général ............................................................. 308

IV. Interpolation gaussienne ........................................................................................................................... 311

V. Interpolation par Splines ............................................................................................................................ 313 V.1. Utilisation du VI Cubic Splin Fit .......................................................................................................... 313 V.2. Utilisation de la commande interp1 du nœud MathScript .................................................................... 314

Chapitre 9 I. Le nœud MathScript .................................................................................................................................... 318

I.1. Définition et exemple ............................................................................................................................. 318 I.2. Import et export de scripts ...................................................................................................................... 322

I.2.1. Import ............................................................................................................................................. 322 I.2.2. Export ............................................................................................................................................. 327

I.3. Fonctions mathématiques intégrées dans le module MathScript ............................................................ 328 I.3.1. Surface 3D ...................................................................................................................................... 329 I.3.2. Courbe 3D ...................................................................................................................................... 332 I.3.3. Débogage du code d’un nœud MathScript...................................................................................... 333

I.4. Quelques exemples................................................................................................................................. 334 I.4.1. Réponse indicielle d’un système analogique du 2nd ordre ............................................................. 334 I.4.2. Transformée de Fourier .................................................................................................................. 335 I.4.3. Filtre FIR passe-bas ........................................................................................................................ 336

II. La fenêtre MathScript LabVIEW ............................................................................................................. 337 II.1. Description de ce module ..................................................................................................................... 337 II.2. Exemple ................................................................................................................................................ 341

III. Quelques fonctions de MathScript ........................................................................................................... 342 III.1. Fonctions relationnelles ....................................................................................................................... 342 III.2. Systèmes discrets ................................................................................................................................. 344

III.2.1. Utilisation du nœud MathScript ................................................................................................... 344 III.2.2. Utilisation de la fenêtre MathScript ............................................................................................. 345

IV. Calculs matriciels ....................................................................................................................................... 347 IV.1. Système matriciel déterminé ............................................................................................................... 347 IV.2. Système matriciel surdéterminé, identification d’un processus du 1er ordre ...................................... 349

V. Réponse indicielle de processus du 1er ordre et 2nd ordre ..................................................................... 353 V.1. Système du 1er ordre ............................................................................................................................ 353

V.1.1. Système du 1er ordre analogique .................................................................................................. 353 V.1.2. Système discret du 1er ordre ......................................................................................................... 354

V.2. Réponse indicielle d’un système du 2ème ordre .................................................................................. 355 V.2.1. Second ordre analogique ............................................................................................................... 355 V.2.2. Second ordre discret ...................................................................................................................... 358

VI. Fonctions graphiques ................................................................................................................................ 360 VI.1. Graphiques 2D .................................................................................................................................... 360 VI.2. Graphiques 3D .................................................................................................................................... 360

Table des matières XVII

VII. Appel de fonctions MathScript ............................................................................................................... 361

Chapitre 10 I. Propriétés d’une table Express .................................................................................................................... 366

II. Propriétés des onglets ................................................................................................................................. 371 II.1. Onglet afficheurs................................................................................................................................... 371 II.2. Onglet graphe des valeurs ..................................................................................................................... 372 II.3. Histogramme ......................................................................................................................................... 373 II.4. Diagramme ........................................................................................................................................... 373

II.4.1. Génération du signal et tracé de l’histogramme ............................................................................ 373 II.4.2. Utilisation des nœuds de propriété ................................................................................................ 375 II.4.3. Diagramme général ....................................................................................................................... 381 II.4.4. Gestion des propriétés d’un graphe ............................................................................................... 381 II.4.5. Nœuds de propriété de classe VI et classe Application ................................................................. 390

III. Les nœuds de méthode .............................................................................................................................. 393

Chapitre 11

I. Fichiers de type tableur ................................................................................................................................ 397 I.1. Sauvegarde d’un fichier tableur ............................................................................................................. 397 I.2. Lecture d’un fichier tableur .................................................................................................................... 398

II. Fichier texte ................................................................................................................................................. 400 II.1. VIs de la palette E/S sur fichiers ........................................................................................................... 400 II.2. VIs de type Express .............................................................................................................................. 404

II.2.1. Ecriture de fichier .......................................................................................................................... 404 II.2.2. Lecture du fichier .......................................................................................................................... 407

III. Fichiers binaires ........................................................................................................................................ 407 III.1. Sauvegarde dans un fichier binaire ...................................................................................................... 407 III.2. Lecture d’un fichier binaire ................................................................................................................. 409

IV. Fichiers de waveforms ............................................................................................................................... 410 IV.1. Ecriture et lecture dans une séquence déroulée ................................................................................... 410 IV.2. Lecture et écriture dans une séquence empilée ................................................................................... 411 IV.3. Export de la waveform dans un fichier tableur.................................................................................... 412 IV.4. Export de 3 waveforms ....................................................................................................................... 414

IV.4.1. Sous-VI générateur de 3 waveforms ............................................................................................ 414 IV.4.2. Export d’un tableau de waveforms .............................................................................................. 416

V. Fichiers TDMS ............................................................................................................................................ 417 V.1. Utilisation des VI Express .................................................................................................................... 417 V.2. VIs de la sous-palette TD en continu .................................................................................................... 420

V.2.1. Ecriture de fichiers TDMS ............................................................................................................ 421 V.2.2. Lecture de fichiers TDMS ............................................................................................................. 425 V.2.3. Propriétés d’un fichier TDMS ....................................................................................................... 425 V.2.4. Création de groupes et propriétés pour un fichier TDMS ............................................................. 426

VI. Export de données de LabVIEW vers Excel ........................................................................................... 429 VI.1. Menu Exporter par un clic droit .......................................................................................................... 429 VI.2. Utilisation d’un nœud de méthode ...................................................................................................... 431

XVIII Table des matières

VII. Fichiers Zip ............................................................................................................................................... 432 VII.1. Création d’un nouveau fichier Zip ..................................................................................................... 432 VII.2. Ajout du fichier Zip ........................................................................................................................... 432 VII.3. Fermeture du fichier Zip .................................................................................................................... 433

VIII. Fichiers XML .......................................................................................................................................... 434 VIII.1. Ecriture des fichiers XML ................................................................................................................ 434 VIII.2. Lecture des fichiers XML ................................................................................................................. 436

IX. Stockage de données sous différents formats .......................................................................................... 437 IX.1. Ecriture avec les VIs de stockage de données ..................................................................................... 437

IX.1.1. Ouverture, création d’un nouveau fichier .................................................................................... 437 IX.1.2. Définition des propriétés .............................................................................................................. 438

IX.2. Lecture avec les VIs de type Express .................................................................................................. 440

X. Gestion des répertoires ............................................................................................................................... 441

Chapitre 12

I. Le graphe déroulant ..................................................................................................................................... 444

II. Le graphe ..................................................................................................................................................... 446

III. Personnalisation des graphes et graphes déroulants .............................................................................. 447

IV. Courbes de Lissajous ................................................................................................................................. 452 IV.1. Graphe XY simple avec le graphe XY Express .................................................................................. 452 IV.2. Graphe XY simple avec le graphe XY ................................................................................................ 454

IV.2.1. Courbe Image de la lettre α .......................................................................................................... 454 IV.2.2. Lemniscate de Bernoulli .............................................................................................................. 455

IV.3. Courbes de Lissajous dans Graphe XY multiple ................................................................................. 457

V. Graphe numérique ...................................................................................................................................... 459

VI. Graphes en 3D ............................................................................................................................................ 460 VI.1. Surface en 3D ...................................................................................................................................... 460

VI.1.1. Graphe de surface en 3D du panel ............................................................................................... 460 VI.1.2. Palette graphisme et son du diagramme ....................................................................................... 463

VI.2. Surface paramétrique 3D ..................................................................................................................... 464 VI.3. Graphe mixte et numérique ................................................................................................................. 467

VII. Graphes spéciaux ..................................................................................................................................... 469 VII.1. Diagrammes à bâtons (stem) .............................................................................................................. 469 VII.2. Diagramme à barres ........................................................................................................................... 471 VII.3. Diagramme en camembert ................................................................................................................. 472 VII.4. Courbes 3D ........................................................................................................................................ 473 VII.5. Contours ............................................................................................................................................. 474

Chapitre 13 I. La boucle de contrôle et simulation ............................................................................................................ 478

II. Signal Generation ........................................................................................................................................ 480

Table des matières XIX

III. Signal Arithmetic ....................................................................................................................................... 481

IV. Lookup Tables............................................................................................................................................ 482

V. Utilities ......................................................................................................................................................... 484

VI. Graph Utilities............................................................................................................................................ 486

VII. Continuous Linear Systems ..................................................................................................................... 487 VII.1. Fonction de transfert et modèle d’état scalaire ................................................................................... 489 VII.2. Modèle d’état continu d’un double intégrateur .................................................................................. 492 VII.3. Modélisation d’un système masse - ressort avec frottements visqueux ............................................. 495

VIII. Discrete Linear Systems ......................................................................................................................... 497 VIII.1. Régulation I avec une équation de récurrence .................................................................................. 498

VIII.1.1. Sous-système de simulation du modèle du processus ............................................................... 498 VIII.1.2. Sauvegarde des résultats dans un fichier tableur ....................................................................... 499

VIII.2. Régulation PI d’un procédé décrit par un modèle d’état .................................................................. 500

IX. Controllers .................................................................................................................................................. 503

X. Model Hierarchy – Spécification de paramètres et lecture de signaux .................................................. 504 X.1. Spécification de paramètres .................................................................................................................. 506 X.2. Lecture de signaux ................................................................................................................................ 508 X.3. Spécification et lecture de paramètres .................................................................................................. 510

XI. Estimation .................................................................................................................................................. 512 XI.1. Filtre de Kalman - Modèle continu du 1er ordre ................................................................................. 513 XI.2. Filtre de Kalman discret - Estimation d’une constante ........................................................................ 514

Chapitre 14

I. Model Construction (construction de modèle) ........................................................................................... 518 I.1. Construction de fonctions de transfert.................................................................................................... 519 I.2. Moteur à courant continu ....................................................................................................................... 520

I.2.1. Réponse indicielle de la vitesse et du courant d’induit ................................................................... 520 I.2.2. Régulation PI avec pondération de la consigne .............................................................................. 522 I.2.3. Filtre de Kalman – Estimation du courant d’induit et de la vitesse angulaire................................. 524

II. Model Information (information sur les modèles) ................................................................................... 525 II.1. Fonction de transfert constante, vérification et spécification de propriétés .......................................... 526 II.2. Modèle d’état constant .......................................................................................................................... 527

III. Model Conversion (conversion de modèle) .............................................................................................. 528 III.1. Conversion d’une fonction de transfert en modèle d’état .................................................................... 528 III.2. Conversion modèle d’état discret en fonction de transfert .................................................................. 531 III.3. Modèle d’état, fonction de transfert, pôles, zéros, réponse indicielle .................................................. 533

IV. Model Interconnection (Interconnexion de modèles) ............................................................................. 536 IV.1. Ajout de fonctions de transfert ............................................................................................................ 536 IV.2. Bouclage négatif (contre-réaction) ...................................................................................................... 537

V. Time Response (temps de réponse) ............................................................................................................ 538 V.1. Fonction de transfert constante dans le diagramme .............................................................................. 539 V.2. Fonction de transfert définie dans un nœud MathScript ....................................................................... 540

XX Table des matières

VI. Frequency Response (réponse fréquentielle) ........................................................................................... 541

VII. Dynamic Characteristics (caractéristiques dynamiques) ..................................................................... 542

VIII. State-Space Model Analysis (analyse dans l’espace d’état) ................................................................ 544 VIII.1. Contrôlabilité et observabilité ........................................................................................................... 546 VIII.2. Modèles d’états similaires ................................................................................................................ 547

VIII.2.1. Similarité de 2 modèles d’état d’un système du 1er ordre ........................................................ 547 VIII.2.2. Circuit RLC ............................................................................................................................... 547

IX. Implementation .......................................................................................................................................... 550 IX.1. Réponse indicielle d’un processus discret du 1er ordre ....................................................................... 551 IX.2. Filtre de Kalman discret ...................................................................................................................... 552 IX.3. Commande par retour d’état ................................................................................................................ 555

IX.3.1. Régulation autour de l’origine ..................................................................................................... 555 IX.3.2. Régulation autour d’une référence non nulle ............................................................................... 558

Chapitre 15

I. Identification paramétrique ......................................................................................................................... 560 I.1. Indentification d’une fonction de transfert discrète ................................................................................ 562 I.2. Identification d’un modèle d’état discret................................................................................................ 563 I.3. Identification d’une fonction de transfert par un VI de type Express ..................................................... 565 I.4. Identification d’un modèle linéaire général ............................................................................................ 567 I.5. Identification des modèles ARX et ARMAX ......................................................................................... 571 I.6. Identification du modèle AR (AutoRégréessif) ...................................................................................... 573

II. Identification par métodes récursives – Modèle de Box-Jenkins ............................................................ 575

III. Identification par Grey-Box ..................................................................................................................... 578

IV. Nonparametric Model Estimation (estimation non paramétrique) ....................................................... 581

V. Model Management (gestion des modèles) ................................................................................................ 583 V.1. Exemple 1 – Management .................................................................................................................... 583 V.2. Exemple 2 – Management .................................................................................................................... 586

VI. Dataprocessing (traitement des données) ................................................................................................ 588

VII. Model Validation ...................................................................................................................................... 589

VIII. Model Conversion ................................................................................................................................... 591 VIII.1. Exemple 1 - Model Conversion ........................................................................................................ 591 VIII.2. Exemple 2 - Model Conversion ........................................................................................................ 594

IX. Model Analysis ........................................................................................................................................... 595

X. Utilities (Utilitaires) ..................................................................................................................................... 597

Chapitre 16 I. PID classique et processus du second ordre ............................................................................................... 602

I.1. PID analogique ....................................................................................................................................... 603 I.2. PID discret.............................................................................................................................................. 605

Table des matières XXI

II. Régulation PID de type académique ......................................................................................................... 608

III. Advanced PID ............................................................................................................................................ 609

IV. Sous-système de simulation d’un PID parallèle ...................................................................................... 612

V. Applications ................................................................................................................................................. 613 V.1. Régulation PI analogique ...................................................................................................................... 613 V.2. Régulation PID ..................................................................................................................................... 615 V.3. Discrétisation d’un régulateur PI analogique par la méthode de Tustin ............................................... 616 V.4. Régulateur PI discret sous sa forme parallèle ....................................................................................... 617 V.5. Régulateur PID discret parallèle ........................................................................................................... 618

VI. Régulation de position – Moteur à courant continu ............................................................................... 621 VI.1. Réponse indicielle de vitesse et de position ........................................................................................ 622 VI.2. Régulation de la vitesse angulaire par placement de pôles .................................................................. 623

VI.2.1. Compensation de pôles, placement de pôles avec action intégrale .............................................. 623 VI.2.2. Placement de pôles dans l’espace d’état ...................................................................................... 625 VI.2.3. Régulation PID de la position ...................................................................................................... 631

VII. Modélisation d’un système multivariable .............................................................................................. 632 VII.1. Simulation et contrôle d’un système multivariable ............................................................................ 632 VII.2. Fonction de transfert multivariable .................................................................................................... 633 VII.3. Réponses indicielles du système multivariable .................................................................................. 636 VII.4. Régulation PID du système multivariable .......................................................................................... 637

Chapitre 17 I. Principe fondamental du contrôle flou ....................................................................................................... 640

I.1. Définition d’un système flou .................................................................................................................. 640 I.2. Variables linguistiques ........................................................................................................................... 641 I.3. Fonctions d’appartenance ....................................................................................................................... 641 I.4. Règles floues .......................................................................................................................................... 642

II. Etapes de mise en œuvre d’un contrôleur flou ......................................................................................... 643 II.1. Etape de fuzzification ........................................................................................................................... 643 II.2. Etape d’inférence .................................................................................................................................. 644 II.3. Etape de défuzzification ........................................................................................................................ 647

III. Création, modification et sauvegarde d’un système flou ....................................................................... 648 III.1. Fonctions d’appartenance des variables d’entrée et sortie ................................................................... 648 III.2. Edition des règles floues ...................................................................................................................... 652 III.3. Description, rapport HTML du système flou ...................................................................................... 653

IV. Modification d’un système existant .......................................................................................................... 655 IV.1. Modification d’une fonction d’appartenance ...................................................................................... 655 IV.2. Modification des règles ....................................................................................................................... 656

V. Création d’un système flou par des VIs .................................................................................................... 657

VI. Régulateur flou .......................................................................................................................................... 660 VI.1. Sans intégration ................................................................................................................................... 660 VI.2. Avec intégration ................................................................................................................................. 662

VII. Régulation floue de l’angle d’un pendule inversé .................................................................................. 663 VII.1. Modèle du pendule ............................................................................................................................. 663 VII.2. Sous-système du pendule ................................................................................................................... 664

XXII Table des matières

VII.3. Réponse impulsionnelle du pendule................................................................................................... 666 VII.4. Test du contrôleur flou ....................................................................................................................... 667 VII.5. Régulation floue de l’angle du pendule ............................................................................................ 669

Chapitre 18

I. Résolution d'équations non linéaires .......................................................................................................... 676 I.1. Résolution d'équations non linéaires à une variable. .............................................................................. 676 I.2. Résolution de systèmes d'équations non linéaires .................................................................................. 679

II. Résolution d'équations et de systèmes différentiels.................................................................................. 681 II.1. Equations différentielles du premier ordre ............................................................................................ 681

II.1.1. Méthode d'Euler ............................................................................................................................ 681 II.1.2. Méthodes de Runge-Kutta d'ordre 2 et 4 ....................................................................................... 683

II.2. Systèmes différentiels d'ordre 1 ............................................................................................................ 687 II.2.1. Méthode d'Euler ............................................................................................................................ 688 II.2.2. Méthode de Runge-Kutta d'ordre 4 ............................................................................................... 694

III. Résolution de système d’équations par des VIs de LabVIEW .............................................................. 705 III.1. Résolution par l’algorithme d’Euler .................................................................................................... 705 III.2. Résolution par l’algorithme de Runge-Kutta d’ordre 4 ....................................................................... 708 III.3. Système linéaire – solution symbolique et numérique ........................................................................ 709

Chapitre 19

I. Calcul de moyenne, variance, mode et médiane......................................................................................... 712 I.1. Moyenne et variance .............................................................................................................................. 712 I.2. Ecarts, gamme et centile ........................................................................................................................ 713 I.3. Mode et médiane .................................................................................................................................... 717 I.4. Moments ................................................................................................................................................ 718

II. Coefficient de corrélation ........................................................................................................................... 719 II.1. Coefficient de corrélation linéaire ........................................................................................................ 719 II.2. Tracé d’histogramme ............................................................................................................................ 723 II.3. Kurtosis et Skewness d’une distribution ............................................................................................... 724

II.3.1. Kurtosis ou indicateur d’écrasement ............................................................................................. 724 II.3.2. Coefficient de Skewness ou de d’asymétrie .................................................................................. 725 II.3.3. Exemple ......................................................................................................................................... 725

III. Lois de probabilité ..................................................................................................................................... 727 III.1. Lois continues ..................................................................................................................................... 727

III.1.1. Loi de Gauss ................................................................................................................................ 727 III.1.2. Loi Gamma .................................................................................................................................. 728 III.1.3. Loi exponentielle ......................................................................................................................... 729 III.1.4. Loi du khi-2 ou khi carré.............................................................................................................. 731

III.2. Lois discrètes ....................................................................................................................................... 732 III.2.1. Loi de Bernoulli ........................................................................................................................... 732 III.2.2. Loi Binomiale .............................................................................................................................. 733

IV. Théorème central limite ou théorème de limite centrale ........................................................................ 734

V. Covariance et matrice de covariances ....................................................................................................... 735 V.1. Covariance de 2 variables aléatoires ..................................................................................................... 735

V.1.1. Calcul de la covariance à partir du coefficient de corrélation linéaire .......................................... 735 V.1.2. Estimation de la corrélation .......................................................................................................... 736

Table des matières XXIII

V.2. Matrice de covariances ......................................................................................................................... 737 V.2.1. Application pour la taille et l’âge .................................................................................................. 738 V.2.2. Application pour les dimensions d’une pièce usinée .................................................................... 739 V.2.3. Matrice de covariances des bruits blancs ...................................................................................... 740 V.2.4. Matrice de covariances d’un bruit blanc et d’un signal sinusoïdal ................................................ 741 V.2.5. Matrice de covariances d’un bruit blanc et d’un bruit rose ........................................................... 742

Chapitre 20

I. Régulateur proportionnel et Intégral PI avec les VIs express .................................................................. 746

II. Commandes PI et PID ................................................................................................................................ 748 II.1. Commande Proportionnelle, Intégrale et Dérivée, PID ........................................................................ 748 II.2. Commande proportionnelle et intégrale, PI numérique ........................................................................ 750

III. Le PID de « Conception de contrôle et simulation » .............................................................................. 754 III.1. Utilisation du VI PID de la palette Contrôle et simulation .................................................................. 754 III.2. PID analogique avec filtrage de la dérivée .......................................................................................... 755

IV. Commande linéaire quadratique avec intégration LQI ......................................................................... 757

V. Commande RST .......................................................................................................................................... 761 V.1. Utilisation des VIs du langage G .......................................................................................................... 762 V.2. Utilisation du nœud MathScript et une boite de calcul ......................................................................... 765

VI. Utilisation de l’outil « Conception de contrôle et simulation » .............................................................. 766 VI.1. Régulation PID série analogique ......................................................................................................... 766 VI.2. Régulation numérique par compensation de pôles .............................................................................. 768

VII. Régulation par le choix de la FTBF ........................................................................................................ 770 VII.1. Utilisation d’un nœud MathScript ...................................................................................................... 771 VII.2. Utilisation d’une boucle For et une boite de calcul ............................................................................ 772

VIII. Commande asymptotique et optimale dans l'espace d'état ................................................................. 774 VIII.1. Commande asymptotique par placement de pôles ............................................................................ 774 VIII.2. Commande optimale dans l'espace d'état .......................................................................................... 777

VIII.2.1. Régulation autour d'une consigne nulle .................................................................................... 778 VIII.2.2. Régulation autour d'une consigne constante non nulle .............................................................. 780 VIII.2.3. Régulation autour d'une consigne variant dans le temps ........................................................... 781

Chapitre 21 I. Extraction d’une sinusoïde par filtrage ...................................................................................................... 786

II. Filtres FIR et IIR ........................................................................................................................................ 789 II.1. Filtres FIR ............................................................................................................................................. 790

II.1.1. Filtre FIR de type Express ............................................................................................................. 790 II.1.2. Réponse impulsionnelle - Filtre dérivateur ................................................................................... 792 II.1.3. Réponse indicielle – Filtre dérivateur ............................................................................................ 793 II.1.4. FFT - filtre dérivateur .................................................................................................................... 794 II.1.5. FFT - filtre moyenneur .................................................................................................................. 795 II.1.6. Filtre FIR définies par ses spécifications fréquentielles ................................................................ 796 II.1.7. FFT - filtre FIR quelconque .......................................................................................................... 798 II.1.8. Filtrage d’un signal par un filtre FIR ............................................................................................. 799

II.2. Filtres IIR .............................................................................................................................................. 800

XXIV Table des matières

II.2.1. Pôles et zéros, diagramme de Bode et réponse indicielle .............................................................. 800 II.2.2. Réponse impulsionnelle d’un filtre IIR ......................................................................................... 802 II.2.3. Réponse indicielle ......................................................................................................................... 803 II.2.4. Diagramme de Nyquist .................................................................................................................. 804 II.2.5. Filtres numériques de Bessel et Chebyshev .................................................................................. 805 II.2.6. Filtre de Yulewalker ...................................................................................................................... 808 II.2.7. Filtre Elliptique et Butterworth – Filtrage de la somme de 3 sinusoïdes ....................................... 809

III. Filtres analogiques ..................................................................................................................................... 811 III.1. Circuit RLC ......................................................................................................................................... 811 III.2. Détermination du filtre de Butterworth par son expression théorique ................................................. 813

III.2.1. Utilisation d’un nœud MathScript ................................................................................................ 816 III.2.2. Utilisation des VIs du langage G de LabVIEW ........................................................................... 817

IV. Filtrage d’un signal aléatoire .................................................................................................................... 818 IV.1. Filtre moyenneur – nœud de rétroaction ............................................................................................. 818 IV.2. Filtre moyenneur dans l’espace d’état ................................................................................................. 820

V. Filtrage adaptatif ......................................................................................................................................... 822 V.1. Algorithme LMS - Filtre FIR d’horizon 2 ............................................................................................ 824

V.1.1. Utilisation des VIs du langage G................................................................................................... 824 V.1.2. Utilisation du nœud MathScript .................................................................................................... 825 V.1.3. Utilisation des VIs de calcul matriciel .......................................................................................... 826

V.2. Algorithme RLS - Filtre FIR d’horizon 3 ............................................................................................. 827 V.3. Filtre antibruit ....................................................................................................................................... 828

VI. Identification de paramètres inconnus .................................................................................................... 830

VII. Prédiction de signal .................................................................................................................................. 832

Chapitre 22

I. Filtre FIR moyenneur .................................................................................................................................. 836 I.1. Réponse indicielle .................................................................................................................................. 836

I.1.1. Utilisation du nœud de rétroaction.................................................................................................. 836 I.1.2. Palette Conception de contrôle et simulation.................................................................................. 837

I.2. Statistiques des bruits d’entrée et de sortie ............................................................................................ 838 I.3. Réponse en fréquences ........................................................................................................................... 839

II. Filtres IIR et FIR ........................................................................................................................................ 843

III. Signaux stochastiques monodimensionnels ............................................................................................. 845 III.1. Corrélation et intercorrélation ............................................................................................................. 845

III.1.1. Utilisation des nœuds MathScript ................................................................................................ 845 III.1.2. Utilisation des VIs LabVIEW ...................................................................................................... 851

III.2. Densité spectrale énergétique .............................................................................................................. 852

IV. Systèmes et signaux stochastiques multidimensionnels .......................................................................... 855 IV.1. Evolution des états x1, x2 et signal de sortie du système .................................................................... 856 IV.2. Evolution des variances des composantes d’états et celle de la sortie ................................................. 857

V. Estimation de signaux et de modèles de systèmes discrets ....................................................................... 857 V.1. Algorithme des moindres carrés récursifs ............................................................................................ 857 V.2. Filtrage de Kalman ............................................................................................................................... 866

V.2.1. Estimation d'une constante ............................................................................................................ 868 V.2.2. Estimation de l'état d'un processus dynamique ............................................................................. 869

Table des matières XXV

VI. Régime permanent du filtre de Kalman .................................................................................................. 879

VII. Prédicteur de Kalman .............................................................................................................................. 882 VII.1. Génération du signal par la fonction de transfert - Nœud MathScript ............................................... 883 VII.2. Génération du signal par l’équation de récurrence - Boite de calcul.................................................. 883 VII.3. Génération du signal par le modèle d’état .......................................................................................... 884 VII.4. Génération du signal par le prédicteur de Kalman ............................................................................. 886

Partie I

Apprentissage de LabVIEW

Partie I. Chapitre 1 - Prise en main de LabVIEW

I. Résolution de systèmes d’équations linéaires I.1. Système déterminé I.2. Système surdéterminé II. Régression linéaire III. Régression exponentielle et polynomiale IV. Equations aux récurrences V. Filtres numériques V.1. Filtre de Butterworth V.2. Filtre à réponse impulsionnelle finie (Finite Impulse Response, FIR) VI. Régulation VI.1. Réponse indicielle d’un processus du 1er ordre VI.2. Régulation proportionnelle et intégrale, PI VII. Analyse numérique VII.1. Régression linéaire par la méthode de Newton-Raphson VII.2. Résolution d’équations différentielles VII.2.1. Méthode d’Euler VII.2.2. Méthode de Runge-Kutta VIII. Probabilités et statistique VIII.1. Théorème central limite VIII.2. Corrélation VIII.2.1. Calcul théorique de la corrélation et de la covariance VIII.2.2. Corrélation par le calcul matriciel IX. Opérations de base d’E/S sur fichiers IX.1. Fichiers texte

IX.1.1. Ecriture IX.1.2. Lecture

IX.2. Fichiers tableur X.2.1. Sauvegarde X.2.2. Lecture IX.3. Fichier de mesures IX.3.1. En-tête du fichier IX.3.2. Génération des signaux IX.3.3. Enregistrement des signaux IX.3.4. Tracé des signaux

1DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _1,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

2 Partie I / Apprentissage de LabVIEW

I. Résolution de systèmes d’équations linéaires

On se propose de résoudre un système d’équations linéaires de type BxA .

I.1. Système déterminé

La première solution consiste à multiplier à gauche les 2 termes de l’égalité par l’inverse de la matrice A. Si cette matrice est inversible (carrée avec déterminant non nul), la solution est : BAx 1

0 .

Pour afficher les résultats d’un calcul, exemple de la matrice inverse de A, nous procédons

comme ci-dessous. On se positionne en sortie du VI « inverse Matrix » et avec le bouton droit de la souris, on choisit le menu Créer Indicateur. On obtient la matrice « inv(A) ».

Chapitre 1 / Prise en main 3

Sur la face-avant, nous affichons les entrées A et B du VI et les sorties qui sont la solution x du système A x = B et l’inverse de la matrice A.

Dans cet exemple, nous cherchons la solution du système suivant :

1021.0124224

321

321

321

xxxxxxxxx

Dans l’exemple suivant, la matrice A et le tableau B sont définis directement comme des

constantes dans le diagramme. Nous utilisons le VI « Solve LinearEquations.vi ». Le système de 2 équations et 2 inconnues que l’on cherche à résoudre est le suivant :

122

21

21

xxxx

Dans le panel (face-avant), nous affichons la solution obtenue par la méthode inv(A)*B

et celle du bloc LabVIEW Solve Linear Equations.vi.

4 Partie I / Apprentissage de LabVIEW

Nous trouvons, évidemment, la même solution par ces 2 méthodes.

Nous obtenons la même solution :

01

x

Dans le VI suivant, nous utilisons la méthode des moindres carrés, indispensable pour résoudre des systèmes sur ou sous déterminés.

La méthode des moindres carrés permet d’obtenir la solution par : BAAAx TT 10 .

Nous obtenons la même solution que pour le programme « deter_syst11.vi ».

Chapitre 1 / Prise en main 5

I.2. Système surdéterminé

Lorsqu’un système linéaire possède plus d’équations que d’inconnues, il est dit surdéterminé.

La matrice A n’est pas inversible. En multipliant à gauche les 2 termes de l’égalité par la transposée de A, nous avons :

BAxAA TT

On multiplie à gauche par l’inverse de AAT et on obtient la solution suivante :

BAAAx TT 1)(

Cette méthode de résolution est aussi valable pour un système déterminé. Soit le système linéaire suivant à 3 équations et 2 inconnues.

421

1

yxyxyx

BXA avec yx

X

La solution X qu’on obtient est celle donnée par le modèle A X qui passe au mieux par les

valeurs du tableau constant B, au sens des moindres carrés. Cette solution est celle qui minimise la somme des carrés des erreurs, soit :

18128463

)42()1()1(22

2222

yxxyyx

yxyxyxe

Cette variance est nulle lorsque ses dérivées partielles sont nulles,

0)()( 22

ye

xe

Dans cet exemple, nous avons :

0846)( 2

yxxe

012412)( 2

xyye

, soit 033 xy

Il suffit donc de résoudre le système déterminé suivant

34

3123

yx

6 Partie I / Apprentissage de LabVIEW

La solution de ce système est exactement celle obtenue par la méthode des moindres carrés, soit :

7142.08571.0

yx

Nous traçons dans le VI suivant la surface qui représente la somme des carrés des erreurs

ci-dessus. La face-avant ne comporte que le cluster d’erreur. Dans le diagramme, nous utilisons la commande mesh dans un script MATLAB pour tracer la surface de la somme des carrés des erreurs.

Nous obtenons la figure suivante dont le minimum correspond aux valeurs (x, y) de la

solution du système d’équations. La commande contour permet de tracer les contours de la surface Z=f(x,y) dans le plan

Oxy. Dans notre cas, on spécifie 1000 contours ou lignes de niveau.

Chapitre 1 / Prise en main 7

Pour entourer la solution, nous affichons les contours de cette surface.

Avec la commande ginput, dans la fenêtre MathScript, nous obtenons : >> ginput ans 0.8871 -0.7456 Ces valeurs sont très proches de celles de la solution analytique. La surface représentant la somme des carrés des erreurs est programmée dans le nœud

MathScript suivant.

8 Partie I / Apprentissage de LabVIEW

Dans ce diagramme, nous utilisons le VI 3D Parametric Surface.vi de la sous-palette Graphisme/Son Propriétés 3D pour afficher cette surface 3D.

Nous obtenons la surface suivante. Avec le VI Basic Properties.vi nous pouvons

choisir le type de tracé avec la propriété plot_style et le taux de transparence par transparency.

Nous définissons un cluster d’entrée constant à l’entrée, après avoir relié les entrées/sorties

d’erreur des VIs consécutifs, nous affichons la sortie d’erreur du dernier VI dans error out.

Dans le menu local du graphe, avec Propriétés de l’option CWGraph3D, nous pouvons

choisir quelques propriétés du graphe.

Chapitre 1 / Prise en main 9

Pour approcher la solution théorique, nous définissons des curseurs que nous pouvons déplacer avec les touches du clavier.

La solution du système est donnée dans le VI suivant, par la méthode des moindres carrés.

Nous trouvons parfaitement les mêmes valeurs que précédemment.

Les fonctions matricielles d’inversion, transposition et multiplication, se trouvent dans la

sous-palette Linear Algebra (algèbre linéaire).

10 Partie I / Apprentissage de LabVIEW

Les opérations suivantes permettent de réaliser les opérations sur les tableaux ou matrices.

La pseudo inverse d’une matrice A, en utilisant le bloc PseudoInv, se calcule comme

suit : pinv(A) = (ATA)-1 AT

Ainsi, la solution du système A x = B, peut être calculée par : x = pinv(A)*B

Pour réaliser une matrice constante, il suffit de déplacer une constante dans le tableau vide

obtenu. Ensuite, pour réaliser une matrice à 2 dimensions, on choisit l’option « Add Dimension » par le bouton droit de la souris.

.

Dans cette palette, nous avons toutes les fonctionnalités de gestion des tableaux

Chapitre 1 / Prise en main 11

Quand nous travaillons dans un domaine particulier, nous avons automatiquement accès à sa palette, comme ici Array Palette pour les tableaux.

II. Régression linéaire

Avec 2 séries de mesures, X et Y, la régression linéaire consiste à exprimer Y selon un modèle linéaire en fonction de X. La méthode généralement utilisée est celle des moindres carrés pour laquelle, on doit minimiser la variance (somme des carrés des erreurs) des résidus entre les mesures iy et les valeurs données par le modèle )( bxa i .

La somme des carrés (variance) des erreurs à minimiser est donnée par :

n

iii

n

ii bxayeS

1

2

1

2 )(

La valeur de S est minimum lorsque ses dérivées s’annulent par rapport aux paramètres a et b. La solution est obtenue en résolvant les 2 équations, soit :

0aS 0)(

1

n

iiii bxayx

n

i

n

iii

n

iii xbxayx

1 1

2

10

0bS 0)(

1

n

iii bxay 0

11bnxay

n

ii

n

ii

En divisant par n, nous obtenons le système suivant de 2 équations aux inconnues a et b suivantes:

n

i

n

iii

n

iii xbxayx

1 1

2

10

xayb

En remplaçant b par sa valeur dans la première équation, nous obtenons :

n

i

n

ii

i

n

i

n

i

n

iii

ii

n

xx

n

yxyx

a

1

1

2

2

1

1 1

)(

)()(

n

xa

n

yb

n

ii

n

ii

11

Dans le VI suivant, nous générons des données de type : y = a x + b + 3 randn,

soit une droite à laquelle on superpose un bruit gaussien d’écart-type 3.

12 Partie I / Apprentissage de LabVIEW

Dans le panel, nous affichons les données bruitées et la droite obtenue par la régression linéaire à l’aide du VI Linear Fit.vi.

Les opérations sur les tableaux telles que la somme, produit, division sont dans la palette Numeric suivante.

Sur le panel, nous affichons des paramètres slope et intercept, correspondant

respectivement, aux paramètres a et b.

Chapitre 1 / Prise en main 13

Dans l’exemple suivant, nous utilisons un script MATLAB dans lequel on programme les

expressions donnant les paramètres a et b de la droite obtenue par la régression linéaire.

Les paramètres a et b sont équivalents à ceux du modèle exponentiel. Ils doivent avoir les mêmes valeurs. Le script MATLAB se trouve dans Mathematics/Scripts & Formulas/Script

Nodes.

14 Partie I / Apprentissage de LabVIEW

En plaçant le pointeur de la souris sur le bord du script, on peut ajouter ou supprimer une

entrée ou sortie que l’on nommera comme les entrées x, y ou les sorties a et b.

Nous comparons, de même que précédemment, les valeurs obtenues par le VI Linear

Fit.vi à celles données par les expressions MATLAB. Sur la face-avant, nous remarquons que ces valeurs sont parfaitement égales.

Chapitre 1 / Prise en main 15

Les différents types de régression, linéaire, exponentielle, etc., sont réalisés par les blocs ou VIs de la palette Fitting.

III. Régression exponentielle et polynomiale

Nous considérons les 2 séries de mesures suivantes:

28.036.045.056.058.063.070.079.089.095.0

00.600.400.300.290.150.10.150.020.010.0

yx

Le tracé de y = f(x) possède une allure exponentielle de la forme y = a ebx. Nous

pouvons passer par une régression linéaire si on considère le logarithme de y. Nous obtenons ainsi : log(y) = log(a) + b x, soit la forme linéaire z = + x. Il

suffit de réaliser une régression linéaire pour obtenir les paramètres et . Les paramètres a et b du modèle exponentiel sont obtenus par a=e et b= . Les tableaux d’entrée et de sortie sont récupérés de la matrice de mesures par le script

MATLAB.

16 Partie I / Apprentissage de LabVIEW

On réalise une régression linéaire avec le bloc Linear Fit.vi pour le tableau log(y).

Avec le VI Curve Fitting, nous pouvons réaliser une régression linéaire, quadratique, spline ou polynomiale.

Dans cet exemple, nous utilisons l’interpolation polynomiale. Ce VI permet d’afficher le

signal de l’interpolation, les coefficients du polynôme ainsi que la variance de l’erreur d’interpolation.

Nous affichons les données de mesure ainsi que la droite de régression sur le même

graphique, les valeurs des paramètres et ainsi que les paramètres a et b du modèle exponentiel.

Chapitre 1 / Prise en main 17

Dans le panel, nous affichons les résultats de ces 2 interpolations ainsi que les résidus.

Dans cet exemple, nous réalisons directement la régression exponentielle de la série de

mesures y en fonction de x. Il suffit de retrouver les paramètres a et b du modèle exponentiel y = a ebx. Nous

utilisons le VI Exponential Fit.vi avec la méthode des moindres carrés (Least Squares).

Dans ce VI, nous calculons les paramètres a (amplitude) et b (damping) du modèle exponentiel grâce au VI Unconstrained Exponential Fit.vi.

Nous affichons, sur la face-avant, les mesures x,y ainsi que le tracé du modèle exponentiel a ebx obtenu par régression exponentielle.

18 Partie I / Apprentissage de LabVIEW

Nous obtenons pratiquement les mêmes valeurs des paramètres a et b que dans la méthode

précédente.

IV. Equations aux récurrences

Dans ce VI, nous nous proposons de chercher la solution de l’équation aux récurrences suivante :

)2(5.0)1(8.01)( kxkxkx

Nous allons utiliser 3 méthodes. La première consiste à utiliser les blocs élémentaires de calcul.

Chapitre 1 / Prise en main 19

Le panel montre les régimes, transitoire et permanent.

Les 2 autres méthodes, presque équivalentes consistent en la programmation de l’équation

de récurrence par les blocs Formula et Formula Node. Ces 2 méthodes nécessitent la mise en place d’un registre à décalage dans la boucle For

afin de mémoriser les anciennes valeurs x(k-1) et x(k-2). Ces valeurs sont initialisées à 10. Nous allons utiliser 2 méthodes de résolution : Le bloc Formula et la boite de calcul

Formula Node.

20 Partie I / Apprentissage de LabVIEW

Les 2 méthodes utilisent une boucle For mais avec des nombres d’échantillons différents (100 pour Formula et 200 pour Formula Node).

Les cadences d’échantillonnage sont aussi différentes (0.1 ms pour Formula et 10 ms pour Formula Node). Sur la face-avant, nous observons des régimes transitoires différents mais nous obtenons parfaitement la même valeur en régime permanent.

La même équation récurrente peut être résolue en utilisant le nœud de rétroaction

« Feedback Node » qui joue le rôle d’opérateur retard d’une période d’échantillonnage z-1.

Par un clic droit puis le choix de « Appearance/Z-Transform Delay Node »,

nous pouvons modifier la forme du nœud en faisant apparaître sa présentation avec l’opérateur retard z-1.

Chapitre 1 / Prise en main 21

Nous obtenons la même valeur en régime permanent.

V. Filtres numériques

V.1. Filtre de Butterworth

Le filtre de Butterworth est réalisé par le VI Butterworth Filter.vi de la sous-palette Traitement du signal Filtres Butterworth.

22 Partie I / Apprentissage de LabVIEW

Dans le diagramme suivant, nous mettons en œuvre le filtrage d’un signal carré par un filtre de Butterworth d’ordre 2. Le bloc Simule Signal permet de simuler différents types de signaux auxquels on peut superposer un bruit blanc, de distribution gaussienne, uniforme, etc.

L’amplitude et la fréquence du signal carré d’entrée sont spécifiées par les contrôles Amplitude et fréquence au niveau du panel tandis que d’autres gardent leurs valeurs par défaut (Phase=0, Duty Cycle=50%).

Le bloc Simulate Signal qui génère le signal carré appartient à la sous-palette Input

de Express.

Pour ce filtre, on doit spécifier 2 fréquences de coupure, basse et haute (low cutoff

freq: fl et high cutoff freq: fh) ainsi que l’ordre n. Le signal de sortie suit une dynamique du second ordre puisqu’on a choisi l’ordre n=2.

Chapitre 1 / Prise en main 23

Il possède un seul dépassement à chaque front du signal d’entrée. Le gain statique est égal à l’unité.

V.2. Filtre à réponse impulsionnelle finie (Finite Impulse Response, FIR)

Dans le VI suivant, nous utilisons le bloc FIR Filter.vi de la palette Filters de Signal Processing.

Les coefficients de ce filtre sont définis par un tableau constant. Dans notre cas, ce filtre possède la fonction de transfert suivante :

21)(

11 zzH

Ce qui correspond à la relation de récurrence :

)1()(21)( kxkxky

La valeur de la sortie à l’instant kT est la moyenne des valeurs précédentes du signal

d’entrée. Le signal d’entrée est un bruit blanc que l’on choisira de moyenne nulle et de variance

unité. Pour produire ce signal aléatoire, nous utilisons le bloc Simulate Signal par lequel on

génère un signal constant de valeur nulle auquel on superpose un bruit blanc d’écart-type unité et de moyenne nulle.

24 Partie I / Apprentissage de LabVIEW

On calcule l’écart-type, la moyenne du bruit d’entrée ainsi que ceux en sortie. Le tracé de l’histogramme du signal de sortie se fait grâce au bloc Create Histogram

que l’on trouve dans la palette Probability & Statistics Palette.

Le calcul théorique de la variance et la moyenne du signal de sortie donne :

et

Le filtre FIR moyenneur permet de diviser par 2 la variance du bruit de sortie.

Chapitre 1 / Prise en main 25

Le filtre ne change pas la distribution d’un signal, nous remarquons le bruit en sortie est

gaussien comme le signal d’entrée. La moyenne est conservée, égale à celle du signal d’entrée tandis que sa variance est

divisée par 2.

Nous avons programmé l’expression littérale donnant la récurrence de ce filtre, soit :

)1()(21)( kxkxky .

Le retard est réalisé par le nœud de rétroaction dont on change la direction.

26 Partie I / Apprentissage de LabVIEW

La distribution est aussi une gaussienne centrée pour cette autre expression de ce filtre FIR moyenneur.

VI. Régulation

VI.1. Réponse indicielle d’un processus du 1er ordre

On se propose de programmer un VI qui permet de modéliser un système du 1er ordre de fonction de transfert :

pH

pH1

)( 0

avec 0H gain statique, constante de temps. Sa discrétisation donne la fonction de transfert en z suivante :

)()(

1)( 1

1

111

kuky

zazbzH

avec T

ea1 , le pôle du système échantillonné à la période T, et )1( 101 aHb avec la conservation du gain statique par l’échantillonnage.

Les échantillons du signal de sortie y(k) sont donnés en fonction de ceux du signal de

commande u(k) par l’équation de récurrence suivante :

)1()1()( 11 kubkyaky

Chapitre 1 / Prise en main 27

C’est cette relation que nous allons programmer pour modéliser le système à réguler. Dans le VI suivant, nous nous proposons de tracer la réponse indicielle. Pour cela, nous

transformons le VI ci-dessous en sous-VI que nous utilisons afin de tracer la réponse indicielle. Ce sous-VI permet d’estimer la valeur de la sortie à l’instant discret k, y(k), connaissant la sortie à l’instant k-1, y(k-1) ainsi que la commande appliquée à l’instant k-1, u(k-1). Les paramètres a1 et b1 sont aussi des entrées de ce sous-VI au même titre que y(k-1) et u(k-1).

Les paramètres a1 et b1 sont assemblés dans un Cluster (Cf. Chapitre Clusters)

dans la face-avant ou panel avant d’être désassemblés dans le diagramme pour être connectés au sous-VI « 1er_ordre.vi» .

Les entrées/sorties sont déterminées par des registres à décalage. Pour pouvoir tracer la réponse indicielle, nous appliquons la valeur 1 à u(k). La valeur initiale de la commande et celle de la sortie sont toutes initialisées à 0. La boucle For permet de tracer 50 échantillons de cette réponse indicielle.

Le panel contient le cluster des paramètres ainsi que le tracé de la réponse indicielle.

28 Partie I / Apprentissage de LabVIEW

Grâce au curseur, on trouve un gain statique de 5 parfaitement égal à la valeur théorique :

58.01

11 1

1

ab

VI.2. Régulation proportionnelle et intégrale, PI

On utilise le système du 1er ordre précédent de gain statique H0 = 5. Le régulateur PI est défini par la fonction de transfert suivante :

pK

KpD ip)(

Pour obtenir l’équivalent numérique, nous remplaçons l’opérateur p de dérivation par son équivalent numérique 11 z .

La version numérique du régulateur est :

1

1

11

11)(

zzKKK

zK

KzD ppiip

Avec (k) = r(k) – y(k), avec r(k) le signal de consigne ou de référence.

L’équation de récurrence liant la commande u(k) à l’erreur (k) est la suivante :

)1()()()1()( kKkKKkuku ppi Pour mettre en œuvre ce régulateur, nous allons utiliser le VI suivant dans lequel le

régulateur PI est programmé dans le bloc Formula dont les entrées sont les paramètres Kp, Ki, l’entrée précédente u(k-1), l’erreur courante (k) et précédente (k-1).

Chapitre 1 / Prise en main 29

Les résultats de cette régulation sont affichés dans le panel suivant formé de 3 onglets.

Le signal de sortie du processus atteint la consigne après un seul dépassement.

30 Partie I / Apprentissage de LabVIEW

Dans l’onglet « Courbe Commande-Erreur », nous affichons la courbe du signal de commande et celle de l’erreur de poursuite.

Les paramètres du processus et ceux du régulateur sont spécifiés dans des clusters. Le

signal de consigne est réglé par un bouton rotatif dans l’intervalle [0 10]. L’affichage de la recopie de la consigne et signal de sortie se fait dans un cluster. Ces 2

signaux sont parfaitement identiques en régime permanent. La poursuite de la consigne se fait avec un seul dépassement, soit une dynamique du

second ordre d’amortissement optimal. Grâce à la présence de l’intégration dans le régulateur, l’erreur en régime permanent est nulle.

Chapitre 1 / Prise en main 31

Le cluster des paramètres du PID est désassemblé suivant les noms , comme celui des paramètres a1 et b1 du processus.

VII. Analyse numérique

VII.1. Régression linéaire par la méthode de Newton-Raphson

Cette méthode a été développée par les mathématiciens anglais Isaac Newton et Joseph Raphson.

La méthode de Newton-Raphson est basée sur l'utilisation de la tangente en un point de la courbe d'une fonction f.

32 Partie I / Apprentissage de LabVIEW

Cette méthode consiste à prendre x0 comme premier zéro de la fonction f(x). Ainsi, le point (x0, f(x0)) sera considéré comme premier point auquel on trace la tangente à la courbe de f(x). Le point d’intersection x1 de cette tangente avec l’axe des x sera ensuite considéré comme deuxième zéro de f(x).

A son tour, le point (x1, f(x1)) servira comme deuxième point de tangence qui définira comme troisième zéro à localiser et ainsi de suite.

La suite des points x0, x1, x2, x3,…, converge vers la vraie solution f(x)=0.

Pour déterminer les valeurs de ces points, nous avons besoin de connaître les équations de ces différentes tangentes.

)()()(')()(')( iiiiii xfxxxfyxxxfxy

Comme nous cherchons à localiser la solution y(x)=0, cette dernière est alors :

)(')(

i

ii xf

xfxx

Dans la méthode définie précédemment, la solution correspondant à l’intersection de la tangente avec l’axe des x, soit 1ix :

)(')(

1i

iii xf

xfxx

Dans le VI suivant, nous considérons la fonction )cos(2)( xexf x dont la dérivée est donnée par )sin(2)(' xexf x . Nous utilisons 3 blocs Formula pour tracer cette courbe, calculer les valeurs )( ixf et )(' ixf .

Dans le graphe de gauche, nous traçons la fonction f(x) dont nous localisons la solution, proche de x=0.6. Dans celui de droite, nous traçons la suite des xi de l’équation récurrente de Newton-Raphson.

Chapitre 1 / Prise en main 33

La convergence de la solution x est obtenue au bout de 3 itérations comme le montrent la

courbe de droite et les valeurs suivantes.

Les valeurs d’une fonction peuvent s’obtenir par les VIs d’évaluation comme suit.

34 Partie I / Apprentissage de LabVIEW

Avec le VI Eval Single-Variable Array.vi , nous pouvons évaluer une fonction sur un ensemble de valeurs. Nous avons choisi l’intervalle x = [0.4 0.8] qui contient la solution obtenue précédemment. Ces VIs permettent d’évaluer une fonction de variable x définie par une chaîne de caractères. Dans ce VI, les valeurs sont définies par un tableau constant. Une recopie de ce tableau permet de l’afficher sur le panel. Le VI Eval Single-Variable Array.vi permet d’évaluer la même fonction sur une seule valeur de x. Nous avons choisi la valeur de x=0.54 correspondant à la solution de f(x), ce que nous vérifions sur le panel avec f(0.54)=0.000589. Sur la courbe de f(x) nous vérifions la valeur de la solution x=0.53996 grâce à l’intersection des 2 curseurs.

Dans le diagramme suivant, nous utilisons le VI NR Zero Finder : Formula qui permet de rechercher la solution f(x) définie par la chaîne de caractères formula dans un intervalle défini par l’intervalle [start end].

Chapitre 1 / Prise en main 35

La palette de détection de zéros contient des VIs utilisant la méthode de Newton-Raphson et de Ridders, ainsi que la recherche de tous les zéros dans un intervalle de x déterminé.

Dans le VI suivant, le bloc Find All Zeros permet de rechercher toutes les solutions de la fonction f(x) dans l’intervalle [-10 10].

Nous trouvons 4 solutions que nous vérifions par f(Zeros).

VII.2. Résolution d’équations différentielles

VII.2.1. Méthode d’Euler

On s’intéresse au calcul de la tension aux bornes de la capacité d’un circuit RC.

La loi d’Ohm donne :

dttdSRCEtiREtS )()()(

36 Partie I / Apprentissage de LabVIEW

L’équation différentielle à résoudre par la méthode d’Euler est définie par :

)(1 SERCdt

dS

Avec E=5V, RC=0.1s, l’équation différentielle est définie par : sts 1050)(' . Nous obtenons bien la courbe exponentielle de la charge d’un condensateur à travers une résistance.

VII.2.2. Méthode de Runge-Kutta

On considère le cas d’une décharge de capacité dans une résistance. Cette capacité possède une charge initiale Q0 correspondant à une tension initiale V0.

Chapitre 1 / Prise en main 37

Nous prenons : .1,100 mFCR Les lois d’Ohm et de Faraday donnent :

dtdVCRiRV

Nous avons ainsi l’équation différentielle suivante :

VVCRdt

dV 101

Tout comme dans l’application de l’algorithme d’Euler, nous spécifions le terme droit de l’équation différentielle, F(X,t), le nom de la variable, v, sa condition initiale v0 et le domaine de valeurs du temps.

La solution théorique est une exponentielle amortie :

RCtevtx /0)(

38 Partie I / Apprentissage de LabVIEW

VIII. Probabilités et statistiques

La sous-palette Probability & Statistics de la palette Mathematics propose des VIs pour des calculs en probabilités et statistiques.

Dans cette sous-palette, nous pouvons calculer la moyenne, l’écart-type d’une série de valeurs et tracer son histogramme, etc.

VIII.1. Théorème central limite

Le théorème central limite établit la convergence en loi de la somme d'une suite de variables aléatoires vers la loi normale.

Considérons X1, X2, X3, etc., une suite de variables aléatoires indépendantes :

Le théorème central limite montre que la variable Sn tend vers une dispersion gaussienne.

La moyenne et l’écart-type de cette variable somme sont : 2,nn

Lorsque ces variables sont centrées et réduites, la variable :

nSn

/

tend vers une la loi de Gauss centrée et réduite )1,0(N lorsque n tend vers l’infini.

Chapitre 1 / Prise en main 39

Dans le VI suivant, nous créons 105 nombres aléatoires. Ces nombres sont d’abord la somme de 2 nombres aléatoires uniformes puis, dans le deuxième script MATLAB, nous faisons la somme de 12 nombres.

Sur le panel, nous affichons l’histogramme du bruit uniforme, celui de la somme de

variables niformes qui est triangulaire ainsi que celui de la somme de 12 variables qui tend vers une gaussienne.

VIII.2. Corrélation

La corrélation entre deux variables aléatoires permet d’étudier l’intensité de la liaison qui peut exister entre ces variables.

Cette corrélation est quantifiée par le coefficient de corrélation défini entre 2 valeurs

extrêmes -1 et +1. Une valeur absolue de 1 signifie une parfaite dépendance entre ces variables ; ce qui

signifie que connaissant la valeur de l’une d’elles, nous pouvons connaître la valeur de l’autre. Une corrélation nulle signifie une totale indépendance entre ces variables.

40 Partie I / Apprentissage de LabVIEW

Les valeurs particulières 1, -1 représentent les cas où Y est proportionnelle à X avec un coefficient de proportionnalité positif et négatif.

Si on note r ce coefficient de corrélation. Les illustrations suivantes montrent différents cas

de corrélation.

Dans les cas suivants, le coefficient de corrélation est nul, la variable Y n’est pas corrélée à X.

Le coefficient de corrélation est défini par :

YX

XY

n

i

n

iii

n

iii

yyxx

yyxxr

1 1

22

1

)()(

)()(

C’est le rapport de la covariance sur le produit des écart-types.

VIII.2.1. Calcul théorique de la corrélation et de la covariance

On considère un tableau X=[-1 -0.5 0 0.5 1] et Y= a1 X + b1, fonction linéaire de X, auquel on superpose un bruit blanc gaussien de variance unité, avec a1=-2 et b1=1.

Dans ce VI, nous calculons les variances de X, de Y, leur covariance et leur coefficient de corrélation à partir de leurs expressions littérales.

L’indice de xi et celui de yi sont obtenus en indexant les tableaux X et Y par le bloc

« Index Array » par l’indice i d’une boucle For.

Chapitre 1 / Prise en main 41

La valeur N est déterminée par la taille du tableau X, « Array Size ».

Dans la face-avant, nous affichons les moyennes et variances des signaux X et Y ainsi que

leur covariance.

Nous vérifions que le coefficient de corrélation, -0.9820 est proche de -1 car le coefficient a de la droite est négatif.

Le coefficient de corrélation a été calculé par 2 méthodes ; par l’utilisation du VI

Correlation Coefficient.vi et par son expression théorique. Nous obtenons parfaitement la même valeur.

42 Partie I / Apprentissage de LabVIEW

Le VI suivant permet de vérifier 2 de ces différents cas : Y décroissante et Y constante, avec X variable aléatoire.

On calcule le coefficient de corrélation entre X et Y par le VI « Correlation Coefficient.vi » et on obtient r1= -0,90164765.

On calcule ce coefficient à travers la matrice de covariance qui a la forme suivante:

2

2

),cov(),cov(

Y

XXY YX

YXC

On obtient la matrice suivante :

Nous retrouvons les valeurs des variances des tableaux X et Y ainsi que leur covariance. De cette matrice, on récupère l’élément de la 1ère ligne et la 1ère colonne qui correspond à la

variance du tableau X de 0.625, celle de Y qui est 1.32837 ainsi que leur covariance qui vaut -0.8221554.

Chapitre 1 / Prise en main 43

Nous obtenons ici la valeur du coefficient de corrélation en utilisant son expression

théorique. Nous vérifions aussi les valeurs des variances des tableaux X et Y. Dans la séquence de droite, nous avons Y=b2=1, quelque soit la valeur de X qui reste une

variable aléatoire ; il n’y a alors aucune corrélation entre elles.

VIII.2.2. Corrélation par le calcul matriciel

Avec la notation matricielle, l’estimateur non biaisé de la variance est donné par :

12

nXX T

X

Le calcul de cette variance par le rapport du produit scalaire, Dot Product.vi de X sur

(n-1), n étant la taille du tableau X, Array Size. Les covariances entre X et Y, Cov(X,Y) et Cov(Y,X)sont obtenues par :

1),cov(

nYXYX

T

XY

1),cov(

nXYXY

T

YX

La matrice de covariances est obtenue grâce au VI « Covariance Matrix.vi » qui

reçoit à son entrée la matrice dont les colonnes sont les signaux X et Y.

44 Partie I / Apprentissage de LabVIEW

Dans le panel, nous vérifions tous les résultats équivalents.

Chapitre 1 / Prise en main 45

Dans ce VI nous cherchons ce coefficient de corrélation par 2 méthodes : résultat du bloc Correlation Coefficient.vi et calcul théorique.

Nous obtenons la même valeur de r = -0,9519, proche de -1.

Lorsque le tableau Y est constant et X aléatoire, le coefficient de corrélation est NaN (Not A Number), soit une valeur indéterminée.

Nous obtenons parfaitement la même valeur du coefficient de corrélation par le bloc

Correlation Coefficient.vi et par le calcul à travers la matrice de covariance.

46 Partie I / Apprentissage de LabVIEW

Dans le diagramme suivant, un tableau X est transformé en tableau Y par la relation Y = 0.5 X + 30 auquel on ajoute un bruit gaussien de variance 5.

Soit r le coefficient de corrélation entre X et Y, la droite de régression de Y en fonction de X est de forme linéaire :

Y= a X+b,

avec :

XaYbra ,

C’est ce que nous programmons dans le script MATLAB. Dans ce VI, le tableau Y est obtenu par la transformation linéaire 0,5 x+30, à laquelle on

ajoute un bruit gaussien d’écart-type 0,2 soit une relation de tendance linéaire de coefficient positif, ainsi le coefficient de corrélation serait proche de 1.

Nous calculons d’abord le coefficient de corrélation en utilisant le VI Correlation

Coefficient.vi puis en utilisant l’expression théorique :

n

i

n

iii

n

iii

yyxx

yyxxr

1 1

22

1

)()(

)()(

Dans le script MATLAB, nous calculons le coefficient le coefficient b de la droite de

régression linéaire que nous traçons dans le même graphe XY que les valeurs du tableau Y en fonction du tableau X.

Sur le panel, nous affichons les points correspondants au tableau X ainsi que la droite de

régression. Nous trouvons un coefficient de corrélation de 0.9835 très proche de la valeur théorique de 1. Nous affichons les paramètres a et b de la droite de régression ainsi que les résultats intermédiaires du calcul théorique du coefficient de corrélation.

Chapitre 1 / Prise en main 47

IX. Opérations de base d’E/S sur fichiers

Dans ce paragraphe, nous allons considérer quelques VIs dans lesquels nous allons étudier quelques exemples de sauvegarde et lecture de données dans des fichiers, tableurs et binaires.

Les VIs relatifs aux E/S sur fichiers sont représentés la disquette File I/O.

48 Partie I / Apprentissage de LabVIEW

IX.1. Fichiers texte

IX.1.1. Ecriture

Dans le VI suivant, nous sauvegardons dans un fichier texte au format tableur, les 10 premières valeurs de )10/sin(i , obtenues en sortie de la boucle For suivante.

Le bloc Array To Spreadsheet String permet de transformer ce tableau de

valeurs en chaîne au format tableur. Write to Text File permet de sauvegarder cette chaîne dans un fichier.

Cette chaîne, de nom Spreadsheet String, est aussi affichée dans le panel.

La figure suivante montre ce que donne la lecture de ce fichier dans Excel.

IX.1.2. Lecture

Nous utilisons le VI Lire un fichier texte. Dans le panel, nous affichons les valeurs enregistrées.

Chapitre 1 / Prise en main 49

Dans le VI suivant, nous générons une matrice de valeurs sinusoïdales, de 5 lignes et 4

colonnes grâce à 2 boucles For imbriquées. Le sinus est programmé par un nœud d’expression.

Dans le panel, nous affichons la matrice ainsi que le texte enregistré.

50 Partie I / Apprentissage de LabVIEW

IX.2. Fichiers tableur

IX.2.1. Sauvegarde

Dans un fichier tableur, les données sont délimitées, généralement par une tabulation. Dans le VI suivant, nous générons, dans une boule For, 2 signaux, un signal aléatoire uniforme (random) et un signal formé de rampes.

En sortie de la boucle, nous récupérons un signal 2D que nous transmettons au VI Write

To Spreadsheet File.vi à son entrée tableau. L’entrée Chemin du fichier permet de spécifier l’emplacement dans lequel nous

voulons enregistrer le fichier dont on spécifie le nom. Si on n’entre aucun emplacement, LabVIEW le demande.

Nous avons spécifié le format de type flottant à 4 décimales (%4f).

Sur le panel, nous avons affiché les 2 signaux ainsi que quelques valeurs de la matrice. La

commande chemin se trouve dans la sous-palette Chaîne et chemin.

Chapitre 1 / Prise en main 51

Le fichier peut être lu dans un tableur comme Excel.

IX.2.2. Lecture

Pour lire un fichier tableur, nous utilisons le VI Read From Spreadsheet File.vi.

52 Partie I / Apprentissage de LabVIEW

Sur le panel, nous retrouvons les valeurs que nous avons sauvegardées.

IX.3. Fichier de mesures

Considérons la mesure de 3 signaux : une tension (U en Volts), une température (T en °C) et une pression (P en bars). On désire, de plus, sauvegarder le temps.

IX.3.1. En-tête du fichier

L’en-tête du fichier est formé de la date, le temps « tps », la température « T » et la pression « P ». Toutes ces chaînes de caractères sont séparées par une tabulation. Après la chaîne « P », on effectue un retour à la ligne. On écrit ces chaînes dans le même fichier que les données dont on spécifie l’emplacement qui est le bureau.

Nous pouvons afficher ou rendre invisible la chaîne en-tête grâce au nœud de propriété

Visible à laquelle on applique la valeur « F » ou fausse, i.e. que cette chaîne ne sera pas visible sur le panel.

Chapitre 1 / Prise en main 53

IX.3.2. Génération des signaux

Les signaux qui simulent les mesures de température et de pression sont générés manuellement par la jauge et le bouton rotatif. Nous ajoutons, à ces signaux, un signal sinus et cosinus. Ces signaux sont générés dans la séquence 0 pour être transmis aux autres séquences à travers une variable locale de séquence. Le temps est fourni par le VI chaîne de date/heure sous forme d’une chaîne de caractères.

IX.3.3. Enregistrement des signaux

L’enregistrement des signaux se fait dans la séquence 1. Les signaux générés dans la séquence 0 sont transmis à travers les variables locales de séquence. Les 2 signaux, T et P, sont assemblés pour former un tableau pour être transformé en chaînes de caractères grâce au VI Tableau en chaîne au format tableur. Le format est de type flottant à 4 décimales. Les valeurs sont aussi, de même que pour les chaînes de l’en-tête, séparées par une tabulation. Nous utilisons le même VI Ecrire dans un fichier texte pour sauvegarder les valeurs numériques transformées en chaînes de caractères.

54 Partie I / Apprentissage de LabVIEW

IX.3.4. Tracé des signaux

Le tracé des signaux se fait dans la dernière séquence. Les signaux P et T sont récupérés par les mêmes variables locales de séquence pour être

assemblés en cluster que l’on trace dans un graphe déroulant.

La structure séquence empilée est insérée dans une boucle While que l’on peut arrêter en

appuyant sur le bouton stop. Le terminal d’itération de la boucle permet de spécifier la fréquence des fonctions sinus et

cosinus. Sa valeur est aussi affichée dans le panel pour représenter la progression du temps. La cadence d’échantillonnage est fixée à 2 secondes.

Chapitre 1 / Prise en main 55

Le diagramme général du VI est le suivant :

Le panel affiche les signaux ainsi que les chaînes des mesures et la chaîne d’heure qui montre la progression du temps.

Nous affichons, de même, le cluster des données P et T qui sont affichées dans le graphe

déroulant.

56 Partie I / Apprentissage de LabVIEW

Le fichier peut être lu dans un tableur tel qu’Excel pour faire du post-traitement. Ici, nous calculons la moyenne des valeurs P et T. Nous pouvons également tracer, dans Excel, ces signaux en fonction du temps.

Partie I. Chapitre 2 - Les chaînes de caractères

I. Quelques opérations sur les chaînes de caractères I.1. Concaténation de chaînes I.2. Exemple 2 de concaténation de chaînes I.3. Suppression de chaîne vide au début et à la fin d’une chaîne de caractères II. Commandes chaîne et chemin II.1. Commande chemin, commande et indicateur chaîne II.2. Chaîne déroulante, recherche, remplacement et portion de chaîne II.2.1. Chaîne déroulante II.2.2. Recherche, remplacement et portion de chaîne III. Tableaux de chaînes III.1. Indexation et suppression d’une portion de tableau III.2. Formatage IV. Fonctions de conversion IV.1. Conversion de chemin, chaîne et nombre IV.2. Chaîne en tableau d’octets IV.3. Indexation de tableaux de chaînes, recherche et modification de la casse IV.4. Recherche de palindrome V. Création et utilisation des tables V.1. Création de la table par un nœud de propriété V.2. Utilisation des tables V.3. Tables Express V.4. Autres propriétés d’une table V.4.1. Création de tables par un nœud MathScript V.4.2. Création de tables par des nœuds de méthode VI. Dates et heures et horodatage VI.1. Attente, temps de calcul et temps écoulé VI.1.1. Attente VI.1.2. Temps de calcul, temps écoulé VI.2. Dates, heures et horodatage VI.2.1. Dates VI.2.2. En-tête d’un fichier texte VI.2.3. Horodatage

DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _2,57N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie I / Apprentissage de LabVIEW

58

I. Quelques opérations sur les chaînes de caractères

Les chaines de caractères sont d’une grande utilité dans LabVIEW. Dans le diagramme, les composants et les opérations liées aux chaînes de caractères se

trouvent dans la palette String.

L’affichage des chaînes de caractères se fait sous les 4 formes suivantes :

Chapitre 2 / Les chaînes de caractères

59

Le choix de l'option Affichage des codes '\' ('\' Codes Display) dans le menu local de la chaîne de caractères permet à LabVIEW d'interpréter les caractères qui suivent immédiatement un barre oblique inverse (\) comme un code de caractère non affichable.

Le tableau suivant montre l'interprétation de 3 codes par LabVIEW.

\n Linefeed : retour à la ligne (équivalent à \0A) \t Tab : tabulation (équivalent à \09) \s Space : espace (équivalent à \20)

Comme chaînes de caractères constantes, nous pouvons citer les chaînes suivantes :

Pour montrer les intérêts de ces chaînes, nous allons utiliser la fonction de concaténation.

I.1. Concaténation de chaînes

Dans le diagramme suivant, nous utilisons la fonction Concaténer des chaînes pour concaténer des chaînes diverses ainsi que des chaînes constantes, telles la chaîne vide, le retour chariot, la tabulation, etc.

Partie I / Apprentissage de LabVIEW

60

Chaîne concaténée est la chaîne «LabVIEW » concaténée à la chaîne constante vide, puis du retour chariot puis à la chaîne « est un langage graphique ». Chaîne concaténée 2 est la concaténation de la chaîne Chaîne concaténée

précédente à Chaîne concaténée.

I.2. Exemple 2 de concaténation de chaînes

Nous allons considérer plusieurs cas de concaténation : chaîne simple et tableau de chaînes. Dans le VI suivant, on crée un tableau de chaînes comme pour un tableau de réels.

Dans cet exemple, on crée 4 chaînes (chaîne1, chaîne2, chaîne3 et chaîne4) avec le VI Cmde chaîne de la sous-palette Chaîne et chemin de la face-avant.

On réalise la concaténation de ce tableau de chaînes avec la chaîne « orienté

Objets ».

La taille d’un tableau de chaînes est le nombre de chaînes dans le tableau. La longueur d’un tableau de chaînes est le nombre total de caractères.

La longueur d’un vecteur de chaînes est le vecteur des longueurs des chaînes.

Chapitre 2 / Les chaînes de caractères

61

I.3. Suppression de chaîne vide au début et à la fin d’une chaîne de caractères

On utilise pour cela, le VI Trim Whitespace.vi pour lequel on choisit la suppression de l’espace, soit avant, soit après, soit aux deux.

Dans ce diagramme, on fait la concaténation de « Langage » et de « de haut

niveau » avec, respectivement des espaces avant et à droite.

Partie I / Apprentissage de LabVIEW

62

Nous supprimons, dans ce diagramme, les espaces à gauche, à droite puis aux deux, tel que représenté dans le panel suivant.

II. Commandes chaîne et chemin

Dans le panel, les chaînes se trouvent dans la sous-palette Chaîne/Chemin. Nous trouvons des commandes et indicateurs chaînes ainsi que des commandes et indicateurs chemins.

Chapitre 2 / Les chaînes de caractères

63

II.1. Commande chemin, commande et indicateur chaîne

Dans le diagramme suivant, nous utilisons une séquence structure déroulée, dans laquelle on écrit la chaîne LabVIEW dans un fichier texte à l’emplacement défini par le répertoire Chemin. Dans la 2ème séquence, on ferme le fichier. Dans la 3ème étape, nous lisons le fichier et nous retrouvons la même chaîne de caractères.

Sur le panel, on utilise une commande Chaîne dans laquelle on spécifie la chaîne « LabVIEW ». On sauvegarde cette chaîne dans le fichier texte.txt dans le répertoire C:/Labview2012.

Dans le diagramme, on utilise une commande chemin pour spécifier le répertoire dans

lequel on sauvegarde le fichier texte. La sauvegarde se fait dans la 1ère séquence. Dans la 2ème, on ferme le fichier. Dans la 3ème

séquence, on lit le fichier et on affiche le résultat dans l’indicateur Chaine 2. Le cluster d’erreur se transmet d’un VI à l’autre. Lorsqu’une erreur survient dans l’un des

VIs, l’élément status se met à l’état logique 1 et la LED s’allume.

Partie I / Apprentissage de LabVIEW

64

Le bouton status reste à l’état logique Off par l’absence d’erreur.

II.2. Chaîne déroulante, recherche, remplacement et portion de chaîne

II.2.1. Chaîne déroulante

La chaîne déroulante propose à l'utilisateur une liste de chaînes pour sélection. Pour obtenir une chaîne déroulante, nous utilisons le VI Chne drlnte. Pour spécifier les différentes chaînes, nous choisissons l’option Editer les éléments par un clic droit.

Avec le bouton Insérer, nous éditons les différentes chaînes suivantes :

Les éléments édités sont insérés au fur et à mesure par le bouton Insérer. Un élément est supprimé par le bouton Supprimer. Dans le cas du VI suivant, les éléments de la chaîne déroulante sont spécifiés par le nœud de propriété où la propriété chaînes[] est affectée à un tableau de chaînes. Dans ce nœud, la propriété Clignotant est affectée à la valeur T(True) qui permet le clignotement de la chaîne choisie dans la chaîne déroulante.

Nous obtenons la sous-chaîne VIEW à partir de la chaîne LabVIEW à partir de l’offset 3. chaîne après remplacement est obtenue en remplaçant les caractères de la chaîne

LabVIEW par MATLA à partir de l’offset 1. chaîne résultante est obtenue en remplaçant Lab par MAT dans la chaîne LabVIEW.

Chapitre 2 / Les chaînes de caractères

65

Nous retrouvons la chaîne choisie dans l’indicateur Chaîne déroulante 2 ainsi que sa longueur.

Les éléments de la chaîne déroulante peuvent aussi être spécifiés en définissant un nœud de

propriété qui lui est lié. Ces éléments sont spécifiés dans la propriété Chaîne[].

Sur le panel, la commande Chaîne déroulante se met à clignoter grâce à la valeur T

(True :Vraie) qu’on a définie pour la propriété Clignotant.

II.2.2. Recherche, remplacement et portion de chaîne

Dans le VI suivant, nous remplaçons l’espace en fin de la chaîne LabVIEW est un langage (offset égal à sa longueur) par la chaîne de haut niveau.

Partie I / Apprentissage de LabVIEW

66

Le panel suivant représente la chaîne résultante ainsi que les clusters d’erreur en entrée et en sortie.

III. Tableaux de chaînes

III.1. Indexation et suppression d’une portion de tableau

Dans le diagramme suivant, nous créons un tableau de chaînes dont nous récupérons le 2ème élément que nous affichons dans l’indicateur Elément.

Nous supprimons le premier élément du tableau grâce à la fonction Supprimer une portion de tableau par indexation de ce tableau.

Dans le panel, nous visualisons la chaîne Elément, le tableau sans la chaîne supprimée et la chaîne supprimée.

Chapitre 2 / Les chaînes de caractères

67

III.2. Formatage

Grâce au formatage en chaîne de caractères, nous allons simuler des mesures avec le tableau x. Nous allons les transformer en chaînes de caractères qu’on ajoute à la dernière entrée de la fonction Formater en chaîne. La 1ère entrée est la chaîne Mesures suivie d’un retour à la ligne, la date, une tabulation, l’heure et l’en-tête des mesures «x1 x2 ».

Sur le panel, nous retrouvons l’en-tête et les valeurs mesurées.

IV. Fonctions de conversion

IV.1. Conversion de chemin, chaîne et nombre

Dans le diagramme suivant, nous allons étudier certains types de conversion. La fonction Chemin en tableau de chaînes produit un tableau de chaînes de

caractères dans lequel le caractère spécial «:\ » est supprimé. Nombre en chaîne

Partie I / Apprentissage de LabVIEW

68

décimale permet d’obtenir une chaîne ou un tableau de chaînes d’entiers décimaux arrondis à l’entier inférieur.

La fonction Rechercher une expression permet de rechercher une chaîne dans une autre, la chaîne d’avant et celle d’après.

Chaîne en tableau d’octets produit un tableau dont les éléments sont les codes

ASCII de tous les caractères de la chaîne. On obtient ce même résultat en utilisant la commande abs dans la fenêtre de commande de

la fenêtre MathScript.

La fonction Chaîne au format tableur en tableau transforme la chaîne multiligne en tableau de valeurs numériques.

On applique la fonction 1/x à ce tableau et en utilisant la fonction Additionner les

éléments d’un tableau et en indexant le tableau correspondant à la taille du tableau, nous calculons la moyenne des éléments du tableau.

Comme le tableau est du type 2D, sa taille est un tableau 1D. Le nombre de lignes correspond à l’indice 0, c’est pour cela qu’on indexe le tableau taille.

Le panel, affiche les résultats escomptés.

Chapitre 2 / Les chaînes de caractères

69

IV.2. Chaîne en tableau d’octets

Dans le tableau suivant, la chaîne LabVIEW est convertie en tableau d’octets dont chacun correspond au code ASCII de chaque caractère de la chaîne.

Nous utilisons cette propriété pour modifier ce tableau par une multiplication par 2 et

l’ajout de la valeur 3. La chaîne correspondante à ce nouveau tableau est la chaîne illisible ›Åǯ•• ±Cgceg.

Nous décodons cette chaîne en retranchant 3 et en divisant le résultat par 2. Le passage en chaîne de ce nouveau tableau permet de décoder la chaîne et de retrouver la

chaîne LabVIEW, la chaîne originale.

Dans le panel, nous affichons le tableau d’octets de la chaîne LabVIEW, la chaîne codée et

la chaîne décodée.

Partie I / Apprentissage de LabVIEW

70

IV.3. Indexation de tableaux de chaînes, recherche et modification de la casse

Dans le diagramme suivant, nous indexons un tableau de chaînes, recherchons la première occurrence d’une chaîne dans un tableau et transformons une chaîne en majuscules. La recherche donne la chaîne correspondant à l’indice spécifié et la recherche de la première occurrence de la chaîne StateChart retourne cette chaîne et l’indice correspondant dans le tableau.

Le passage en majuscules de la chaîne LabVIEW retourne la chaîne LABVIEW.

Indexer une chaîne multiligne permet de retirer une ligne comme on le fait pour un tableau. Dans cet exemple, la 3ème composante de la chaîne multiligne, indice 2, est bien la chaîne

et d’acquisition. Ainsi la concaténation avec la chaîne LabVIEW donne bien LabVIEW et d’acquisition. B

Chapitre 2 / Les chaînes de caractères

71

Dans le panel, nous affichons le tableau de chaînes et le résultat de l’indexation. La recherche de la première occurrence retourne l’indice 1. Le résultat est une chaîne vide, soit la chaîne retrouvée dans laquelle la chaîne recherchée est retirée.

IV.4. Recherche de palindrome

Dans ce VI, nous vérifions si la chaîne ressasser est un palindrome. Pour cela, nous inversons cette chaîne et comparons le résultat à cette dernière.

Le résultat booléen de cette comparaison permet de sélectionner la chaîne palindrome

reliée à l’entrée T du VI Ajouter la chaîne Vrai/Faux. Nous utilisons la fonction Sélectionner qui sélectionne l’une des 2 chaînes selon la valeur logique qui provient du test d’égalité.

Dans le panel, nous affichons le résultat de l’inversion de la chaîne ressasser et

l’allumage de la LED en vert signalant que c’est un palindrome.

Partie I / Apprentissage de LabVIEW

72

V. Création et utilisation des tables

Dans le panel, la table est obtenue dans la palette Liste/Table… du panel.

V.1. Création de la table par un nœud de propriété

On se propose de créer une table grâce à un nœud de propriété. On crée une table dans le panel et on lui lie, dans le diagramme, un nœud de propriété pour spécifier certaines propriétés.

On choisit les propriétés suivantes :

NbCols : nombre de colonnes de la table que l’on choisit égal à 2 NbLignes : nombre de lignes de la table, égal=5 EntCol[] : en-têtes de colonnes. Nous affectons à cette propriété le tableau :

EntColVis : Visibilité des en-têtes de colonnes. Valeur : le contenu de la table, soit :

Chapitre 2 / Les chaînes de caractères

73

Visible : permet l’affichage ou non de cette table Etiquette.CoulTexte : Couleur de l’étiquette de la table. On lui affecte une

constante couleur dans la palette Dialogue et interface utilisateur.

Les tables sont des représentations des tableaux 2D de chaînes de caractères. Plus bas, on utilise un graphe XY pour tracer la pression en fonction de la température. Pour cela, on utilise les propriétés EchelX.EtiquNom.Texte et

EchelY.EtiquNom.Texte que l’on affecte, respectivement aux chaînes température et pression que l’on obtient par indexation du tableau des en-têtes de colonnes.

Pour tracer la pression en fonction de la température dans un graphe XY, on doit indexer la

table pour obtenir ses valeurs. Ces valeurs sont des chaînes, on doit les transformer en nombre par le VI Chaîne

Fract/Exp en nombre.

Partie I / Apprentissage de LabVIEW

74

V.2. Utilisation des tables

On utilise généralement des tables pour pouvoir obtenir des valeurs intermédiaires par interpolation linéaire.

Grâce à la fonction Interpoler un tableau 1D, nous pouvons calculer la valeur du tableau pour un indice fractionnaire, exemple 3.2.

L’interpolation se fait linéairement comme suit.

Pour trouver l’ordonnée correspondant à l’indice 3.2, nous faisons :

32.310

341017 y

Nous trouvons :

4.1110)32.3(*341017y

Chapitre 2 / Les chaînes de caractères

75

La table a été définie dans le panel.

x y 0 3 1 4 2 4.6 3 10 4 17 5 24 6 36 7 48 8 64 9 82 10 98

Dans ce diagramme, nous utilisons un nœud de propriété pour :

- définir l’en-tête des colonnes, tableau de chaînes appliqué à EntCol[], - rendre visibles les en-têtes des colonnes, valeur T à la propriété EntColVis,

- rendre visibles les en-têtes de lignes, T à la propriété ETteLigVis, - définir le nombre de colonnes (2) et de lignes (11),

- permettre l’affichage de la barre de défilement verticale, valeur T à la propriété BarDéfVert.

Cette table est représentée par la courbe suivante, représentée sur un graphe XY. Nous trouvons bien la valeur 11.4 que nous approchons bien à l’aide des curseurs.

Pour avoir les curseurs, on choisit l’option « Propriétés » puis l’onglet Curseurs de

la boite de dialogue obtenue par un clic droit à l’intérieur du graphe.

Partie I / Apprentissage de LabVIEW

76

Dans le diagramme suivant, nous utilisons le VI Interpoler un tableau 1D.vi qui utilise une interpolation linéaire pour obtenir la valeur de l’indice fractionnaire 3.50.

V.3. Tables Express

Dans le diagramme suivant, nous créons une table de type Express. Une matrice 2x2, créée dans un nœud MathScript, est envoyée à l’entrée Signaux du VI Construire une table.

A cette table, on lie un nœud de propriété dans lequel 2 tableaux de chaînes reliés aux

propriétés EntCol[] et ETtesLig[] permettent de définir les en-têtes de colonnes et de lignes.

IndiceVis permet la visibilité des indices de la table, EntColVis et ETteVis

affichent les en-têtes des colonnes et des lignes.

Chapitre 2 / Les chaînes de caractères

77

Dans le panel suivant, nous affichons la table et le cluster d’erreur.

V.4. Autres propriétés d’une table

Dans cet exemple, nous utilisons d’autres propriétés des tables. Etiquette.CoulAP : couleur d’arrière-plan de l’étiquette de la table Etiquette.PoliceGras : police de l’étiquette en gras PolCellGras : contenu de la cellule active en police Gras DéfilHoriz. : défilement horizontal non actif BarDéfVert : barre de défilement verticale NbLignes et NbCols : spécification du nombre de lignes et de colonnes EntCol[] : en-têtes de colonnes, définies par le tableau

Le nœud de propriétés est lié à l’indicateur Indicateur table.

Partie I / Apprentissage de LabVIEW

78

V.4.1. Création de tables par un nœud MathScript

Dans le diagramme suivant, nous construisons la table directement par un tableau, de 5 lignes et 2 colonnes, généré par 2 boucles For dans un nœud MathScript. Dans la table, les nombres sont à 2 chiffres après la virgule.

Nous avons défini, dans le panel, 2 tableaux de chaînes de caractères qui serviront d’en-

têtes de colonnes et de lignes. Ces tableaux permettent de spécifier les propriétés EntCol[] et ETtesLig[] pour en-têtes de colonnes et de lignes.

Les propriétés EntColVis et ETteLigVis, lorsqu’elles sont vraies (valeur T)

permettent la visibilité des en-têtes des colonnes et de lignes.

Dans le panel, nous affichons la table avec ses en-têtes de lignes et de colonnes.

V.4.2. Création de tables par des nœuds de méthode

On se propose de remplir la table en utilisant un nœud de méthode. Dans le VI suivant, le nœud est lié à Commande table.

Nous choisissons la méthode Définir la valeur de cellule pour spécifier la valeur

de la cellule dont on va définir les coordonnées dans la table.

Chapitre 2 / Les chaînes de caractères

79

La cellule est définie par un indice de colonne, IndiceX et indice ligne, IndiceY. Le VI Nombre en chaîne fractionnaire permet de transformer un nombre, à 4

chiffres après la virgule, en chaîne de caractères. Cette chaîne permet de spécifier la valeur de la cellule de la première ligne et la deuxième colonne.

Le panel suivant montre la table, la chaîne et sa longueur.

Partie I / Apprentissage de LabVIEW

80

VI. Dates et heures et horodatage

Les VIs correspondant aux dates et heures se trouvent dans la palette Informations temporelles.

VI.1. Attente, temps de calcul et temps écoulé

VI.1.1. Attente

Plusieurs VIs permettent de synchroniser des boucles For et While en insérant dans ces dernières une attente entre 2 itérations successives.

Chapitre 2 / Les chaînes de caractères

81

On utilise 2 boucles For qui sont cadencées successivement par des attentes de 50 et 100 ms.

L’attente peut aussi se faire par le VI suivant, de type Express :

VI.1.2. Temps de calcul, temps écoulé

Renvoie la valeur de l'horloge en millisecondes, mais sans référence de base. On peut s’en servir pour calculer une différence de temps comme le temps de calcul d’un programme.

Nous utilisons 2 compteurs d’impulsions pour mesurer le temps de calcul.

Ce temps est calculé par la différence entre la valeur donnée par le compteur en sortie de boucle For et celui à l’entrée.

Ce VI permet de tracer une surface 3D avec 2 passages de boucle. Nous obtenons 17911 ms.

Le VI Temps écoulé, de type Express, permet de calculer le temps écoulé depuis un temps de départ, fixé à 0, et la sortie de la boucle While.

Partie I / Apprentissage de LabVIEW

82

Le programme dans le script MATLAB permet de réaliser une interpolation linéaire par la méthode des moindres carrés en calculant les paramètres de la droite d’interpolation.

Le panel suivant, montre les données et la droite de régression ainsi que les paramètres, a

et b, de la droite réelle qui relie les mesures ainsi que ceux de la droite de régression. Nous affichons également le temps écoulé de 797 ms.

Chapitre 2 / Les chaînes de caractères

83

VI.2. Dates, heures et horodatage

VI.2.1. Dates

Les dates et heures sont très liées aux chaînes de caractères d’où les indicateurs sous forme de chaînes de caractères en sortie des VIs.

Nous avons considéré une chaîne correspondant à la date du jour pour récupérer la date en général ainsi que l’heure.

La date est obtenue par le VI Sous-ensemble d’une chaîne en considérant la

longueur d’une chaîne date avec un offset nul. L’heure est le sous-ensemble de chaîne date et heure à partir de l’offset égal à la

longueur de la chaîne date classique ajoutée de l’espace de la fin. Le panel suivant affiche les chaînes résultantes.

Partie I / Apprentissage de LabVIEW

84

VI.2.2. En-tête d’un fichier texte

Pour les fichiers de mesure, nous avons besoin d’associer un en-tête au tableau de mesures. Le VI suivant permet de mesurer 2 grandeurs sous forme d’un tableau à 5 lignes et 2 colonnes.

L’en-tête est formé de la date et l’heure sous la forme hh:mm:ss suivies des noms des grandeurs x1 et x2.

Le VI est formé de 3 séquences dont la dernière sert uniquement à tracer le signal généré et sauvegardé dans un fichier texte.

Dans la 2ème séquence on ajoute l’en-tête formé de la chaîne x1 suivie d’une tabulation et de la chaîne x2 puis d’un retour chariot.

Le signal qu’on sauvegarde est formé de la somme d’une sinusoïde et d’un signal aléatoire uniforme.

Chapitre 2 / Les chaînes de caractères

85

Dans le panel on affiche l’en-tête du fichier, le tableau ainsi que les courbes de mesures.

VI.2.3. Horodatage

VII.2.3.1. Horodatages constants

La donnée horodatage est formée de la fraction de seconde, la seconde, jusqu’au jour de l’année sous la forme affichée à l’entrée du VI Date/heure en secondes.

cluster date/heure renvoie la date et l'heure. Si en UTC est VRAI, le cluster

date/heure est exprimé en temps universel. fractions de seconde correspond aux fractions de seconde qui se sont écoulées

depuis que la seconde a commencé. seconde est le nombre de secondes, minute est le nombre de minutes, heure, jour du mois, mois, année, jour de la semaine, jour de l'année.

Partie I / Apprentissage de LabVIEW

86

DST renvoie une valeur pour l'heure d'hiver (0) ou l'heure d'été (1). DST est heure d'hiver (0). Les opérateurs arithmétiques sont compatibles au type horodatage. Horodatage 2 est l’horodatage représentant 1977 secondes écoulées depuis le 1er

janvier 1904 à 0 heure [01-01-1904 00:00:00]. horodatage est celui correspondant à un cluster date et heure tel que défini ci-dessus.

Le VI Formater la chaîne de date/heure transforme un horodatage en

chaîne de caractères formée par la date et l’heure contenues dans l’horodatage.

VI.2.3.2. Mesures horodatées

Dans le diagramme suivant, nous générons, avec le VI Formule Waveform.vi, un signal selon la formule suivante : )2sin()sin( twt

La fréquence est choisie égale à 5 Hz et l’amplitude garde sa valeur par défaut de 1. Sa sortie est une waveform dont nous retirons sa donnée Y afin de créer une autre waveform par le VI Construire une waveform.

Chapitre 2 / Les chaînes de caractères

87

Dans le panel, nous observons que l’axe des x comporte le temps sous la forme d’horodatage. Pour cela, on doit décocher l’option Ignorer l’horodatage du menu local qu’on obtient par un clic droit.

Partie I. Chapitre 3 - Les nombres complexes

I. Palette Complexes II. Opérations sur les nombres complexes II.1. Coordonnées cartésiennes et polaires II.2. Approximation de la valeur de II.3. Solutions de l’équation du 2nd degré III. Fonctions de complexes III.1. Racine, logarithme, exponentielle et puissance réelle de complexes III.2. Clusters complexes III.3. Matrices complexes III.3.1. Manipulation de matrices complexes III.3.2. Analyse de circuit RLC IV. Opérations sur les complexes dans un nœud MathScript IV.1. Fonctions spéciales de nombres complexes IV.2. Représentation graphique IV.3. Racines n-ièmes d'un nombre complexe IV.4. Logarithme d’un nombre complexe IV.5. Diagramme de Bode d’un circuit RLC V. Les complexes dans un script MATLAB V.1. Racines n-ièmes d’un nombre complexe V.2. Opérations scalaires et matricielles sur les complexes

89DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _3,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

90 Partie I / Apprentissage de LabVIEW

I. Palette Complexes

Pour créer un nombre complexe dans LabVIEW, nous le définissons dans le panel comme un nombre réel quelconque et nous choisissons la représentation CDB (Complexe double précision).

Même une valeur nulle est représentée sous sa forme complexe z = 0 + 0 i. Les VIs qui opèrent sur les nombres complexes se trouvent dans la sous-palette Complexe de la palette Numérique.

Chapitre 3 / Les complexes 91

II. Opérations sur les nombres complexes

II.1. Coordonnées cartésiennes et polaires

Dans le VI suivant, nous réalisons les différentes opérations sur les complexes à partir du nombre z = 2 + i.

Nous effectuons :

- la valeur absolue d’un nombre complexe, - le passage de la forme cartésienne à la forme polaire, - le passage de la forme polaire aux valeurs Imaginaire et Réel, - le calcul du conjugué du nombre complexe.

Nous obtenons la même forme polaire à partir du nombre complexe dans sa forme cartésienne (r, thêta) et de sa forme (Réel/Imaginaire). Le complexe conjugué est obtenu par la fonction Complexe conjugué.

92 Partie I / Apprentissage de LabVIEW

II.2. Approximation de la valeur de

La valeur du nombre peut être approchée par l’expression suivante : )1ln(i où ln représente le logarithme népérien. On obtient la formule, dite d’Euler suivante, en multipliant par i à gauche et à droite et en prenant l’exponentielle des 2 parties: 1ie Cette expression exprime le fait que -1 est le nombre complexe dont le module vaut 1 et l’argument . Dans le diagramme suivant, nous générons l’imaginaire pur i par la fonction Réel/Im en complexe. Nous le multiplions par dont nous prenons l’exponentielle que nous comparons -1. La valeur exp(x)=-1+1.2246 10-16 i est quasiment égale à -1. Nous prenons la valeur absolue de l’erreur que nous comparons à 10-3.

Dans le panel, nous affichons les différentes valeurs complexes. La LED s’allume car l’erreur est nettement plus faible que 10-3.

Chapitre 3 / Les complexes 93

II.3. Solutions de l’équation du 2nd degré

Les solutions de l’équation du second degré 02 cxbxa peuvent se résumer comme suit, selon le signe du discriminant cab 42 :

0 0

abx22,1

ajb

x22,1

Les deux cas sont représentés par l’utilisation de la structure Condition. On teste si le discriminant est positif. Le résultat, vrai ou faux, de type booléen est appliqué au terminal de sélection de la structure pour déterminer les solutions à sélectionner. Dans le cas faux, on crée la valeur imaginaire pure j en utilisant la fonction Réel/Im en complexe pour obtenir les solutions complexes conjuguées ci-dessus.

94 Partie I / Apprentissage de LabVIEW

Dans le panel, nous représentons le cas des solutions réelles de type double. Le type de données des solutions ayant été choisi de type CDB (complex double), les solutions réelles sont représentées par une partie imaginaire nulle.

III. Fonctions de complexes

III.1. Racine, logarithme, exponentielle et puissance réelle de complexes

Le diagramme suivant consiste à calculer la racine carrée, l’exponentielle et le logarithme népérien d’un nombre complexe.

Nous appliquons quelques fonctions sur le complexe (3-2i).

La fonction Réel/Im en complexe permet d’obtenir la forme cartésienne (3-2i) lorsqu’on lui applique la partie réelle 3 et la partie imaginaire (-2).

Nous calculons la racine carrée de ce nombre par la fonction Racine carrée et la fonction Racine y-ième de x lorsqu’on lui applique le nombre complexe. Comme les fonctions appliquées précédemment, ces dernières peuvent s’appliquer à :

- un nombre scalaire, - un tableau ou matrice de nombres, - un cluster de nombres ou tableau de clusters de nombres.

La fonction symbolisée par celui de la racine carrée effectue la racine carrée de ce nombre. Nous le faisons également par la fonction Racine y-ième en appliquons 2 au connecteur y représentant la racine. Nous testons les 2 résultats et effectivement, c’est le même; ce qu’on vérifie par la LED qui s’allume en recevant de l’opérateur « égalité » la valeur logique vraie (T pour True).

Chapitre 3 / Les complexes 95

En utilisant les VIs Exponentielle et Logarithme népérien, nous retrouvons le même nombre (3-2i) de départ. Pour effectuer la puissance ^(-3) du nombre (3-2i), nous utilisons le VI Racine y-ième de x pour lequel la valeur de la puissance est prise égale à y=-1/3. La LED qui s’allume montre l’équivalence des 2 manières de calculer la racine carrée d’un nombre complexe.

III.2. Clusters complexes

Nous créons le tableau complexe à 2 éléments jj

3221

que nous assemblons avec le

scalaire complexe 4

21 j

e dans un cluster.

Calculer le conjugué de ce cluster revient à prendre le conjugué de tous les nombres complexes contenus dans ce cluster. Il est de même pour la valeur absolue.

96 Partie I / Apprentissage de LabVIEW

Dans le panel, nous affichons les 2 nombres complexes ainsi que le cluster dans lequel on les a assemblés. Dans le résultat de la valeur absolue, nous remarquons bien la valeur 0.5 du scalaire complexe défini en coordonnées polaires.

III.3. Matrices complexes

Différentes fonctions propres aux nombres complexes permettent d’obtenir son module, son conjugué, ses parties, imaginaire et réelle, etc.

III.3.1. Manipulation de matrices complexes

Dans le diagramme suivant, nous disposons de 2 matrices réelles, celle dite « imaginaire » est appliquée au connecteur im de la fonction Réel/Im en polaire, tandis que la matrice réelle est appliquée au connecteur re. Cette fonction permet de transformer un nombre complexe, dans sa forme cartésienne (a+jb) à sa forme polaire jer . Dans notre cas de l’application de 2 matrices de mêmes dimensions, cette transformation s’effectue pour chaque couple d’éléments de mêmes indices. Nous obtenons une matrice, de mêmes dimensions que celles de la matrice d’entrée, qui contient les rayons r et une autre consistant en une matrice d’arguments . Lorsqu’on applique ces 2 matrices à la fonction Polaire en complexe, nous obtenons directement une autre matrice, de mêmes dimensions que chacune des matrices d’entrée, mais formée directement de nombres complexes dans leur forme cartésienne. C’est le cas de la matrice Z que nous affichons dans le panel. Lorsqu’on ajoute un réel à une matrice complexe, il s’ajoute à toutes les parties réelles de ses éléments complexes. C’est ce que nous remarquons pour la matrice resultat qui provient de l’ajout de la valeur entière 3. Toute fonction sur les complexes, dans le cas du tableau ou matrice, s’applique à tous les éléments du tableau ou matrice. C’est le cas de la fonction « valeur absolue ». Il en est de même pour un cluster complexe. L’élement (0,0) est l’élément de la première ligne et de la première colonne de la matrice complexe à laquelle on a ajouté la valeur scalaire et entière 3. Ceci s’obtient par indexation de la matrice en précisant l’indice 0 pour la ligne et la colonne.

Chapitre 3 / Les complexes 97

Dans le panel, nous affichons les matrices de départ et les matrices résultats On peut facilement vérifier que l’élément (4+2i) provient de la matrice r*e(i^tetha) à laquelle on a ajouté la valeur 3. Cet élément est obtenu par indexation de la matrice résultat.

III.3.2. Analyse de circuit RLC

On considère le circuit RLC suivant :

98 Partie I / Apprentissage de LabVIEW

On considère :

FCmHL

RR

Hzf

10100

2150

2

1

La loi des mailles donne :

0)12( 312

131

iRijCw

R

ijLwiRVe

Nous avons aussi, par la loi des nœuds :

0321 iii

La loi des mailles et des nœuds donne la relation matricielle suivante entre la tension d’entrée et les courants i1, i2 et i3.

3

2

1

12

1

111

10

0

00

iii

RjCw

R

RjLwVe

Le vecteur des courants est alors donné par :

UM

VeR

jCwR

RjLw

iii

1

1

12

1

3

2

1

00

111

10

0

Dans le diagramme suivant, nous spécifions les matrices M et U dans un nœud MathScript. Les valeurs des composants sont des entrées de ce nœud. La pulsation est aussi une entrée, spécifiée en fonction du terminal d’itération. Ce nœud a comme sorties, la matrice M et le vecteur U. Nous inversons la matrice M et multiplions le résultat en utilisant les VIs d’inversion Inverse Matrix.vi et de multiplication matricielle A x B.vi de la sous-palette Mathématiques Algèbre linéaire.

Chapitre 3 / Les complexes 99

Nous récupérons le courant i1 par indexation dont extrayons les composantes polaires.

Nous traçons le module dans un graphe déroulant et affichons la phase en degrés en utilisant un nœud d’expression dans lequel on transforme cette phase de radians en degrés par l’expression x*180/ .

Nous avons relié les clusters d’erreur entre le nœud MathScript et le VI Temps d’attente.

Lorsqu’une erreur intervient, nous retrouvons, dans le cluster d’erreur de sortie, error out, sa localisation à savoir le VI dans lequel elle survient.

Dans le panel, nous affichons la matrice complexe d’impédance, M ainsi que son inverse.

Dans le graphe déroulant, nous traçons le module du courant i1. Tous ces calculs s’effectuent dans une boucle While cadencée à 0.2s.

100 Partie I / Apprentissage de LabVIEW

IV. Opérations sur les complexes dans un nœud MathScript

Les opérations sur les nombres complexes sont réalisées de la même façon que sur les nombres réels.

IV.1. Fonctions spéciales de nombres complexes

En utilisant la programmation textuelle du nœud MathScript ou MATLAB script, nous avons accès à des fonctions spécialisées pour la manipulation des nombres complexes. Dans le diagramme suivant, nous disposons de 2 matrices réelles A et B qui vont permettre de réaliser une matrice complexe de partie réelle A et imaginaire B. Nous utilisons la commande complex. Ceci peut aussi se faire tout simplement par la commande Z=A+j B. La fonction complex permet de transformer tout tableau de nombres, clusters ou cluster de clusters de nombres, en sa partie complexe. Dans le cas de la matrice Z, le scalaire, X=1, forme la partie réelle du tableau de partie imaginaire Y. Nous testons si tous éléments de la matrice Z sont égaux à celle que nous créons simplement par Reel+j*Im.

Chapitre 3 / Les complexes 101

La matrice W est créée simplement par l’expression W=X+j*Y sans utiliser la commande complex. De même, le conjugué d’une matrice complexe se fait tout simplement par l’opérateur « ' ».

Dans le panel, nous affichons les résultats des commandes complex, conjugate, real, imag, etc. Nous comparons tous les éléments de la matrice Z et celle formée par la commande simple Reel + j * Im. Le résultat est vrai, d’où l’allumage de la LED qui reçoit un 1 logique. Nous vérifions que tous éléments de la matrice conjuguée, Conj_W sont les conjugués de ceux de la matrice W.

102 Partie I / Apprentissage de LabVIEW

IV.2. Représentation graphique

Nous allons étudier deux représentations graphiques de nombres complexes en utilisant le nœud MathScript. La fonction plot, appliquée à un nombre complexe, trace son image dans le plan cartésien.

Le tracé des images des complexes qui forment le tableau suivant,

iiz

232

1

1

est représenté dans la fenêtre ci-après. Grâce à la commande gtext, nous affichons le libellé de l’image de chaque nombre. Si Reel et Im sont les parties, réelle et imaginaire, du nombre complexe z, cette commande est équivalente à compass(Reel, Im). Cette commande trace des flèches à partir de l’origine. Le complexe z2, formé des 3 racines de l’unité est une sortie du nœud MathScript. Nous affichons leurs modules et phases grâce à la fonction Complex en polaire.

Chapitre 3 / Les complexes 103

La commande compass représente le tracé d’un nombre complexe dans des coordonnées polaires. Dans cet exemple, ce complexe représente les racines 3-ièmes de l’unité.

IV.3. Racines n-ièmes d'un nombre complexe

Si l'on considère le nombre complexe z sous la forme exponentielle :

)(exp jrz

on obtient l'expression de ses racines n-ièmes

zn rn jk

nexp [ ( )]

2, avec k = 0, 1, ..., n-1.

104 Partie I / Apprentissage de LabVIEW

Dans ce qui suit, nous créons un VI qui retourne les racines n-ièmes d'un nombre complexe. Dans ce diagramme, nous programmons textuellement, dans un nœud MathScript, l’expression ci-dessus. En calculant la puissance de cette solution à la puissance n, nous retrouvons parfaitement le complexe de départ. En effet, en testant l’égalité du résultat avec le complexe de départ, nous obtenons un 1 logique (LED allumée), ce qui vérifie l’égalité du résultat obtenu avec le complexe de départ.

Nous devons impérativement spécifier le type de données pour les variables de sortie du nœud de MathScript et de MATLAB script. En pointant la variable de sortie, par un clic droit, nous sélectionnant Choisir le type de données Tous les types Tableau 1D CDB 1D, pour un tableau 1D de type complexe.

Chapitre 3 / Les complexes 105

Nous cherchons, dans ce panel, la racine 3-ième de l’unité ainsi que la puissance au cube du résultat que nous comparons au complexe de départ. La LED en sortie de la fonction Egaux ?, montre que nous obtenons parfaitement le complexe de départ.

IV.4. Logarithme d’un nombre complexe

En utilisant les fonctions, exponentielle et logarithme, les racines n-ièmes d'un nombre complexe z sont données par l'expression :

znn

zexp [ log( )]1

On se propose de définir un sous-VI qui réalise la fonction logarithme d'un nombre complexe. Si z est exprimé sous sa forme trigonométrique :

z e j ,

son logarithme, défini à 2k près, a pour expression :

w z j klog( ) log ( )2

Ce sous-VI calcule un tableau dont la taille est donnée par la valeur de k qui représente la solution à k2 près.

Ci-après, nous utilisons ce sous-VI qui calcule le logarithme d’un nombre complexe par lequel nous cherchons sa racine n-ième.

106 Partie I / Apprentissage de LabVIEW

Nous pouvons vérifier ce sous-VI en calculant la racine 3-ième de l’unité :

En élevant le résultat à la puissance n dans le nœud MATLAB script, nous vérifions qu’on retrouve parfaitement le complexe de départ.

IV.5. Diagramme de Bode d’un circuit RLC

Le circuit RLC suivant est attaqué par un signal sinusoïdale t e jwt( ) .

avec :

FCHL

R

11.0

100

Dans le domaine fréquentiel, ce circuit est défini par la fonction de transfert suivante dans le domaine fréquentiel.

Chapitre 3 / Les complexes 107

wCRjwCLjwEjwSjwH 21

1)()()(

Cette fonction de transfert peut-être transformée, comme suit en faisant apparaître le coefficient d’amortissement .

2

00

)(21

1)(

ww

wwj

jwH

Nous désirons calculer et tracer la réponse en fréquences de cette fonction de transfert dans une bande de pulsations donnée. Nous traçons le gain en coordonnées logarithmiques,

)(log(20 jwH .

Nous retrouvons bien, les asymptotes 0 dB vers les basses fréquences et -40 dB/décades en hautes fréquences. Dans le panel, nous avons spécifié les valeurs de R, L et C, respectivement à l’aide d’un bouton rotatif et glissières. Le cas présenté dans le panel est celui où le coefficient d’amortissement est plus petit que 1. Le système est dit sous amorti. La courbe possède un pic à une pulsation dépasse 0 dB. Le coefficient d’amortissement

est donné par : LCR

2

108 Partie I / Apprentissage de LabVIEW

Nous allons tracer la réponse temporelle, en réponse à une sinusoïde. Nous sortons, du nœud MathScript, le module par la commande abs et l’argument par la commande angle en degrés en utilisant le nœud d’expression. Le circuit, étant un filtre passe-bas, nous remarquons qu’en augmentant la pulsation w, à l’aide d’une glissière, l’amplitude du signal de sortie diminue. Nous avons choisi un coefficient d’amortissement 08.1 . Nous affichons les valeurs numériques par les commandes de R, L et C en choisissant Afficheur numérique dans le menu local de Eléments visibles.

Dans le diagramme, nous calculons la fonction de transfert complexe H(jw) et nous nous en servons pour calculer le signal de sortie. Nous traçons, dans le même graphe XY, le signal d’entrée et la valeur absolue du signal de sortie. Le module et la phase, en degrés, de la fonction de transfert sont simplement affichés.

Dans le panel, nous affichons les signaux d’entrée et de sortie, le coefficient d’amortissement et la glissière de réglage de la pulsation w.

Chapitre 3 / Les complexes 109

V. Les complexes dans un script MATLAB

Les nœuds MathScript ne permettent pas l’utilisation des toutes les commandes MATLAB.

Dans l’environnement LabVIEW, les scripts MATLAB nécessitent l’acquisition d’une licence et l’installation de MATLAB.

MATLAB s’exécutive dès qu’on fait appel à un script MATLAB. Dans l’exemple

suivant, nous faisons appel à plusieurs commandes propres aux nombres complexes.

V.1. Racines n-ièmes d’un nombre complexe

Soit z un nombre complexe, de module r et de phase , que l’on représente sous sa forme exponentielle :

jerz

On obtient l'expression de ses racines n-ièmes comme suit :

nkj

en rn z

2

, pour k = 0, 1, ..., n-1.

Dans le diagramme suivant, nous calculons les racines 3-ièmes de l’unité par l’expression ci-dessus.

Nous affichons, d’abord, le module, la phase du nombre complexe. On s’en sert ensuite

pour afficher ce nombre en utilisant l’expression ci-dessus de sa forme exponentielle.

L’imaginaire pur j est défini par une constante dont nous choisissons la représentation en CDB (complexe double) dans son menu local.

110 Partie I / Apprentissage de LabVIEW

Dans le panel, nous affichons l’argument des 3 racines ainsi que les 3 racines 3-ièmes de l’unité.

V.2. Opérations scalaires et matricielles sur les complexes

Dans le diagramme suivant, nous utilisons le nœud MATLAB script pour réaliser des commandes sur des complexes ainsi que des matrices complexes, telles que sqrt (racine carrée), conj (conjugué), log (logarithme), ainsi que l’opération de division (opérateur /). L’opérateur « ’ » permet la conjugaison d’un nombre complexe.

Les résultats de ces opérations sont assemblés dans un cluster. Pour chaque entrée ou sortie du nœud, nous devons spécifier le type de données dans le menu local.

Chapitre 3 / Les complexes 111

Le module et la phase des éléments de la matrice complexe Matrice sont des matrices

2x2 concaténées verticalement. Les matrices, réelle et imaginaire, sont des matrices 2x2 concaténées horizontalement.

Le type de données choisi est : 2-D Array of Real

Partie I. Chapitre 4 - Les polynômes

I. Polynômes au sein du nœud de MathScript et la fenêtre MathScript I.1. Opérations sur les polynômes I.1.1. Multiplication, division et racines de polynômes I.1.2. Division de polynômes I.1.3. Racines d'un polynôme I.2. Manipulation de fonctions polynomiales I.2.1. Evaluation de la dérivée et de la primitive d’une fonction polynomiale I.2.2. Dérivée, intégrale par les fonctions diff et cumsum I.3. Interpolation et régression au sens des moindres carrés II. Utilisation des VIs LabVIEW II.1. Somme, produit et division de polynômes II.2. Décomposition en éléments simples, valeurs et vecteurs propres, II.2.1. Décomposition en éléments simples II.2.2. Valeurs et vecteurs propres II.3. Polynômes rationnels II.3.1. Addition, soustraction, décomposition en éléments simples et évaluation II.3.2. Retour négatif de polynômes rationnels III. Polynômes de Bessel et Chebyshev III.1. Polynômes de Bessel III.2. Polynômes de Chebyshev III.2.1. Forme théorique du polynôme de Chebyshev III.2.2. Utilisation du VI Chebyshev Polynomial.vi

113DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _4,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

114 Partie I / Apprentissage de LabVIEW

La palette Polynomiales appartient à la palette Mathématiques.

Si nous utilisons le nœud MathScript ou la fenêtre MathScript, il existe beaucoup de

fonctions propres aux polynômes.

I. Polynômes au sein du nœud de MathScript et la fenêtre MathScript

I.1. Opérations sur les polynômes

Dans la syntaxe MathScript, les polynômes sont formés de vecteurs lignes dont les composantes sont ordonnées par ordre des puissances décroissantes. Un polynôme de degré n est représenté par un vecteur de taille (n+1). Par exemple, le polynôme

2x2x3xx2f(x) 434

est représenté par le vecteur ligne suivant:

En plus des opérations propres aux vecteurs qui peuvent être utilisées pour la manipulation des polynômes, d'autres opérations spécifiques sont prévues, telles que conv (multiplication de polynômes), deconv (division de polynômes), roots (racines d’un polynôme), etc.

Chapitre 4 / Les polynômes 115

I.1.1. Multiplication, division et racines de polynômes

La multiplication et la division de deux polynômes sont réalisées respectivement par la convolution et la déconvolution de leurs coefficients, à l'aide des fonctions conv et deconv.

Exemple: fonctions de transfert en cascade

Considérons le système suivant constitué de deux fonctions de transfert mises en cascade.

H p1( ) H p2( )

avec

H pp

p p13 1

2 2 3( ) H p

pp p2

050 2

( )..

La fonction de transfert globale est le produit des fonctions de transfert élémentaires :

H p H p H p( ) ( ) ( )1 2

Nous vérifions bien que la fonction de transfert globale est la suivante : 0.5 p2 + 2.5 p + 3 ------------------------------- 0.6 p4 + 3.4 p3 + 2.2 p2 + p + 1

116 Partie I / Apprentissage de LabVIEW

Sur ce panel, nous affichons les fonctions de transfert H1, H2 et le produit des 2, H_glob. Nous affichons également les zéros et les pôles de la fonction de transfert H1.

I.1.2. Division de polynômes

Si l'on veut, par exemple, retrouver le dénominateur de H p1( ) , on utilisera la fonction deconv. Dans le cas général, la division peut ne pas donner un résultat exact, il existe alors un quotient Q et un reste R. Considérons les deux polynômes P et S suivants :

P x x x

S x x x

( )

( )

3 12 3 4

On s'intéresse au quotient et au reste de la division de P par S. On obtient ainsi, un quotient Q et un reste R donnés par :

Q x xR x x

( )( )

314 13

On dispose de la fonction residue pour décomposer une fraction en éléments simples sous la forme :

P xS x

K xri

x pii

n( )( )

( )1

où pi, ri (i = 1 à n) et K x( ) sont respectivement les pôles, les résidus et le terme direct du résultat de la décomposition.

Chapitre 4 / Les polynômes 117

Ce qui correspond à la décomposition suivante :

12.0

48.133

43213

)()(

xxx

xx

xxxSxP

Inversement, connaissant les résidus, les pôles et le terme direct, la même fonction residue permet de retrouver les 2 polynômes. Nous utilisons les mêmes polynômes des résidus, pôles et terme direct précédents.

118 Partie I / Apprentissage de LabVIEW

I.1.3. Racines d'un polynôme

Les racines d'un polynôme sont données par la fonction roots. Ceci est intéressant en traitement de signal ; les solutions du numérateur (zéros) et ceux du dénominateur (pôles) de la fonction de transfert peuvent renseigner sur les modes du système. Considérons la fonction de transfert H p( ) suivante :

)2()1()1)(1(

222)( 2

2

ppjpjp

pppppH

Dans ce diagramme, le numérateur de cette fonction de transfert est une entrée du nœud MathScript. Son dénominateur est défini comme le produit des deux polynômes du 1er ordre,

)1( p et )2( p . Nous utilisons la fonction deconv, en divisant le dénominateur par le polynôme )1( p . Evidemment, nous obtenons le polynôme )2( p . La fonction de transfert est affichée sous la forme d’un tableau de clusters :

- le cluster properties - le cluster transfer function(s).

Le cluster properties contient les propriétés de la fonction de transfert i.e. les retards de l’entrée u0, de la sortie y0, la cadence d’échantillonnage, etc., le cluster transfer function(s) contient le numérateur et le dénominateur de la fonction de transfert. La fonction poly permet de retrouver le polynôme à partir de ses solutions. Nous appliquons les solutions du numérateur num_H à cette fonction poly. Le résultat de cette fonction est comparé à num_H. Le tableau booléen égal avec ses 3 LEDs allumées confirme l’égalité de num_H au résultat de la fonction poly. Lorsqu’on applique une matrice comme argument à la fonction poly, elle retourne le polynôme caractéristique de cette matrice. Nous appliquons la matrice A suivante à la fonction poly :

4321

A

Le polynôme caractéristique de la matrice A est alors :

p x x2 5 2

Chapitre 4 / Les polynômes 119

Les racines de ce polynôme sont les valeurs propres de la matrice A que l'on peut aussi obtenir directement par la fonction eig.

Le panel suivant, affiche tous les résultats des fonctions roots, conv, deconv, tf, poly et eig.

120 Partie I / Apprentissage de LabVIEW

I.2. Manipulation de fonctions polynomiales

I.2.1. Evaluation de la dérivée et de la primitive d’une fonction polynomiale

Beaucoup de fonctions mathématiques s'expriment ou peuvent être approximées par des polynômes. polyder(f) : calcul de la dérivée de la fonction polynomiale f(x). polyint (f,k) : retourne un polynôme représentant l’intégrale du polynôme f avec la

constante k. polyval(f,x) : évaluation de la fonction polynomiale f(x) pour un ensemble donné de

valeurs de la variable x, exprimé sous forme d'un tableau, Le script polynome_derivee_integrale.m, réalisé sous l’éditeur de la fenêtre MathScript, utilise la fonction polyder pour calculer la dérivée d’une fonction polynômiale. Considérons, par exemple, la fonction polynomiale f x x x( ) 2 2 2 1 . Dans le script polynome_derivee_integrale.m, on calculera sa dérivée et la primitive s'annulant en 0, dont on tracera les courbes représentatives.

fichier polynome_derivee_integrale.m

Chapitre 4 / Les polynômes 121

Nous obtenons ainsi, la dérivée et la primitive suivantes :

f x x' ( ) 4 2, F x x x x( )23

3 2

I.2.2. Dérivée, intégrale par les fonctions diff et cumsum

I.2.2.1. Dérivée

Nous allons utiliser d’autres commandes pour le calcul de la dérivée, de l’intégrale et de leurs expressions théoriques. Pour calculer la dérivée, nous allons utiliser la fonction diff. L’intégration se fait à l’aide de la commande cumsum qui fait une somme cumulée dans le domaine d’intégration. L’expression théorique du polynôme se fait à l’aide de poly2str (passage du polynôme à chaîne de caractères). La fonction diff, appliquée à un tableau x de taille n donne un tableau de taille (n-1) dont chaque élément correspond à la différence de deux éléments successifs de x. Cette fonction peut être utilisée pour le calcul de la dérivée d'une fonction mathématique f(x) par la formule suivante :

f'(x) = df/dx = diff(f)./diff(x)

122 Partie I / Apprentissage de LabVIEW

C’est la division, élément par élément, des tableaux diff(f) et diff(x). Le programme suivant, illustre le calcul et le tracé de la courbe représentative de la dérivée de la fonction :

f(x) = x2/2 - x + 1.

La fonction f(x) et sa dérivée sont tracées dans le même graphe XY du panel.

I.2.2.2. Intégrale

On cherche à calculer les intégrales de la forme suivante :

I x f t dtx

( ) ( )1

Nous nous intéresserons au cas où 1)( ttf , dont le résultat théorique est :

23

2

2

12

2)( xx

xttxI

Chapitre 4 / Les polynômes 123

Pour calculer cette intégrale à l'aide du script de la fenêtre MathScript, on peut utiliser la méthode des rectangles qui consiste à approcher l'aire sous la courbe par celle des rectangles de longueur f(x) et de largeur dx (le pas d'intégration). La valeur de l'intégrale, dans l'intervalle [a,b], est la somme cumulée des surfaces des rectangles élémentaires. La somme cumulée est réalisée par la fonction cumsum. La valeur obtenue par cette méthode est d'autant plus proche de la valeur théorique que le pas d'intégration est plus faible. Dans cet exemple, script integ.m, ce pas vaut 0.001.

La courbe suivante, montre la fonction y=x-1 et son intégrale.

I.3. Interpolation et régression au sens des moindres carrés

Dans le domaine de l'analyse de données, on a souvent besoin d'établir un modèle mathématique liant plusieurs séries de valeurs expérimentales. L'interpolation consiste à approcher la courbe liant 2 séries de mesures par un polynôme. Les coefficients optimaux de ce polynôme sont ceux qui minimisent la variance de l'erreur d'interpolation. Ce principe est connu sous le nom de la méthode des moindres carrés.

124 Partie I / Apprentissage de LabVIEW

La commande p = polyfit(x,y,n) retourne le polynôme p de degré n permettant d'approcher la courbe y = f(x) au sens des moindres carrés. Afin d'en déduire l'erreur entre la courbe expérimentale et le modèle obtenu, on dispose de la fonction polyval(p,x) qui retourne la valeur du polynôme p pour toutes les composantes du vecteur ou de la matrice x. Pour appliquer ces fonctions, nous allons simuler une courbe expérimentale par une sigmoïde à laquelle nous superposons un bruit gaussien. Pour tracer les 3 courbes (erreur, valeurs du polynôme d’interpolation, sigmoïde bruitée), nous avons besoin d’utiliser 2 fonctions Construire un tableau.

Pour chaque sortie du nœud MathScript, nous devons choisir son type par le menu local suivant. Pour toutes les sorties de ce nœud MathScript, on choisit un tableau 1D de type double en choisissant l’option « Choisir le type de données » du menu local. Il est plus simple d’opter pour la suite d’options suivantes : Tous les types Tableau 1D DBL 1D.

Le panel suivant montre la sigmoïde bruitée, le polynôme d’interpolation ainsi que l’erreur d’interpolation. L’histogramme montre une distribution gaussienne de moyenne parfaitement nulle. L’erreur, comprise entre -0.1 et 0.1, possède une variance très faible, de 1.85 10-3.

Chapitre 4 / Les polynômes 125

II. Utilisation des VIs LabVIEW

Les VIs relatifs polynômes se trouvent dans la palette Mathématiques Polynômiales.

II.1. Somme, produit et division de polynômes

Dans le diagramme suivant, nous utilisons les 2 polynômes suivants :

12)( 2 xxxP et 1)( 23 xxxQ

Dans LabVIEW, les polynômes sont représentés par ordre ascendant. P(x) et Q(x) sont ainsi définis comme suit :

221)( xxxP et 3201)( xxxxQ

126 Partie I / Apprentissage de LabVIEW

La somme de 2 polynômes est un polynôme de degré le plus élevé. On ajoute les éléments de même puissance. Ainsi,

23)()( 23 xxxxQxP

Nous faisons le produit des polynômes suivants :

3201)( xxxxQ et 2231)( xxxG

En faisant le produit de ces deux polynômes, nous obtenons le polynôme suivant :

5432 25231)()( xxxxxxGxQ La division de Q(x) par G(x), donne, par une division euclidienne :

Dans le diagramme suivant, nous faisons la somme des polynômes 221)( xxxP et 1( 23 xxxQ pour former le polynôme 23)()( 23 xxxxQxP , grâce

au VI Add Polynomials.vi. Le VI order of Polynomail.vi permet de déterminer l’ordre d’un polynôme, comme ici la valeur 3 du polynôme ).()( xQxP Grâce au VI Multiply Polynomials.vi, nous faisons le produit de )(xQ et du polynôme 132)( 2 xxxG pour obtenir 13252)()( 2345 xxxxxxQxG .

On divise le polynôme 123)(1 23 xxxxP par le polynôme 12x pour obtenir le quotient 3)(1/)(1 xxQxP avec le reste Reste 2x .

Chapitre 4 / Les polynômes 127

On obtient, dans le panel, les mêmes valeurs du quotient (x+3) et du reste (x-2) que dans l’exemple étudié précédemment.

II.2. Décomposition en éléments simples, valeurs et vecteurs propres,

II.2.1. Décomposition en éléments simples

Dans ce diagramme, nous décomposons en éléments simples, le rapport des 2 polynômes suivants à l’aide du VI Partial Fraction Expansion.vi :

431

2

3

xxxx

Nous utilisons, ensuite, le quotient, les pôles et les résidus pour retrouver les polynômes du numérateur et du dénominateur précédents.

128 Partie I / Apprentissage de LabVIEW

Nous obtenons : P xS x

xx x

( )( )

. .3

1384

0 21

Nous retrouvons bien les mêmes polynômes du numérateur et du dénominateur.

II.2.2. Valeurs et vecteurs propres

Si A est une matrice carrée (nxn), un vecteur non nul est dit vecteur propre de A si A où 0)( IA Si cette équation est vérifiée, est appelé valeur propre de la matrice. L’équation )(det IA est appelée équation caractéristique de la matrice A dont les solutions sont les valeurs propres de A qu’on calcule par 0)(det IA . Nous allons utiliser la matrice suivante afin de calculer ses valeurs propres, ses vecteurs propres et son équation caractéristique.

0123

A

L’équation caractéristique s’obtient par :

2)3(1

23det)det( IA = 0

Nous obtenons l’équation du second degré suivante :

0232 Les 2 solutions, réelles, sont :

21

2,1

Chapitre 4 / Les polynômes 129

Les vecteurs propres sont définis par :

yx

yx

0123

Pour 1 : 1

11V , soit tous les vecteurs proportionnels à

uu

.

Pour 2 : 5.0

12V , soit tous les vecteurs proportionnels à

2u

u.

Dans le diagramme suivant, nous calculons les valeurs et vecteurs propres de la matrice A précédente en utilisant le VI Polynomial Eigenvalues and Vectors.vi et la commande eig du nœud MathScript. Dans le nœud MathScript, les valeurs propres sont calculées comme étant les solutions du polynôme caractéristique de la matrice A (polynôme obtenu par la commande poly) et en utilisant la commande eig. Les solutions du polynôme caractéristique sont obtenues par la commande roots. Cette commande utilisée avec 2 paramètres de retour, permet d’obtenir une matrice diagonale D dont la diagonale est formée par les valeurs propres et une matrice pleine, V constituée des vecteurs propres. Ces vecteurs propres sont bien proportionnels à ceux obtenus théoriquement.

130 Partie I / Apprentissage de LabVIEW

Le polynôme caractéristique 0232 est bien le même que celui obtenu par la théorie. Il faut remarquer que la notation de ce polynôme est propre à celle du langage MathScript et pas à celle du langage G de LabVIEW.

II.3. Polynômes rationnels

Les VIs concernant les polynômes rationnels se trouvent dans la sous-palette Mathématiques Polynomiales Polynôme rationnel. Nous disposons des opérations classiques d’addition, produit, soustraction, évaluation, etc., mais nous avons également les VIs :

Negative Feedback with Rational Polynomials.vi qui permet de calculer le polynôme en boucle fermée lorsqu’on a un retour négatif avec une

boucle ouverte 1

11 D

NG et un retour 2

22 D

NG . Plus loin, nous allons étudier le

cas d’une régulation PID. Negative Feedback with Rational Polynomials.vi qui

correspond à un retour positif. Pade approximation.vi qui permet d’approximer les polynômes du

numérateur )(xP et du dénominateur )(xQ d’une fonction rationnelle )()()(

xQxPxf

par n

k

kk xaxP

0)( et

n

k

kk xbxQ

0)( . L’approximation de Padé consiste à calculer

les coefficients ak et bk par le calcul des dérivées de f en x=0. Etc.

Chapitre 4 / Les polynômes 131

II.3.1. Addition, soustraction, décomposition en éléments simples et évaluation

Dans le diagramme suivant, le numérateur et le dénominateur de la relation 432

13

xx

xx sont

considérés comme étant la somme de 3x et de ( 1x ) sur la différence de )32( xx moins 4. Le rapport est ensuite décomposé en éléments simples. On a cherché la valeur du quotient à x=2.

Nous obtenons le résultat suivant :

12.0

48.133

)4()32(

)1(3

43213

xxx

xx

xx

xx

xx

132 Partie I / Apprentissage de LabVIEW

II.3.2. Retour négatif de polynômes rationnels

Nous allons considérer une régulation de type Proportionnel et Intégral, PI, d’un système du 1er ordre analogique de constante de temps s20 et de gain statique ,5.00H soit la fonction de transfert :

ppH

pH2015.0

1)( 0

Le régulateur possède la transmittance suivante :

pTpT

KpT

KpDi

i

i

1)11()(

Nous nous intéressons au calcul de la fonction de transfert en boucle fermée, la FTBF, en

utilisant le VI Negative Feedback with Rational Polynomials.vi. Le système est bouclé par la fonction de transfert du capteur du 1er ordre de constante de

temps scapteur 2 et de gain statique unité. Le système global est ainsi défini comme suit, si l’on choisit 1K et sTi 10 :

Si on appelle )( pH la boucle ouverte et )( pG la chaîne de retour, la fonction de transfert

en boucle fermée est donnée par :

5.0152204005.0610

)201()21(10)101(5.0)21()101(5.0

)()(1)()( 23

2

ppppp

pppppp

pGpHpHpFTBF

Grâce à la présence de l’intégration dans le régulateur, le gain statique est égal à 1. Le VI Negative Feedback with Rational Polynomials.vi calcule la

fonction de transfert de la boucle fermée suivante :

Chapitre 4 / Les polynômes 133

La fonction de transfert en boucle fermée est donnée par)()(1

)()(21

1

pGpGpGpFTBF . Le

VI Negative Feedback with Rational Polynomials.vi possède comme entrées les 4 polynômes 211 ,, NDN et 2D et retourne en sortie le numérateur et le dénominateur de la FTBF.

Dans le cas de la régulation PI, nous faisons les produits )1(*0 pTH i et pTi * )1( p en utilisant le VI Multiply Polynomials.vi. Nous faisons le rapport de ces 2

polynômes résultats par Divide Rational Polynomials.vi. Ainsi, les polynômes du VI Negative Feedback sont les suivants :

5.05001 pHpTKHN i

ppTD i 101 12N

ppD capteur 2112

Dans le panel, nous représentons les valeurs des différents polynômes.

Ci-après, nous utilisons un script de la fenêtre MathScript, dans lequel nous avons spécifié les valeurs des paramètres :

Gain K et constante de temps Ti du régulateur PI, Gain statique H0 et constante de temps du processus à réguler, Constante de temps de la fonction de transfert du capteur

134 Partie I / Apprentissage de LabVIEW

En utilisant la commande conv pour faire le produit de polynômes, nous calculons le numérateur et le dénominateur de la fonction de transfert en boucle fermée.

Les 3 pôles, dont 2 sont complexes conjugués, sont obtenus par la commande roots qui calcule les solutions du dénominateur de la FTBF. Les modules de ces pôles sont tous inférieurs à 1, ce qui montre la stabilité du système bouclé.

La commande tf, à laquelle on transmet le numérateur et le dénominateur de la FTBF retourne l’expression de la fonction de transfert du système bouclé.

5.0152004005.0610)( 23

2

ppppppFTBF

La commande lsim(FTBF, u, t) permet de tracer la réponse de la FTBF au signal d’entrée u pendant l’intervalle de temps t.

La réponse en boucle fermée avec une entrée échelon est la suivante. Le système se

comporte comme un système du 2nd degré d’amortissement optimal de 7071.02/2 . Cette réponse suit parfaitement la consigne en échelon, en régime permanent, grâce à la présence d’une intégration dans le régulateur.

Chapitre 4 / Les polynômes 135

III. Polynômes de Bessel et Chebyshev

III.1. Polynômes de Bessel

Le polynôme de Bessel d’ordre n, à la valeur x, )(xPn , est défini par la relation de récurrence suivante :

)(1)1(4

)()( 22

2

1 xPn

xxPxP nnn , avec 1)(0 xP et xxP 1)(1

Dans ce diagramme nous calculons )(2 xP pour x variant de -6 à +4 par pas de 2. Dans la boucle For, le terminal d’itération i passe par un nœud d’expression 2*(x-3) pour servir d’entrée x au VI Bessel Polynomial.vi.

Dans le panel, nous représentons la fonction )(2 xP dans un graphe XY.

Deux curseurs sont utilisés pour vérifier les valeurs 1)0(2P et .33.2)4(2P

136 Partie I / Apprentissage de LabVIEW

III.2. Polynômes de Chebyshev

III.2.1. Forme théorique du polynôme de Chebyshev

L'équation suivante définit le polynôme de Chebyshev, ).(xTn

))(arccoscos()( xnxTn pour n = 0, 1, 2, etc.

Dans ce diagramme, nous programmé le polynôme de Chebyshev d’ordre 3 en utilisant son

expression ci-dessus. A l’entrée x, nous avons appliqué l’expression )12( iN

pour avoir -1 et

+1, respectivement pour i=0 et i=N.

La courbe suivante représente l’allure du polynôme de Chebyshev d’ordre 3 programmé par sa formule théorique.

Chapitre 4 / Les polynômes 137

III.2.2. Utilisation du VI Chebyshev Polynomial.vi

Dans ce diagramme, nous programmes 3 programmes de Chebyshev, d’ordre 1, 2 et 3. A

l’entrée x, nous avons appliqué )12( iN

avec i le terminal d’itération de la boucle For et N

le terminal de décompte de valeur 20. Ainsi, la valeur de x vaut -1 lorsque i vaut 0. En fin de boucle, lorsque i vaut N, la variable x vaut 1.

Ces 3 polynômes sont les suivants.

Partie I. Chapitre 5 - Les tableaux et clusters

I. Les tableaux I.1. Création de tableaux dans le panel et le diagramme I.1.1. Création de tableaux dans le panel I.1.2. Création de tableaux dans le diagramme I.2. Création de tableaux par les boucles For et While I.2.1. Utilisation de boucles For I.2.2. Utilisation de boucles For et While I.3. Fonctions de tableaux I.3.1. Taille et initialisation d’un tableau à une dimension I.3.2. Construire un tableau, partie d’un tableau, concaténation I.3.3. Indexation d’un tableau I.3.4. Interpolation d’un tableau 1D I.4. Polymorphisme des fonctions sur les tableaux I.5. Les matrices et l’algèbre linéaire I.5.1. Sous-palette Tableau Matrice I.5.2. Sous-palette Mathématiques Algèbre linéaire I.6. Applications sur les tableaux I.6.1. Résolution des systèmes linéaires par la méthode Newton-Raphson I.6.2. Circuit électrique I.6.3. Pseudo-inverse d’une matrice II. Les clusters II.1. Création de clusters II.1.1. Création de clusters dans la face-avant II.1.2. Création de clusters dans le diagramme II.2. Disposition du cluster et modification de l’ordre de ses éléments II.2.1. Disposition du cluster et choix de l’ordre de ses éléments II.2.2. Modification de l’ordre des éléments d’un cluster II.3. Opérations sur les clusters II.3.1. Opérations sur un cluster constant dans le diagramme II.3.2. Produit de clusters II.3.3. Modification des éléments d’un cluster II.4. Transformation de tableau en cluster et inversement II.4.1. Cluster numérique et chaîne de caractères II.4.2. Calculs sur un cluster numérique II.5. Tableau de clusters II.6. Les graphes et les clusters II.6.1. Graphes déroulants II.6.2. Graphes II.7. Cluster et nœud d’expression II.8. Somme de clusters et opérations sur les éléments de clusters II.9. Résumé des fonctions de clusters

139DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _5,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie I / Apprentissage de LabVIEW

140

I. Les tableaux

Les tableaux sont des ensembles ordonnés d’éléments de même type : des booléens, chaînes de caractères, réels, waveforms ou clusters.

On ne peut pas avoir un tableau de tableaux. Pour cela, on peut utiliser un tableau multidimensionnel ou un tableau de clusters dans lequel chaque cluster peut contenir un ou plusieurs tableaux.

Un tableau peut être de plusieurs dimensions. Chaque dimension peut être indexée de 0 à

N-1 avec N le nombre d’éléments. Une colonne est un tableau à 1 dimension. Le tableau est dit à 2 dimensions lorsqu’il possède un certain nombre de colonnes et un certain nombre de lignes.

La 1ère et la 2ème dimension sont appelées, respectivement, largeur et hauteur du tableau tandis que la 3ème est dite profondeur.

I.1. Création de tableaux dans le panel et le diagramme

I.1.1. Création de tableaux dans le panel

Pour créer un tableau de réels, entiers, chaînes de caractères ou clusters, on commence par créer un élément de l’un de ces types qu’on déplace à l’intérieur d’un tableau vide (Tableau, matrice et cluster Tableau).

Une fois qu’on a placé la première valeur, on étire le tableau vers la droite ou vers le bas.

Chapitre 5 / Les tableaux et clusters 141

Pour ajouter une dimension, on pointe la souris sur l’index, et on sélectionne « Ajouter une dimension » dans le menu local. On peut supprimer une dimension par ce même menu.

Après avoir ajouté une dimension, on étire le tableau vers le bas, et on remplit les éléments du tableau par leurs valeurs.

Même lorsqu’il y a 3 dimensions ou plus, l’affichage du tableau reste sous la forme 2D.

I.1.2. Création de tableaux dans le diagramme

Pour créer un tableau constant dans le diagramme, nous choisissons Cnste tableau dans la palette précédente.

On prend ensuite une valeur numérique qu’on insère dans le tableau vide.

Partie I / Apprentissage de LabVIEW 142

Pour ajouter une dimension, on pointe, à la souris, l’index et choisir « Ajouter une

dimension » dans le menu local. Pour choisir la taille du tableau, on l’étire, vers la droite et/ou vers le bas, en plaçant la

souris dans le coin intérieur gauche du tableau :

Une fois étiré, on spécifie sa taille, en déplaçant la souris, sous forme de flèche à double

sens, sur le bord gauche ou droit du tableau.

I.2. Création de tableaux par les boucles For et While

I.2.1. Utilisation de boucles For

Les boucles For sont un moyen efficace pour créer un tableau. Dans cet exemple, nous générons, dans cette boucle, un nombre aléatoire de distribution

uniforme dont les valeurs sont comprises entre 0 et 10. Nous faisons la transformation 2x-1 avant de le sortir de la boucle ; ses valeurs sont

maintenant comprises entre -1 et 1.

Nous devons choisir le mode du tunnel et spécifier Indexation dans le menu local

obtenu par un clic droit au passage du signal sur le bord de la boucle For.

Chapitre 5 / Les tableaux et clusters 143

Nous obtenons un tableau à 5 éléments alors que la dernière valeur est bien la dernière

valeur du tableau. Si nous utilisons 2 boucles imbriquées, nous obtenons un tableau à 2 dimensions.

I.2.2. Utilisation de boucles For et While

Dans cet exemple, nous allons obtenir le même type de résultat qu’avec 2 boucles For imbriquées.

La boucle While s’arrête quand l’itération devient strictement supérieure à 1, soit les itérations 0, 1, 2.

Le nombre de colonnes est fixé par le terminal d’itération N de la boucle For, ici 5, celui des lignes par le nombre d’itérations de la While soit 3.

Nous obtenons un tableau 2D à 3 lignes et 5 colonnes.

Partie I / Apprentissage de LabVIEW

144

I.3. Fonctions de tableaux

On se propose d’étudier les fonctions les plus largement utilisées.

I.3.1. Taille et initialisation d’un tableau à une dimension

I.3.1.1.Tableau à une dimension

Dans cet exemple, on initialise à 1 un tableau de 5 éléments. Sa taille est de 5, la somme de ses éléments est aussi de 5.

Comme tous ses éléments valent 1, le produit de ses éléments est 1. On affiche la taille de ce tableau par la fonction Taille d’un tableau.

On fait la somme et le produit de tous les éléments du tableau.

Dans le panel, nous obtenons les résultats décrits précédemment.

I.3.1.2. Tableau à 2 dimensions

Pour initialiser un tableau à 2 dimensions, nous devons tirer, vers le bas, le VI Initialize Array pour spécifier le nombre de colonnes.

Dans notre cas, nous aurons un tableau à 2 lignes et 3 colonnes toutes remplies de 1.

Chapitre 5 / Les tableaux et clusters 145

Le tableau comporte 2 lignes et 3 colonnes dont tous les éléments sont égaux à 1. La somme et le produit s’appliquent à tous les éléments du tableau. C’est pour cela que la somme est égale à 6 et le produit égal à 1.

I.3.1.3. Initialisation d’un tableau multidimensionnel (plus de 2 dimensions)

Lorsqu’on veut créer un tableau à 3 dimensions, on étire vers le haut le bord haut du VI Initilize Array . Dans le cas suivant, on crée un tableau de 4 lignes, 3 colonnes et 2 pages, formé de la valeur 5.

Partie I / Apprentissage de LabVIEW

146

Nous obtenons un tableau de 4 lignes, 3 colonnes et une profondeur de 2. Le nombre total d’éléments est alors de 4*3*2 soit 24. Dans le panel nous retrouvons la taille, soit la profondeur de 2, le nombre de lignes de 4 et

de colonnes, 3. La somme des éléments du tableau, de 120 est égale au produit des valeurs de la taille,

multiplié par 5, soit : somme=5*4*3*2=120. Nous refaisons le calcul de cette somme par le produit des dimensions du tableau par la

valeur 5. Dans ce panel, nous affichons le tableau multidimensionnel, ses tailles et la somme de ses

éléments, obtenue par deux méthodes.

Chapitre 5 / Les tableaux et clusters 147

I.3.2. Construire un tableau, partie d’un tableau, concaténation

I.3.2.1. Option « Concaténer les entrées »

On se propose de construire un tableau à partir d’autres tableaux. On relie les 3 tableaux t1, t2 et t3 à la fonction Construire un tableau.

Ces tableaux à une dimension, ont respectivement, 6, 3 et 1 élément. Le tableau résultat est un tableau 2D.

Les entrées sont comblées avec des zéros afin que leur taille corresponde à celle de la plus longue entrée, ici le tableau t1.

Dans ce cas, l’option Concaténer les entrées n’est pas sélectionnée dans le menu local.

Dans le panel, nous visualisons le tableau obtenu en sortie de la fonction Construire un tableau.

La 1ère ligne est constituée entièrement du tableau t1. La 2ème ligne est formée du tableau t2 et de 3 zéros afin d’avoir le même nombre de

colonnes que le tableau t1. Il en est de même pour la 3ème ligne constituée du scalaire formant le tableau t3.

La fonction Sous-ensemble d’un tableau permet d’extraire un sous-tableau en indiquant l’index de départ d’une ligne ou de colonne ainsi que la longueur de ligne ou de la colonne du sous-tableau.

Nous obtenons le tableau 2D suivant :

Partie I / Apprentissage de LabVIEW

148

Si l’on choisit l’option Concaténer les entrées, les valeurs des tableaux t1, t2 et t3 sont concaténées les unes aux autres en commençant par t1 et en finissant par t3.

I.3.2.2. Sous-ensemble d’un tableau, suppression d’une portion de tableau

Dans le diagramme suivant, nous créons un tableau 2D constant de 4 lignes et 4 colonnes. Nous cherchons les valeurs, minimale et maximale, ainsi que leurs indices dans le tableau, en utilisant la fonction Max. et min. d’un tableau.

Pour récupérer un sous-ensemble d’un tableau, nous devons utiliser la fonction Sous-ensemble d’un tableau pour lequel, on doit spécifier l’indice de départ dans les lignes, la profondeur ainsi que l’indice de départ dans les colonnes et la profondeur. Dans ce cas particulier, le sous-tableau comportera 3 lignes à partir de la première et 4 colonnes à partir de la deuxième (indice 1).

Dans le panel, nous représentons les résultats des traitements qu’on effectue sur le tableau Tableau 2D et Tableau 1D.

La recherche d’un élément dans un tableau se fait avec la fonction Search 1D Array

qui fournit l’indice de l’élément recherché. Pour vérifier que l’élément recherché possède bien l’indice obtenu, on indexe ce tableau

avec la valeur obtenue de l’indice et on vérifie bien que c’est la bonne valeur, 3.

Chapitre 5 / Les tableaux et clusters 149

Dans notre cas, nous extrayons le sous-tableau à partir de la 1ère ligne (index 0) sur une

longueur de 3, soit les 3 premières lignes, et de la 2ème colonne (index 1) sur une longueur de 4, soit jusqu’à la 5ème colonne.

I.3.3. Indexation d’un tableau

Lorsqu’on spécifie les indexes de la ligne et de la colonne, on récupère l’élément de la ligne et de la colonne spécifiées. L’indicateur élément est l’élément de la 4ème ligne et 2ème colonne. Lorsqu’on n’indique pas la ligne ou la colonne, on récupère, respectivement, la colonne ou la ligne spécifiée. L’afficheur sous-tableau est la 3ème ligne du tableau (index 2 de ligne), tandis que sous-tableau 2 est la 2ème colonne (index 1 de colonne).

Dans le VI suivant, nous étudions les différentes façons d’indexer un tableau. Nous construisons un tableau à partir des tableaux 2D, t1 et t2. Par un clic droit sur la

fonction Construire un tableau, on sélectionne l’option Concaténer les entrées.

La taille du tableau obtenue est bien de 6 lignes et 3 colonnes.

Partie I / Apprentissage de LabVIEW

150

Lorsqu’on ne sélectionne pas cette option, la concaténation se fait selon la 3ème dimension ; on obtient donc un tableau à 3 dimensions ou 3 pages.

Au niveau de l’affichage, il reste 2D qui n’affiche que la 1ère page.

La 1ère indexation consiste à rechercher l’élément de la 4ème ligne et 2ème colonne. C’est le

cas de l’afficheur élément de valeur 1. Lorsqu’on ne spécifie que la valeur de l’indice ligne, on récupère la totalité de la ligne ;

c’est le cas de la 3ème ligne affichée dans sous-tableau. C’est le cas de la 2ème colonne de sous-tableau2.

Sur ce panel, nous avons les résultats des différentes indexations.

Chapitre 5 / Les tableaux et clusters 151

I.3.4. Interpolation d’un tableau 1D

Dans ce diagramme, nous disposons d’un tableau 2D à 5 lignes et 2 colonnes. Nous indexons la 1ère colonne (index 0) que nous affichons dans x. Nous indexons la 2ème colonne que nous affichons dans y.

Nous cherchons la valeur du tableau y d’index fractionnaire 2,5 en utilisons la fonction Interpoler un tableau 1D.

Partie I / Apprentissage de LabVIEW

152

Pour trouver la valeur à cet indice fractionnaire, on fait la moyenne de la valeur à l’indice 2 (510) et de celle de l’indice 3 (540).

Nous obtenons :

5252

540510

I.4. Polymorphisme des fonctions sur les tableaux

Le polymorphisme est le fait que certains VIs et fonctions s’adaptent au type des entrées. Certaines seulement de leurs sorties peuvent être polymorphes.

Dans le VI suivant, nous pouvons remarquer que la fonction Taille d’un tableau s’adapte au tableau qu’il soit formé de données numériques ou de chaînes de caractères. Il en est de même pour la fonction Indexer un tableau. Dans ce VI, nous désassemblons un cluster formé de 2 valeurs booléennes et une chaîne de caractères. Nous récupérons les 2 valeurs booléennes qu’on applique à la fonction Formater en chaîne qui accepte des chaînes de caractères, des valeurs booléennes et des valeurs numériques.

Chapitre 5 / Les tableaux et clusters 153

Quelque soit le type d’entrée de la taille d’un tableau, sa sortie est toujours un entier ou tableau d’entiers. La sortie de la fonction Formater en chaîne est toujours une chaîne de caractères.

I.5. Les matrices et l’algèbre linéaire

I.5.1. Sous-palette Tableau Matrice

Dans la sous-palette Matrice, nous avons quelques fonctions relatives aux matrices

comme la taille, la construction de matrices, le redimensionnement, etc.

Partie I / Apprentissage de LabVIEW

154

Dans le diagramme suivant, nous disposons de 2 matrices que nous avons définies dans le panel en définissant une matrice réelle.

Dans le diagramme suivant, nous construisons une matrice à partir des 2 matrices réelles,

définies au niveau du panel. La construction ou concaténation se fait horizontalement en choisissant l’option

« Ajouter à la fin par colonnes » dans le menu local.

Lorsqu’un élément indexé n’existe pas, le résultat est NaN (Not A Number) car la 4ème ligne n’existe pas.

La transposition de la matrice 6x3 est bien une matrice 3x6. Lorsqu’on ne spécifie qu’un index de ligne, seule cette ligne est affichée ; c’est le cas de la

1ère ligne (Matrice en sortie). La fonction Taille de matrice donne bien 3 lignes et 6 colonnes. Le même résultat est obtenu en utilisant la fonction Taille d’un tableau.

Chapitre 5 / Les tableaux et clusters 155

Le panel affiche les résultats de la construction de matrices, indexation, et opérations sur

les matrices.

I.5.2. Sous-palette Mathématiques Algèbre linéaire

La sous-palette Mathématiques Algèbre linéaire du panel, contient des fonctions qui permettent de créer une matrice spéciale, une matrice à partir de ses valeurs propres, d’effectuer les produits matriciels, l’inversion de matrices, transposition, l’exponentielle d’une matrice, la puissance d’une matrice, sa racine carrée, son logarithme, etc.

Nous pouvons aussi effectuer la décomposition en valeurs singulières (svd), décomposition QR, etc.

Partie I / Apprentissage de LabVIEW

156

Nous retrouvons la même sous-palette Matrice étudiée précédemment.

I.5.2.1. Résolution d’un système linéaire

Nous pouvons utiliser le VI Solve Linear Equations.vi pour résoudre un système linéaire de type A x = B.

On considère le système suivant, de 2 équations à 2 inconnues : La matrice A est obtenue en transformant un tableau en matrice par le VI Array To

Matrix.vi de la palette Tableau.

Nous pouvons obtenir cette solution par : x = A-1 B. L’inverse d’une matrice, ainsi que le produit d’une matrice par un vecteur, se trouvent dans

la sous-palette Mathématiques Algèbre linéaire.

Chapitre 5 / Les tableaux et clusters 157

Nous vérifions que la matrice carrée est inversible en calculant le déterminant qui ne doit pas être nul.

Lorsque le système est surdéterminé, i.e. plus d’équations que d’inconnues, la meilleure

solution est obtenue par : BAAAx TT 1)( . Soit le système surdéterminé suivant à 3 équations et 2 inconnues: 2 x1 + 10 x2 =0 x1 + 2 x2 = 2 4 x1 + 20 x2 = 1 Nous créons un tableau A, de 3 lignes et 2 colonnes que nous transformons en matrice par

le VI Array To Matrix.vi.

Nous utilisons aussi la pseudo-inverse de la matrice A, soit (ATA)-1 AT. En la multipliant par le vecteur B, nous obtenons la même solution.

Partie I / Apprentissage de LabVIEW

158

I.5.2.2. Régression linéaire par la méthode de Cramer

On considère les vecteurs de mesures suivants : x = [0.10 0.20 0.50 1.0 1.50 1.90 2.00 3.00 4.00 6.00] y = [0.95 0.89 0.79 0.70 0.63 0.58 0.56 0.45 0.36 0.28] Si on trace y en fonction de x, on remarque qu’elle suit une forme exponentielle y = a ebx.

Pour obtenir un modèle linéaire, nous devons utiliser la fonction logarithme. Nous obtenons d’autres mesures, z et x avec : z = log(y) = log(a) + b x = + x. Nous allons calculer les paramètres et par la méthode de Cramer :

N

k

N

k

N

k

N

k

N

k

N

k

N

k

kxkx

kxN

kxkzkx

kxkz

1

2

1

1

1

2

1

11

)()(

)(det

)()()(

)()(det

N

k

N

k

N

k

N

k

N

k

N

k

kxkx

kxN

kzkxkx

kzN

1

2

1

1

11

1

)()(

)(det

)()()(

)(det

Les paramètres a et b du modèle exponentiel sont alors : a=e et b=

I.5.2.3. Utilisation d’un nœud MathScript

Chapitre 5 / Les tableaux et clusters 159

Dans ce diagramme, nous avons spécifié les tableaux des données x et y ainsi que le dénominateur commun de et et leurs expressions données précédemment. Nous en déduisons les paramètres a et b puis calculons les valeurs du modèle exponentiel.

Nous traçons les valeurs de ce modèle ainsi que les données dans un même graphe XY.

Nous avons calculé la moyenne et la variance de l’erreur entre les données et celles du modèle.

Dans le panel, nous affichons les valeurs des paramètres a et b et traçons les mesures et le

modèle a ebx ainsi que l’erreur de modélisation. Nous utilisons des graphes XY pour afficher le tableau construit par les données du modèle,

des mesures ainsi que l’erreur entre les deux. La moyenne et la variance de l’erreur de modélisation sont très faibles.

I.5.2.4. Utilisation des matrices dans LabVIEW

Nous allons utiliser des VIs matriciels pour obtenir les mêmes valeurs que précédemment. Nous avons besoin de savoir comment créer une matrice. On part d’une matrice de mêmes dimensions que celle que nous voulons créer,

indépendamment des valeurs de ses éléments. Supposons que l’on veuille créer la matrice suivante :

5.42.38.25.1

A .

On part d’une matrice nulle et on utilise la fonction Définir des éléments de

matrice pour modifier les éléments de la matrice en spécifiant les indexes de ligne et colonne. Exemple pour la valeur 2.8 qui correspond à la ligne 0 et colonne 1.

Partie I / Apprentissage de LabVIEW

160

On obtient une matrice dont l’élément de la ligne 0 et colonne 1 vaut 2.8, les autres restent inchangés.

On fait de même pour les autres éléments de la matrice. On tire, vers le bas, 3 fois sur l’icône de la fonction Définir les éléments de matrice.

La matrice de départ peut contenir des valeurs quelconques, car elles seront remplacées par les valeurs à spécifier, l’essentiel est que ses dimensions soient celles de la matrice qu’on veut obtenir. Dans le diagramme suivant, nous calculons les valeurs des coefficients et , de l’exemple précédent, en utilisant les VIs de LabVIEW. Les matrices des numérateurs et du dénominateur commun sont obtenues grâce à la fonction Définir des éléments de matrice étudiée précédemment.

Chapitre 5 / Les tableaux et clusters 161

Les déterminants de ces matrices sont calculés par le VI Determinant.vi de la sous-palette Algèbre linéaire. Les quantités intermédiaires telle la somme des éléments de x ( x ) ou la somme des carrés

de ses éléments ( 2x ) sont obtenues par des VIs propres à ces opérations.

Dans le panel suivant, nous affichons la matrice nulle de départ, les vecteurs de mesure x et

y ainsi que les paramètres a et b du modèle exponentiel. Nous affichons également les matrices des numérateurs et du dénominateur commun aux

coefficients et .

Nous retrouvons les mêmes valeurs des coefficients a et b qu’avec le nœud MathScript.

Partie I / Apprentissage de LabVIEW

162

I.6. Applications sur les tableaux

I.6.1. Résolution des systèmes linéaires par la méthode Newton-Raphson

I.6.1.1. Utilisation des VIs de LabVIEW

On considère les deux tableaux x et y suivants : x = [0.10 0.20 0.50 1.0 1.50 1.90 2.00 3.00 4.00 6.00] y = [0.95 0.89 0.79 0.70 0.63 0.58 0.56 0.45 0.36 0.28]

Sur ce panel, on spécifie les 2 tableaux et on trace la courbe donnant le tableau y en fonction de x. Le tracé de y=f(x) donne les résultats suivants.

Chapitre 5 / Les tableaux et clusters 163

Le diagramme suivant utilise la fonction Assembler de la palette Cluster pour tracer la courbe y=f(x) dans un graphe XY.

Cette courbe possède une allure exponentielle de la forme bxeay . On se propose de déterminer les paramètres a et b du modèle exponentiel liant x et y. Nous allons utiliser la méthode de Newton-Raphson après avoir linéarisé le modèle

exponentiel, soit : )log()log( axby xz

Cette méthode permet d’obtenir les paramètres a et b suivants :

Dans ce diagramme, nous utilisons les fonctions somme et produit des éléments d’un tableau, la fonction exponentielle, le logarithme, le carré des éléments d’un tableau pour calculer les paramètres a et b.

Partie I / Apprentissage de LabVIEW

164

Nous disposons de 10 valeurs des tableaux X et Y, et nous souhaitons avoir les paramètres a et b du modèle suivant :

bxm eay

qui soit le plus proche des mesures. Nous calculons la moyenne et la variance de l’erreur entre les mesures et les valeurs

données par le modèle exponentiel, en utilisant le VI Std Deviation and Variance.vi.

Nous avons utilisé une variable locale afin d’éviter les fils de câblage assez longs pour

utiliser cette variable dans le calcul des ordonnées de la courbe du modèle. Sur ce panel, nous affichons les valeurs des paramètres a et b du modèle, les tableaux X et

Y ainsi que les courbes représentant le modèle exponentiel ainsi que les mesures réelles, en construisant un tableau avec les clusters (x, y) des valeurs données par le modèle et des valeurs réelles des mesures.

La moyenne et la variance de l’erreur de modélisation, -0,0055 et 0,0014, sont très faibles,

ce qui montre une très bonne qualité de la modélisation. L’affichage des expressions des paramètres a et b, se fait en copiant une image, jpg ou

bmp, et en la collant sur le panel.

Chapitre 5 / Les tableaux et clusters 165

I.6.1.2. Utilisation d’un nœud MathScript

Dans le nœud MathScript, nous utilisons essentiellement la commande sum qui permet de calculer la somme des valeurs des éléments d’un tableau. Lorsqu’on précède d’un point une opération sur deux tableaux, celle-ci s’effectue élément par élément. Les opérations x.*y, x./y permet de faire, respectivement, le produit et la division de chaque élément du tableau x par celui du tableau y de même dimension.

Dans le 2ème nœud MathScript, nous calculons la moyenne m et la variance s2 de l’erreur

e= )()( iyiy m de modélisation, par les expressions suivantes :

1

0)(1 N

iie

Nm et

1

0

2))(1

12N

imie

Ns

Nous comparons ensuite, la valeur obtenue de la valeur de cette moyenne avec celle que

l’on obtient par le VI Std Deviation and Variance.vi. Le résultat logique de cette comparaison est envoyé à la LED m?. L’écart des 2 résultats de

variance, en valeur absolue, est comparé à 10-3. Le résultat de cette comparaison est en envoyé à LED s2?.

Dans le 1er nœud MathScript, nous utilisons les fonctions relatives aux tableaux telle que

sum et les opérations élément par élément, comme « .* » et « ./ ».

Les 2 conditions étant vraies, les 2 LEDs s’allument en vert sur ce panel. Nous retrouvons les mêmes valeurs pour la moyenne et la variance de l’erreur, que précédemment, soit 0.0055 et 0.0014.

Partie I / Apprentissage de LabVIEW

166

Sur ce panel, nous affichons les courbes des mesures réelles et du modèle exponentiel, les 2 LEDs, ainsi que la moyenne et la variance.

La courbe suivante est obtenue par la fonction plot du nœud MathScript.

Chapitre 5 / Les tableaux et clusters 167

I.6.2. Circuit électrique

Soit le circuit électrique formé de 3 résistances et de 2 générateurs de tension continue.

La loi des nœuds permet d’obtenir le système d’équations suivant donnant les tensions E1 et

E2 en fonction des intensités des courants i1 et i2.

2

1

2

1

ii

AEE

avec 2

1

RRRRRR

A

On se propose de calculer ces courants avec les valeurs numériques suivantes :

10021 RR , 220R , VE 121 , VE 52

Dans le nœud MathScript, on affecte des valeurs aux différentes résistances et aux 2 générateurs de tension, ainsi que la matrice A.

Partie I / Apprentissage de LabVIEW

168

Nous aurions pu aussi les définir, dans le diagramme ou le panel, et les affecter comme des entrées au nœud MathScript.

On calcule le courant I par : 2

11

2

1

EE

RRRRRR

I

On calcule ensuite ce courant par 3 méthodes différentes en utilisant les VIs de LabVIEW relatifs aux matrices :

1- Par la méthode précédente2

11

EE

AI . Le VI Inverse Matrix.vi se trouve dans

Mathématiques Alg. Linéaire (palette Algèbre linéaire) Mat. inverse.

La matrice A, carrée doit avoir un déterminant non nul. Dans cette palette, nous trouvons les fonctions : produit des matrices, transposée d’une

matrice, etc.

2- En utilisant le VI Solve Linear Equations.vi en résolvant le système BxA . 3- En résolvant le système BxA par la méthode des moindres carrés

BAAAx TT 1)( Nous retrouvons les mêmes valeurs par ces différentes méthodes :

0193.00507.0

2

1

ii

I .

Sur ce panel, nous affichons la transposée et l’inverse de la matrice A:

2

21

RRRRRR

A .

Nous retrouvons, par ces 3 méthodes, les mêmes valeurs des courants i1 et i2.

Chapitre 5 / Les tableaux et clusters 169

I.6.3. Pseudo-inverse d’une matrice

I.6.3.1. Système déterminé

La pseudo-inverse d’une matrice A est donnée par TAAAT 1)( . Le sous-VI Pinv.vi est programmé comme suit, même si la fonction pinv existe dans la

sous-palette.

Dans le diagramme suivant, nous utilisons ce sous-système pour résoudre le système précédent.

Nous retrouvons les mêmes résultats précédents. Sur le panel, nous affichons la matrice A,

sa pseudo-inverse ainsi que le résultat qui est le même que précédemment.

Partie I / Apprentissage de LabVIEW

170

I.6.3.2. Système surdéterminé – Utilisation des VIs de LabVIEW

Cette méthode est utilisée pour la résolution d’un système surdéterminé dans lequel le nombre d’équations est supérieur au nombre d’inconnues.

Considérons le système suivant dans lequel il y a 3 équations pour 2 inconnues 1x et 2x , donc surdéterminé.

12

4.08.12

yxyx

yx

On cherche à minimiser la quantité 222 )12

()4.0()8.12( yxyxyxS qui

correspond à la somme des carrés des erreurs entre yx

A et B. La matrice A et le vecteur B

sont les suivants :

15.011

12A ,

14.0

8.1B

La matrice A et le vecteur B sont définis dans le panel. Quand on définit des valeurs

numériques dans le panel, il faut les rendre comme des valeurs par défaut, avec le menu edit Désigner les valeurs actuelles comme défaut.

Dans le diagramme suivant, nous calculons la pseudo-inverse de la matrice A qu’on multiplie par le vecteur B pour obtenir la solution au sens des moindres carrés, i.e. qui annule l’expression S précédente.

Dans la partie Statistiques de l’erreur, nous calculons la moyenne et la

variance de l’erreur A x – B.

Chapitre 5 / Les tableaux et clusters 171

Dans le panel, nous affichons la matrice A, le vecteur B, l’erreur A x – B, la pseudo-inverse

de la matrice A. Nous affichons également la solution, la moyenne et la variance de l’erreur qui sont très

faibles : 0.02222 et 0.002593.

I.6.3.3. Calcul du minimum de la solution à partir du résultat du vecteur d’erreur Ax– B.

Les valeurs du tableau de l’erreur sont également très faibles.

06667.00333.00333.0

BxA

Si on veut tracer la somme des carrés de ces erreurs, on peut utiliser la fenêtre MathScript

pour pouvoir faire des calculs interactifs. Cette fenêtre est obtenue dans Outils Fenêtre MathScript.

Partie I / Apprentissage de LabVIEW

172

La quantité est programmée dans la fenêtre de dialogue.

Cette quantité, autour de la solution est très faible et elle correspond parfaitement au minimum de la surface, calculé dans le nœud MathScript.

Ce panel permet d’afficher les résultats des calculs faits dans le diagramme précédent.

Chapitre 5 / Les tableaux et clusters 173

Dans le diagramme suivant, nous traçons la surface S de la somme des carrés des erreurs, en utilisant la commande surf dans le nœud MathScript. Grâce à la fonction Max. et min. d’un tableau, on calcule son minimum, valeur min = 0.006725 ainsi que ses indices, l’indice de x et l’indice de y.

En indexant le tableau x, on trouve la valeur x de la solution. On fait de même pour y avec son indice. Nous trouvons bien que la surface est minimum au point (x = 0.47, y = 0.83), valeurs obtenues après la résolution du système surdéterminé au sens des moindres carrés. Pour être sûr d’entourer la solution, nous choisissons de définir x et y dans l’ensemble [-1; 1]. On programme l’expression de la quantité S qui est la somme des carrés ou variance des 3 erreurs.

Lorsqu’on trace la surface 2D de l’erreur, on remarque qu’elle est minimale au niveau des

valeurs de la solution.

Partie I / Apprentissage de LabVIEW

174

Cette surface semble être à son minimum autour des valeurs (x=.5 et = 0.8). Les valeurs exactes sont données au niveau du diagramme avec un nœud MathScript.

Nous affichons le minimum de cette quantité S qui correspond parfaitement au résultat obtenu précédemment. Les indices de x et y qui correspondent sont 183 et 147. Nous affichons enfin les solutions x=0.83 et y=0.47.

I.6.3.4. Système surdéterminé – Utilisation d’un nœud MathScript

Considérons le système surdéterminé suivant :421

1

yxyxyx

Nous avons alors le système matriciel suivant :

Byx

A , avec 2111

11A et

41

1B

Du nœud MathScript, nous calculons la solution :

BApinvBAAAx TT *)()( 1 .

Cette solution correspond au minimum de la surface correspondant à la somme des carrés des erreurs.

Cette somme des carrés des erreurs, ou variance, est donnée par :

222 )42()1()1( yxyxyxS

En développant cette expression, nous obtenons :

18208463 22 yxyxyxS

La solution correspond au minimum de la surface S. On doit donc annuler les dérivées

partielles xS et

yS .

Chapitre 5 / Les tableaux et clusters 175

Ces dérivées partielles sont :

020124

0846

yxyS

yxxS

On obtient le système déterminé suivant : Byx

A , avec12446

A et 208

B

La solution de ce système doit correspondre à celle qu’on obtient avec la solution par les

moindres carrés du système précédent. En utilisant la fenêtre MathScript, nous résolvons ce système d’équations, et nous obtenons

parfaitement la même solution.

Dans ce diagramme, nous utilisons la commande pinv dans un nœud MathScript.

Partie I / Apprentissage de LabVIEW

176

Nous obtenons, comme avec la fenêtre MathScript, parfaitement les mêmes solutions.

La surface tracée avec la commande mesh possède son minimum autour de la solution

obtenue. La surface 3D suivante représente la variation de la variance de l’erreur entre le résultat de A x et le vecteur B de l’équation A x =B.

Chapitre 5 / Les tableaux et clusters 177

II. Les clusters

Les clusters ou agrégats sont des objets pouvant contenir des éléments de différents types, ordonnés de 0 à n-1.

Lorsqu’on supprime un élément du cluster, l’ordre se réajuste automatiquement. Ils permettent de rassembler un ensemble de données et éviter l’emploi de nombreux fils et ainsi faciliter la lisibilité du VI. Un cluster est comme une gaine dans laquelle on fait passer les différents fils d’un câble téléphonique ou des fils électriques. On passe alors la gaine au lieu des fils individuels. Un cluster est équivalent au type Struct du langage C. Les clusters sont recommandés lorsqu’on doit transmettre beaucoup de fils d’une partie d’un code à une autre ou à des VIs.

II.1. Création de clusters

II.1.1. Création de clusters dans la face-avant

Dans le panel du VI suivant, on crée un cluster constant de la palette Tableau, matrice et cluster. Dans la face-avant, les clusters se trouvent dans la palette Tableau, matrice et cluster. Nous trouvons le cluster, le tableau constant et des matrices.

Dans le diagramme, la palette Cluster permet de spécifier un cluster constant (Cnste

cluster), assembler des éléments d’un cluster et désassembler un cluster.

Partie I / Apprentissage de LabVIEW

178

Nous mettons dans ce cluster, respectivement et dans l’ordre:

- un tableau de réels, - une chaîne de caractères, - un bouton OK (0 ou 1), - un bouton rotatif.

Cet ordre sera celui dans lequel ces éléments seront récupérés lors d’un désassemblage du cluster. Ainsi, comme les éléments d’un tableau, les éléments d’un cluster sont aussi ordonnés selon l’ordre de leur création.

Pour réaliser ce cluster, nous utilisons le cluster constant.

Dans le diagramme, nous avons fait le désassemblage de ce cluster pour récupérer et

afficher ses éléments.

Dans ce diagramme, nous avons désassemblé le cluster défini dans la face-avant, en

utilisant le VI Désassembler par nom.

Chapitre 5 / Les tableaux et clusters 179

Les éléments du cluster sont affichés avec leur nom et leur type. La chaîne Chaine est concaténée avec la chaîne « est un langage de haut

niveau ». Nous obtenons le résultat « LabVIEW 2012 est un langage de haut niveau ». Nous avons aussi désassemblé par Désassembler où seul le type est affiché. Nous affichons uniquement le tableau et la LED Bouton OK.

Nous utilisons cette LED pour sortir de la boucle While et arrêter le VI. Nous avons également affiché le cluster de l’erreur avant et après la boucle While.

Nous ressortons le bouton rotatif afin d’en faire une recopie sur la face-avant.

II.1.2. Création de clusters dans le diagramme

Ces clusters sont définis dans le diagramme, par le cluster constant, Cnste cluster dans

la palette Cluster du diagramme.

Partie I / Apprentissage de LabVIEW

180

Exemple 1

Grâce à la fonction Assembler, nous créons le cluster constant Cluster de sortie, en assemblant des éléments (tableau de réels et tableau de booléens).

De même qu’on peut ajouter un élément supplémentaire à un cluster déjà défini comme la variable T(vraie) qu’on assemble avec le cluster contenant un tableau et une chaîne de caractères.

Nous récupérons les 2 clusters obtenus par désassemblage, que l’on peut visualiser sur la

face-avant suivante :

Exemple 2

Dans cet exemple, nous créons un cluster constant dans le diagramme. Ce cluster contient 4 éléments :

- 1 tableau, - 1 valeur booléenne, - 1 chaîne de caractères, - 1 cluster.

Le cluster interne contient 3 éléments :

- 1 réel, - 1 valeur booléenne, - 1 cluster à 2 éléments.

Chapitre 5 / Les tableaux et clusters 181

Lorsqu’on désassemble le cluster Cluster 1, nous récupérons les éléments Tableau, Chaîne ainsi que Cluster2. Il faut désassembler le cluster externe avant de le faire pour un cluster interne. Dans notre cas, nous avons utilisé la fonction Désassembler trois fois avant de récupérer la LED du cluster Cluster 3.

Nous allons montrer qu’un cluster peut posséder un élément qui est lui-même un cluster. Cluster 1 possède 4 éléments : un tableau de réels, la valeur booléenne T, une chaîne

de caractères et le cluster Cluster 2 à 3 éléments (réel, valeur booléenne F, et le cluster Cluster 3).

Ce type de désassemblage affiche sur la fonction Désassembler, uniquement le type de

chaque élément. Les indicateurs des éléments désassemblés sont représentés dans le panel suivant. Cluster 2 est le cluster interne à Cluster 1.

Partie I / Apprentissage de LabVIEW

182

II.2. Disposition du cluster et modification de l’ordre de ses éléments

II.2.1. Disposition du cluster et choix de l’ordre de ses éléments

La disposition d’un cluster peut être horizontale ou verticale. Le cluster suivant possède une disposition verticale. Nous pouvons changer cette disposition en passant de cette disposition à celle horizontale par le menu local suivant obtenu par clic droit sur le cluster.

Nous obtenons la disposition horizontale suivante :

Nous pouvons, également, ajuster la taille d’un cluster par l’option « ajuster la

taille ». Nous pouvons garder la disposition initiale avec l’option « Aucun ».

II.2.2. Modification de l’ordre des éléments d’un cluster

La modification de l’ordre des éléments dans un cluster se fait par l’option « Ordonner les commandes dans le cluster … ».

Considérons le cluster suivant dont on veut modifier l’ordre des éléments. Initialement, l’ordre est le suivant : Tableau, Chaîne, Bouton OK puis Bouton

rotatif. En appuyant sur le bouton de chaque élément, on peut changer sa valeur.

Chapitre 5 / Les tableaux et clusters 183

Une fois l’ordre

choisi avec le doigt, on appuie sur le bouton suivant :

Nous obtenons l’ordre suivant

(Chaîne, Bouton OK, puis Bouton rotatif) comme on le remarque par le désassemblage.

II.3. Opérations sur les clusters

Nous allons étudier certaines opérations sur les clusters, comme les opérations arithmétiques sur un cluster numérique, la modification des éléments d’un cluster, etc.

II.3.1. Opérations sur un cluster constant dans le diagramme

Nous considérons un cluster numérique auquel nous appliquons la racine carrée et un cluster de chaînes de caractères auquel nous appliquons des opérations de concaténation et de la transformation en majuscules. Nous avons définis 2 clusters constants dans le diagramme. Le premier est un cluster numérique qui possède 2 éléments ; un tableau et un scalaire.

Le deuxième cluster contient un tableau de chaînes et une chaîne de caractères. Nous les créons dans le diagramme suivant.

La racine carrée, appliquée au cluster numérique, s’applique à tous ses éléments. Si le

cluster possède un élément sous forme de tableau, l’opération s’applique aussi à tous les éléments du tableau.

Dans le panel, nous retrouvons un nouveau cluster, sqrt(X), dont les éléments sont la

racine carrée de ceux du cluster de départ. De même, pour le cluster qui possède les chaînes de caractères, l’opération appliquée au

cluster, s’applique à toutes les chaînes du cluster, comme ici pour la transformation en majuscule.

Partie I / Apprentissage de LabVIEW

184

Dans la face-avant suivante, nous visualisons le cluster résultat de l’opération racine carrée,

la chaîne concaténée et le cluster de chaînes transformées en majuscules.

II.3.2. Produit de clusters

Dans cet exemple, nous créons 2 clusters de mêmes dimensions afin de spécifier les unités des différents éléments du cluster de départ.

Nous spécifions un cluster sur le panel et nous faisons le produit dans le diagramme. Les éléments du cluster d’origine, sont respectivement : la pression en bars et la température en K (Kelvin).

Nous désirons les obtenir respectivement en pascals et en degrés Celsius.

Nous faisons le produit des 2 clusters, produit qui se fait élément par élément. Nous

récupérons le 2ème élément (Température) auquel on ajoute la valeur 273.15 qu’on relie au 2ème élément de la fonction Assembler pour modifier le cluster produit (x*y).

Chapitre 5 / Les tableaux et clusters 185

Nous obtenons le cluster résultat dans la face-avant.

II.3.3. Modification des éléments d’un cluster

Dans cet exemple, nous réalisations les modifications de bundles. Nous créons dans le panel, le cluster Cluster 1 qui possède 3 éléments (un tableau, un bouton Stop et une chaîne de caractères).

Lorsqu’on veut remplacer quelques éléments d’un cluster, il suffit de désassembler le cluster, utiliser la fonction Assembler dans laquelle on remplace les éléments par leurs nouvelles valeurs. On assemble à ce cluster la valeur 12 dont le résultat est affiché dans cluster de sortie 2. Nous avons ensuite désassemblé ce cluster et pris seulement le tableau et la chaîne de caractères pour en faire le cluster cluster de sortie 3.

Dans le bas du diagramme, nous avons désassemblé Cluster 1, modifié l’élément Stop

en l’inversant ainsi que transformé la chaîne en majuscules. Le tableau est remplacé par un

Partie I / Apprentissage de LabVIEW

186

autre tableau contenant uniquement le scalaire 3.14. La taille 1 est vérifiée par le VI Taille d’un tableau. Le résultat est dans le nouveau cluster cluster de sortie.

Les résultats sont dans la face-avant suivante. Quand on n’appuie pas sur le bouton stop,

il vaut 0 logique ; ainsi la LED stop est éteinte dans cluster de sortie 2.

Dans le cluster cluster de sortie, la LED stop est allumée car on a pris l’inverse

de stop de cluster de sortie 2. De plus, tous les caractères de Chaîne sont en majuscules.

II.4. Transformation de tableau en cluster et inversement

II.4.1. Cluster numérique et chaîne de caractères

On crée, dans le panel, un cluster constant numérique, nommé Cluster1. Dans ce diagramme, nous le transformons en tableau de mêmes dimensions.

L’indexation du tableau, permet d’obtenir le 2ème élément, élément. L’index vaut 1 car le langage LabVIEW commence par l’index 0.

Lorsqu’on le retransforme en cluster, nous obtenons cluster 2. Dans cet exemple, nous créons un cluster de chaîne de caractères en utilisant la fonction

Assembler.

Chapitre 5 / Les tableaux et clusters 187

Nous construisons un tableau de clusterset sa majuscule en les utilisant dans la fonction « Construire un tableau de clusters ».

Lorsqu’on transforme un tableau en cluster, on doit choisir la taille de ce dernier dans le

menu local (clic droit).

Dans le panel suivant, nous transformons un cluster en tableau qu’on indexe pour

transformer une partie en cluster. Le 2ème élément du tableau de clusters est la majuscule du 1er élément.

Partie I / Apprentissage de LabVIEW

188

II.4.2. Calculs sur un cluster numérique

Si l’on veut faire des calculs sur les éléments d’un cluster numérique, il est préférable de le transformer d’abord en tableau.

On souhaite faire la somme et le produit des éléments du cluster. Une fois transformé en

tableau, nous disposons de plusieurs façons de faire ces calculs. Dans le diagramme suivant, nous affichons le tableau équivalent au cluster. La première méthode pour faire le produit est d’utiliser la propriété d’auto-indexation de la boucle For. Lorsqu’un tableau entre dans une boucle For, nous n’avons pas besoin de spécifier le nombre N d’itérations. Celui-ci est déterminé par la taille du tableau. Les éléments sont traités par la boucle l’un après l’autre. Pour faire le produit, nous utilisons un registre à décalage que nous initialisons à 1. Le produit dans la boucle se fait selon l’algorithme suivant :

Produit(0)=1 ; For i=1 : n % n : taille du tableau Produit(i) = Produit(i-1)*x(i) end Nous utilisons ensuite la fonction Multiplier les éléments d’un tableau qui

donne le même résultat que précédemment.

On utilise le même principe pour faire la somme. Le registre à décalage est, cette fois-ci, initialisé à 0. L’utilisation de la fonction

additionner les éléments du tableau donne le même résultat qu’avec la boucle For.

On teste, à chaque fois, les deux résultats et la sortie du test (booléen) est appliquée à une LED qui s’allume quand le résultat du test est vrai (1 logique).

Chapitre 5 / Les tableaux et clusters 189

Dans le cas de la somme, l’algorithme est le suivant : Somme(0)=0 ; For i=1 : n % n : taille du tableau Somme (i) = Somme (i-1)+x(i) end

II.5. Tableau de clusters

Dans le diagramme suivant, Cluster, formé d’un tableau et d’une chaîne de caractères, est spécifié dans la face-avant. Pour construire un tableau de clusters avec celui-ci, nous devons utiliser la fonction « Construire un tableau de clusters » et impérativement des clusters de mêmes dimensions et ayant des éléments de même type que ce dernier.

Nous créons un tableau de clusters avec Cluster et un cluster constant, défini dans le diagramme. Ce tableau est affiché dans tableau de clusters.

Sa taille est déterminée par la fonction Taille d’un tableau, et vaut 2, le nombre de clusters. L’indexation d’un tableau de clusters se fait par la fonction Indexer un tableau, comme pour un tableau classique.

Partie I / Apprentissage de LabVIEW

190

Dans la face-avant suivante, nous affichons le tableau de clusters et l’élément cluster indexé, soit le deuxième.

II.6. Les graphes et les clusters

II.6.1. Graphes déroulants

Pour tracer 2 courbes sur un graphe déroulant, nous devons assembler les 2 signaux comme pour les clusters.

Dans la face-avant suivante, nous visualisons les 2 signaux, le sinus et le sinus cardinal.

Chapitre 5 / Les tableaux et clusters 191

II.6.2. Graphes

Nous générons un sinus cardinal dans une boucle For. Pour spécifier l’abscisse initial X0 et l’intervalle delta X, nous devons les assembler au

tableau défini par la boucle For.

Partie I / Apprentissage de LabVIEW

192

Dans la face-avant suivante, nous affichons le sinus cardinal avec un delta X de 1. Nous affichons également le tableau de quelques premières valeurs du sinus cardinal, ainsi

que la 1ère valeur X0 et delta X.

Graphe XY simple

Dans le diagramme suivant, nous générons un signal sinus et un cosinus (sinus déphasé

de2

) grâce à des VIs de type Express. Comme ces VIs génèrent des signaux de type

dynamique, nous les transformons en réels DBL grâce à la fonction Convertir des données dynamiques. Grâce à la fonction Assembler, nous obtenons un cluster que nous affichons dans un graphe XY.

Chapitre 5 / Les tableaux et clusters 193

Nous obtenons un cercle qui est la courbe de Lissajous ou la trajectoire d'un point dont les composantes rectangulaires ont un mouvement sinusoïdal.

II.7. Cluster et nœud d’expression

Dans le diagramme suivant, nous appliquons l’expression (2x-1) à un cluster numérique. Ceci revient à multplier par 2 tous éléments numérique du cluster et retrancher 1 au résultat. La notation x représente la variable d’entrée.

Partie I / Apprentissage de LabVIEW

194

Le nœud d’expression applique l’équation (2x-1) à chaque élément du tableau 2D et du scalaire du cluster d’entrée.

L’équation d’un nœud d’expression s’applique à tous les éléments d’un tableau ou d’un cluster.

II.8. Somme de clusters et opérations sur les éléments de clusters

Nous allons étudier la somme de 2 clusters de type numériques qui possèdent le même nombre d’éléments de même type. Dans notre cas, les clusters contiennent, tous les deux, dans le même ordre, un scalaire et un tableau numérique.

Nous avons défini 2 clusters numériques dans la face-avant. Nous avons fait leur somme pour obtenir le cluster Somme.

Cette somme se fait élément par élément, comme par l’exemple la somme des 1ers éléments

des 2 clusters qui vaut 4, et ainsi de suite. La division par 2 du cluster résultat se fait pour tous les éléments du cluster. La somme des tableaux contenus dans les clusters se fait aussi élément par élément. Nous réalisons le carré de tous éléments du 2ème cluster, Cluster2, et nous leur enlevons

la valeur 1 à l’aide du nœud d’expression par l’opération (x**2-1). Pour l’élévation au carré, nous pouvons utiliser la fonction Carré qui s’applique à chaque

élément du cluster. Le produit de clusters numériques de même type se fait élément par élément.

Sur le panel, nous trouvons les clusters constants ainsi que les résultats des différentes opérations.

Chapitre 5 / Les tableaux et clusters 195

II.9. Résumé des fonctions de clusters

Nous avons, ci-dessous, la totalité des fonctions de clusters. Au niveau du panel, il y a le cluster constant que nous trouvons aussi dans le diagramme ainsi que les clusters d’erreur en entrée et en sortie.

Diagramme Panel

Dans le diagramme suivant, le cluster d’erreur en entrée est appliqué en entrée de la boucle

While avec un mode de tunnel en « Dernière valeur ». Après avoir relié chaque sortie d’erreur d’un VI à l’entrée d’erreur du VI qui le suit, on

termine par le cluster d’erreur en sortie qu’on place en sortie de la boucle avec le même mode de tunnel.

Cette gestion de l’erreur concerne les 3 VIs de type Express (Simuler un signal et Temps d’attente).

Partie I / Apprentissage de LabVIEW

196

Le VI Simuler un signal fournit un signal de type dynamique. Pour le transformer en type double, nous devons utiliser Express Manipulation de signaux Convertir des données dynamiques.

Nous avons défini, dans le panel, un cluster constant contenant l’écart-type, l’offset du

bruit, un interrupteur On/Off et une commande Signal. Pour modifier Cluster bruit afin de brancher le signal bruit, nous devons utiliser la

fonction Assembler par nom. Le signal de bruit sera branché à l’entrée Signal tandis que Cluster bruit sera

appliqué à la partie centrale de cette fonction. Ensuite, nous désassemblons par nom ce cluster pour récupérer les éléments offset,

écart-type, la commande On/Off ainsi que le signal bruit Signal. Cet écart-type et l’offset sont transmis aux entrées du VI simuler un signal par l’intermédiaire de variables locales.

Le signal sera appliqué au graphe déroulant Graphe bruit. Nous utilisons également un simulateur de générateur triangulaire, dont la fréquence est

spécifiée par la jauge fréquence triangle. Nous obtenons un tableau de clusters en utilisant la fonction Indexer et assembler

un tableau de clusters.

Dans ce panel, nous retrouvons le cluster bruit, la jauge pour fixer la fréquence du signal

triangle. Les variable offset et écart-type sont visibles dans la section bruit. Nous

affichons les 2 éléments du tableau de clusters. Nous affichons enfin les graphes déroulants du bruit et du signal triangulaire.

Chapitre 5 / Les tableaux et clusters 197

Partie I. Chapitre 6 - Les boucles et structures

I. Boucle For I.1. Factorielle d’un nombre entier I.2. Equation de récurrence I.2.1. Boucle For et registre à décalage I.2.2. La boucle For et les tableaux II. Boucle While III. Boite de calcul III.1. Equation de récurrence III.2. Limitation d’un signal entre des valeurs, minimale et maximale III.3. Calcul de la moyenne et de la variance d’un signal aléatoire IV. Structure Condition IV.1. Structure à 2 conditions - limitation d’un signal IV.2. Structure à plusieurs conditions V. Structure Evénement V.1. Gestion des propriétés d’un tracé V.1.1. Modification de propriétés d’objets graphiques V.1.2. Modification de la couleur du nuage des points V.1.3. Modification du type de marqueur sur le nuage de points V.1.4. Gestion de l’appui sur le bouton stop V.1.5. Gestion de l’épaisseur du trait V.1.6. Gestion de la couleur du texte de l’affichage des paramètres a et b V.1.7. Police des caractères de l’axe des abscisses et du titre du graphique V.1.8. Modification de la couleur de la droite de régression V.2. Evénements liés au déplacement de la souris, dialogue utilisateur VI. Structure Elément en place VI.1. Opération sur les tableaux et waveforms VI.2. Intérêt de la structure Elément en place VI.2.1. Temps de calcul avec structure en place VI.2.2. Temps de calcul sans structure Elément en place VII. Structure Séquence déroulée VII.1. Structure à 2 étapes VII.2. Structure à 3 étapes VIII. Structure Séquence empilée IX. Nœud MathScript IX.1. Récupération d’une sinusoïde par filtrage passe-bande IX.2. Interpolation exponentielle IX.2.1. Méthode de Newton IX.2.2. Utilisation des VIs d’interpolation de LabVIEW IX.2.3. Utilisation de la méthode des moindres carrés IX.3. Distributions, triangulaire et gaussienne, méthode de Box-Muller IX.4. Equation du 2nd degré IX.5. Régulation proportionnelle et intégrale, PI IX.5.1. Sous-VI du processus IX.5.2. Sous-VI du régulateur PID IX.5.3. Programme principal de la régulation PID IX.5.4. Régulation PI dans une boucle de contrôle et simulation

199DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _6,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie I. Apprentissage de LabVIEW

200

Dans la palette Structures, nous trouvons les boucles (For, While), la structure Condition, le nœud MathScript dans lequel nous pouvons programmer dans un langage proche à MATLAB, la boite de calcul avec un langage proche du C, etc.

I. Boucle For

Le langage G de LabVIEW possède 2 structures permettant de répéter l’exécution d’un ensemble de VIs; les boucles For et While.

La boucle For s’exécute un nombre de fois défini par le nombre N. L’indice i d’itération va toujours de 0 à (N-1).

Comme en langage C, c’est une structure itérative permettant d’exécuter une partie de

programme un nombre déterminé de fois, connu à l’avance.

I.1. Factorielle d’un nombre entier

La factorielle d’un nombre n est définie par : n !=n*(n-1)*…*1 Dans la boucle For suivante, nous calculons la factorielle de l’entier n, par l’expression

suivante : fact_n=1 for i=0 à n-1

fact_n=fact_n*(i+1) end

Chapitre 6 - Les boucles et structures 201

Cette formule est programmée dans la boucle For suivante du VI factorielle.vi. L’itération de la boucle For va de i=0 à 5. La factorielle est calculée comme suit : factorielle(0)=1 ; for i=1 à 5 factorielle(i)=(i+1)*factorielle(i-1) ; end Dans le diagramme suivant, nous avons utilisé ce même algorithme dans un nœud

MathScript. La différence est que l’itération de la boucle For du langage MathScript commence à la

valeur 1. Nous avons calculé cette factorielle en utilisant les commandes gamma et prod.

Nous avons obtenu le même résultat avec les différentes méthodes. En sortie du nœud MathScript, nous obtenons un tableau que nous devons indexer. La

valeur de la factorielle est l’avant-dernière valeur de ce tableau.

Partie I. Apprentissage de LabVIEW

202

I.2. Equation de récurrence

I.2.1. Boucle For et registre à décalage

I.2.1.1. Equation de récurrence non linéaire

On se propose de résoudre l’équation de récurrence suivante:

21 cos5.08.01 nnn xxx

On utilisera une boucle For avec registres à décalage. Nous avons pris N=20 pour le nombre d’itérations. Ce nombre est suffisant pour avoir une bonne convergence de la solution. Nous avons alors décidé d’arrêter le VI si la différence entre les valeurs successives est inférieure à 0.001. Si cette condition est vérifiée, son résultat logique de 1 est envoyé au VI STOP qui arrête l’exécution du VI. Cette condition n’est effectuée que pour i strictement supérieur à 2. Nous affichons la valeur absolue de l’erreur lorsqu’elle est inférieure à 0.001.

Le panel suivant affiche l’évolution du signal xn. La valeur finale de l’écart entre 2 valeurs

successives est égale à 0,000266529. La condition sur cette erreur est alors vérifiée à la 15ème itération.

Chapitre 6 - Les boucles et structures 203

I.2.1.2. Boucle While, boite de calcul et registre à décalage

Dans le diagramme suivant, nous avons programmé l’équation de récurrence dans une boite de calcul.

Les entrées x1 et x2 sont les valeurs x(n-1) et x(n-2) de la variable x(n), obtenues grâce à l’utilisation d’un registre à décalage.

On utilise une structure condition dans laquelle on teste la valeur absolue de l’écart entre les échantillons successifs.

Si cet écart absolu devient inférieur à 0.001, on considère ainsi qu’on a obtenu la convergence totale de la solution. Auquel cas, on envoie une valeur 1 logique au VI STOP qui permet d’arrêter l’exécution du programme.

Avant de faire ce test, on s’assure qu’on a dépassé l’échantillon n°2. On affiche dans le panel, les valeurs x(n) et x(n-1) ainsi qu’un graphe déroulant pour

observer l’évolution de la solution temporelle. Les valeurs initiales de la solution des 2 échantillons, x(0) et x(1) sont toutes 2 choisies

égales à 10.

Dans le panel, nous observons une convergence oscillatoire de la solution vers la valeur 0.756513.

L’écart 442.20.756755-0.756513)1()( enxnx , est bien inférieur à la précision

souhaitée de 1e-3. Nous avons obtenu cette convergence à l’échantillon n° 21.

Partie I. Apprentissage de LabVIEW

204

I.2.1.3. Nœud MathScript et nœud de rétroaction

Au lieu d’utiliser le registre à décalage pour obtenir les valeurs x(n-1) et x(n-2) antérieures à l’instant courant n, nous utilisons 2 nœuds de rétroaction, tous deux initialisés à 0.

La manière de tester la convergence est la même que précédemment. Ici l’équation

récurrente est programmée dans un nœud MathScript.

Chapitre 6 - Les boucles et structures 205

Grâce aux conditions initiales nulles, la convergence est atteinte au bout de l’instant n=14, avec un écart 467.20.757752-0.757485)1()( enxnx .

I.2.1.4. Boucle For et nœud de rétroaction

L’opérateur retard d’une cadence d’échantillonnage, , se trouve dans la même palette Structures. Il possède le même rôle qu’un registre à décalage.

Un nœud de rétroaction est semblable à un bloc z-1, le retard d’une cadence d’échantillonnage.

Utilisé dans la théorie de la régulation et du traitement de signal, il permet de stocker les valeurs précédentes d’un signal.

On peut modifier son apparence pour qu’il ressemble au bloc z-1.

Partie I. Apprentissage de LabVIEW

206

Par un clic droit, nous pouvons modifier l’apparence de ce nœud pour le transformer sous forme du retard 1z , le nœud de délai de transformée en Z.

I.2.1.5. Equation de récurrence non linéaire

Le VI suivant permet de résoudre l’équation différentielle du second ordre suivante :

)cos(*5.08.01 21 nnn xxx

Dans le diagramme suivant, nous utilisons 2 nœuds de rétroaction pour retarder la valeur de xn et obtenir xn-1 et xn-2.

La valeur 0 en bas de l’opérateur retard est la valeur d’initialisation de xn-1 et xn-2 comme

nous l’avons fait avec le registre à décalage. Lorsque l’itération i est supérieure à 2, nous testons la valeur absolue de l’écart entre xn-1 et

xn-2. Lorsque cet écart est inférieur à 0.001, nous arrêtons l’exécution de ce VI grâce au bouton

STOP.

Solution en régime permanent

Nous décidons de calculer la valeur en régime permanent du signal xn. Lorsque l’itération n tend vers l’infini, en régime permanent, nous avons :

nnn 21 . Ainsi, nous pouvons écrire :

8.1cos5.01 n

nx

x

Nous allons chercher graphiquement la valeur de l’itération n, telle que la valeur absolue

de l’erreur devienne plus faible qu’une certaine valeur limite. Dans notre exemple, nous avons :

001.08.1cos5.01 n

nx

x

Nous calculons la valeur absolue de cette erreur dont nous testons son infériorité à la

valeur 0.001. Pour capturer la solution qui répond à ce critère, nous disposons un afficheur dans une

structure condition qui est valide uniquement quand la condition sur l’erreur est vérifiée. Nous traçons la solution dans un graphe déroulant.

Chapitre 6 - Les boucles et structures 207

Dans le panel suivant, nous affichons la valeur de l’itération n et la valeur du signal xn.

Lorsque la condition sur l’erreur est vérifiée, nous affichons la valeur de la solution du régime permanent.

Solution générale

Dans le diagramme, nous utilisons des nœuds de rétroaction initialisés à 0. Lorsque la condition sur l’erreur est vérifiée (valeur absolue<0.001), le VI s’arrête et nous affichons la valeur de cette erreur en valeur absolue.

Partie I. Apprentissage de LabVIEW

208

Il y a convergence à 0.001 près au bout de la 15ème itération, comme on l’observe dans le panel suivant. Nous retrouvons la valeur obtenue précédemment en régime permanent.

I.2.1.6. Boucle For avec nœud de rétroaction et registre à décalage

Nous pouvons utiliser simultanément un nœud de rétroaction pour retarder une variable et un registre à décalage pour retarder l’autre.

Nous remplaçons un nœud de rétroaction par un registre à décalage en choisissant

« Remplacer par un registre à décalage » après un clic droit sur le nœud qu’on va remplacer.

Chapitre 6 - Les boucles et structures 209

La boucle For suivante utilise, à la fois un registre à décalage et un nœud de rétroaction:

Inversement, un registre à décalage peut aussi être remplacé par un nœud de rétroaction.

Partie I. Apprentissage de LabVIEW

210

Nous obtenons le même résultat que précédemment.

I.2.1.7. Equation de récurrence du 1er ordre

Dans le VI suivant, nous considérons un processus discrets du 1er ordre de pôle de -0.2 puis

de -0.8. Si u(k) et y(k) sont respectivement l’entrée et la sortie, la réponse indicielle (u=1) est

décrite par l’équation de récurrence suivante :

)1(1)( kyaky

Dans le 1er VI, nous utilisons un nœud de rétroaction et dans le 2ème, un registre à décalage.

Pour mettre le nœud d’initialisation sur le bord gauche de la boucle For, nous choisissons

l’option « Déplacer le terminal d’initialisation d’une boucle vers l’extérieur » dans le menu local.

Dans le panel suivant nous affichons les réponses indicielles des 2 processus avec un mode oscillant, stable car les 2 pôles sont positifs, inférieurs à 1 en valeur absolue.

Chapitre 6 - Les boucles et structures 211

I.2.2. La boucle For et les tableaux

I.2.2.1. Création de tableaux

La boucle For est un moyen de créer un tableau à plusieurs dimensions. La sortie d’une boucle For est affichée dans un indicateur à travers un tunnel.

Dans l’exemple suivant, nous avons utilisé 2 modes pour ce tunnel : Indexation et Dernière valeur, soit on obtient un tableau de N valeurs, soit uniquement la dernière valeur.

Pour créer un tableau à n dimensions, il faudra utiliser n boucles For imbriquées.

L’exemple suivant permet de créer un tableau à 2 dimensions.

Partie I. Apprentissage de LabVIEW

212

La longueur de la première boucle correspond au nombre de lignes, celle de la boucle

intérieure au nombre de colonnes. Nous obtenons ainsi un tableau à 2 lignes et 5 colonnes. La dernière valeur correspond au

tableau des 2 dernières lignes.

I.2.2.2. Tableaux à l’entrée de la boucle For

Dans cet exemple, nous appliquons un tableau à l’entrée de la boucle For. N, le terminal de décompte de la boucle est égal à 12 alors que la taille du tableau est de 5 uniquement.

Dans ce cas, c’est la taille du tableau qui limite le nombre d’itérations même si on

n’applique pas une valeur au terminal de décompte N qui limite le nombre d’itérations. En sortie de la boucle, le résultat de la racine carrée et le terminal d’itération deviennent

des tableaux de mêmes dimensions que le tableau d’entrée.

Chapitre 6 - Les boucles et structures 213

La sortie d’une boucle For est un tableau dont la taille est égale à la valeur du terminal de

décompte N de la boucle. Inversement, lorsqu’on applique un tableau à une boucle For, pour laquelle on ne spécifie

pas la valeur du terminal N, la boucle s’arrête lorsqu’on a traité tous les éléments du tableau : c’est l’auto-indexation.

Nous appliquons l’expression (2 x -1) à un signal aléatoire random dans une boucle For.

En sortie nous obtenons un tableau. Ce tableau devient un scalaire à l’intérieur de la deuxième boucle For (trait fin). Nous utilisons une boite de calcul pour tester le signe de chaque valeur que nous

transformons en 99^2 lorsqu’elle est négative. Nous prenons ensuite la racine carrée de cette valeur. Le résultat se transforme en tableau

en sortie de la boucle.

Partie I. Apprentissage de LabVIEW

214

Les racines carrées des valeurs négatives sont remplacées par la valeur 99.

I.2.2.3. Limitation d’un signal entre des valeurs, minimale et maximale

Ce VI utilise une boucle While avec un nœud de rétroaction pour construire un tableau, à

partir du signal sinusoïdal, )100

2sin( i , généré dans un nœud MathScript.

Un graphe affiche les valeurs de ce tableau au fur et à mesure qu’il se construit. La boite de calcul reçoit, comme entrées, les valeurs, maximale Maxi et minimale mini,

qui limitent le signal sinusoïdal qui arrive par l’entrée x. Dans cette boite de calcul, la variable cond logique est égale à 1 logique lorsque le signal

est supérieur ou égal à mini et inférieur ou égal Maxi, autrement il vaut 0. Seules les données comprises entre les valeurs inférieures ou égales à Maxi et supérieures

ou égales à mini sont intégrées au tableau lorsque la valeur logique vaut 1, ce qu’on obtient par la condition on cond>0.

Chapitre 6 - Les boucles et structures 215

Dans ce panel, nous affichons le signal sinusoïdal d’origine ainsi que celui qui a été limité. Les valeurs Maxi et mini sont spécifiées par un bouton rotatif et une jauge.

Le bouton STOP permet d’arrêter l’exécution du programme.

II. Boucle While

Pour la boucle For, le terminal de décompte N est connu à l’avance. La valeur associée à ce terminal détermine le nombre d’itérations.

Cette boucle exécute un ensemble de VIs jusqu’à ce qu’une condition d’arrêt soit remplie. La boucle While s’exécute au moins une fois. Elle s’exécute indéfiniment jusqu’à ce que le terminal d’arrêt reçoive une valeur logique 1

ou T (vraie). Cette condition peut se réaliser par programmation ou par l’appui sur un bouton stop sur

la face-avant qui envoie un 1 logique sur le terminal d’arrêt de la boucle While. La boucle While s’exécute aussi longtemps que la valeur du terminal conditionnel reste

TRUE (vrai). Dans l’exemple suivant, nous traçons un signal aléatoire uniforme dans un graphe

déroulant. Les différentes itérations sont cadencées par une période de 200 ms. La boucle ne s’arrête que lorsqu’on appuie sur le bouton STOP.

Partie I. Apprentissage de LabVIEW

216

Lorsqu’on appuie sur le bouton STOP, on quitte la boucle While.

L’utilisation des nœuds de rétroaction et des registres à décalage dans une boucle While est identique à celle dans les boucles For.

Les boucles For et While peuvent avoir autant de registres à décalage que besoin.

III. Boite de calcul

La boite de calcul est un nœud en mode texte, à l’instar du nœud MathScript, qui permet d’effectuer des calculs dans le diagramme d’un VI.

Les boites de calcul permettent d’éviter des opérations graphiques qui nécessitent

l’utilisation d’un grand nombre de VIs. Il n’y a pas de limite au nombre d’entrées et de sorties. La création des entrées et des

sorties se font par un clic droit et, respectivement, en choisissant les options Ajouter une entrée et Ajouter une sortie en pointant les bords, gauche et droit, de la boite.

La syntaxe de programmation est très proche de celle du langage C.

Chapitre 6 - Les boucles et structures 217

La syntaxe du langage dans une boite de calcul est semblable, mais pas nécessairement

identique, à celle du langage C. La boite de calcul permet d’accepter des instructions mathématiques élémentaires et des

instructions telles : - If …, Then …, else - do « instruction » while (affectation ) - Break qui arrête les boucles For et While - Continue - switch (affectation ) { liste-instruction-conditionnelle } On utilise le mot-clé continue pour transmettre le contrôle à l'itération suivante de la

boucle Do, For ou While la plus proche dans la boîte de calcul. La syntaxe est proche de celle du langage C telles les instructions suivantes : If(y==x && a[2][3]<a[0][1]) {

int32 temp; temp = a[2][3]; a[2][3] = y; y=temp; }

else x=y;

Ces instructions sont équivalentes à l’algorithme suivant : Si y=x et que l’élément (2,3) du tableau a est inférieur à l’élément (0,1) : Alors { On définit l’entier temp On affecte l’élément (2,3) à la variable temp On affecte la valeur de y à l’élément (2,3) On affecte la valeur temp à la variable y } Sinon On affecte la valeur de y à x

Partie I. Apprentissage de LabVIEW

218

III.1. Equation de récurrence

On se propose de résoudre l’équation de récurrence non linéaire suivante :

)cos(5.08.01 21 nnn xxx

On programme cette équation dans une boite de calcul qu’on insère dans une boucle For afin de réaliser l’itération sur 50 pas. Pour récupérer, à chaque pas de calcul n, les valeurs antérieures 1nx et 2nx , nous utilisons un registre à décalage qu’on initialise à 10.

L’évolution de la solution est tracée dans un graphe déroulant à l’intérieur de la boucle. Le tout est cadencé à 200 ms par le balancier.

Dans le panel suivant, nous affichons l’évolution de la solution de la solution.

Chapitre 6 - Les boucles et structures 219

III.2. Limitation d’un signal entre des valeurs, minimale et maximale

Dans cet exemple, on réalise une limitation d’un signal sinusoïdal entre des valeurs, minimale et maximale.

Le signal à limiter est généré dans un nœud MathScript. Les valeurs 0.8 et -0.5 sont

câblées aux entrées Maxi et mini de la boite de calcul. Nous utilisons la structure if … then … else pour limiter le signal représenté par l’entrée x.

Dans le panel suivant, nous affichons la sinusoïde d’entrée et le signal limité entre -0.5 et

0.8.

Un autre exemple de limitation d’un signal sera fait plus loin en utilisant la structure

Condition.

Partie I. Apprentissage de LabVIEW

220

III.3. Calcul de la moyenne et de la variance d’un signal aléatoire

Nous allons utiliser une boite de calcul pour effectuer la moyenne et la variance d’un certain nombre de valeurs aléatoires de distribution uniforme.

Une variable aléatoire uniforme x, entre a et b, possède la moyenne suivante :

b

a

abdxxab

x2

1

Sa variance est :

12)(

4)(

)(31 2233

222 ababab

abxdxxab

b

ax

Avec : a=0, b=1,

nous avons : 5.0x

0.0833 1212

x

Dans le diagramme suivant, le langage utilisé dans une boite de calcul possède la même

syntaxe que le langage C. La taille de l’échantillon est l’entrée n. A l’intérieur de la boite de calcul, nous définissons le paramètre i d’itération de la boucle

comme un entier codé sur 32 bits, les variables moyenne, somme, le tableau tab et la variable variance comme des flottants.

A l’aide d’une boucle For, nous remplissons le tableau tab avec des valeurs aléatoires,

rand, de distribution uniforme. La moyenne est calculée par l’expression :

n

ixx i

)(,

avec n le nombre de valeurs. La variance est donnée par l’expression suivante :

1

)( 2

2

n

xixi

x

Dans le diagramme suivant, nous faisons le calcul de la moyenne et de la variance d’un

tableau de valeurs aléatoires dans une boite de calcul. La syntaxe du langage est celle du C.

Chapitre 6 - Les boucles et structures 221

Après définition des types des différentes variables, nous utilisons 2 boucles For pour le calcul de la moyenne et de la variance.

Les valeurs obtenues de la moyenne et la variance vérifient les valeurs théoriques. Dans le panel, nous affichons les valeurs de la moyenne et de la variance ainsi que le

graphe du signal temporel.

Partie I. Apprentissage de LabVIEW

222

IV. Structure Condition

La structure peut être considérée comme un IF ou un CASE. Elle traite tout type de données (entrée numérique, chaîne, booléen, énumération...)

IV.1. Structure à 2 conditions - limitation d’un signal

Une structure comporte plusieurs sous-diagrammes dont un seul sera exécuté selon la condition qui est réalisée. La condition à tester est câblée à l’entrée « ? ».

Comme exemple, nous allons utiliser la structure Condition pour limiter un signal entre une valeur minimale et une valeur maximale.

Dans ce cas particulier, nous utilisons 2 boucles imbriquées, car lorsque le signal est plus grand que la valeur minimale, on doit tester le cas où il serait aussi plus grand que la valeur maximale.

Nous générons un signal par le VI de type Express Simuler un signal. Nous testons ce signal aux valeurs, maximale Val_max et minimale Val_min.

Dans cet exemple, nous présentons le cas où le signal est plus grand que Val_min et plus

petit que Val_max, auquel cas on récupère en sortie la valeur du signal. Nous utilisons 2 structures condition imbriquées pour tester les différentes conditions. Ci-après, nous décrivons les 3 séquences de la structure à 2 conditions imbriquées selon la

valeur du signal par rapport aux seuils, minimal et maximal.

Chapitre 6 - Les boucles et structures 223

{x>=Val_min} faux alors y=Val_min.

{(x>=Val_min) vrai et (x<= Val_max) vrai} alors y=x.

{(x>= Val_min) vrai et (x<= Val_max) faux} alors y= Val_max.

Le signal est bien limité entre la valeur val_min=-0.5 et Val_max=0.8.

Partie I. Apprentissage de LabVIEW

224

IV.2. Structure à plusieurs conditions

Dans cet exemple, nous allons spécifier un filtre numérique dans un nœud MathScript.

Nous allons utiliser une structure condition afin de spécifier le type de filtre numérique afin de filtrer un signal somme de 3 sinusoïdes.

Le type de filtre sera spécifié par un menu déroulant qui se trouve dans la palette Menu

déroulant et énum du panel.

Afin de spécifier les éléments du menu, on choisit l’option Editer les éléments … dans le menu local qu’on obtient par un clic droit.

Par le bouton Insérer, on spécifie les éléments qu’on peut réorganiser à la fin avec les

boutons Déplacer vers le haut et Déplacer vers le bas.

Le diagramme suivant est constitué de 2 nœuds MathScript. Dans le nœud MathScript de gauche, on spécifie 3 sinusoïdes de fréquences respectives de

10, 25 et 40 Hz. On fait la somme de ces sinusoïdes pour produire le signal xtot qu’on va filtrer. Le menu déroulant possède les 3 valeurs suivantes qui spécifient le type de filtre : passe-

bas, passe-haut et passe-bande.

Chapitre 6 - Les boucles et structures 225

Dans la séquence 0, nous spécifions un filtre passe-bas de Butterworth, de fréquence de coupure 12 Hz grâce à la commande Butter afin de récupérer la sinusoïde de fréquence 10 Hz. Cette commande permet de récupérer le numérateur B(z-1) et le dénominateur A(z-1) de ce filtre. On filtre le signal somme, xtot grâce à la commande filter à laquelle on transmet le numérateur B(z-1) et le dénominateur A(z-1).

La commande freq permet d’obtenir et de tracer la réponse en fréquences de ce filtre. On calcule la FFT du signal de sortie du filtre par la commande fft. On trace ensuite cette

FFT grâce à la commande stem.

Dans cet exemple, nous utilisons des nœuds de propriété qui permettent de rendre invisibles les oscilloscopes des résultats des filtres passe-haut et passe-bas.

On rend visible (valeur T à la propriété Visible) l’oscilloscope dans lequel on trace les résultats du filtre passe-bande et la sinusoïde x2 de 25 Hz. Dans le panel suivant, nous affichons la sinusoïde x2 de fréquence 25 Hz en même temps que la sortie du filtre passe-bas.

Partie I. Apprentissage de LabVIEW

226

Nous affichons également le numérateur B(z-1) et le dénominateur A(z-1) du filtre. Après le régime transitoire, le signal de sortie du filtre possède la même fréquence que la

sinusoïde de fréquence 25 Hz. La figure suivante représente la réponse en fréquences du filtre passe-bande.

La FFT du signal de sortie du filtre montre qu’on récupère bien la sinusoïde de 25 Hz.

Chapitre 6 - Les boucles et structures 227

V. Structure Evénement

La structure événement possède un ou plusieurs sous-diagrammes dont un exactement est effectué lorsque la structure s'exécute.

La structure attend qu’un événement ait lieu pour exécuter la condition qui lui correspond pour gérer cet événement. Les événements sont asynchrones et dus aux actions de l’utilisateur sur la face-avant.

La programmation événementielle permet d’interroger l’état des objets de la face-avant pour détecter tout changement (modification de la valeur d’un menu déroulant, saisie au clavier, etc.).

L’arrêt de cette boucle est alors un événement que l’on doit gérer pour quitter la boucle, ou

carrément LabVIEW. Comme la structure Evénement ne gère qu’un seul événement à la fois, on doit la mettre à l’intérieur d’une boucle While.

Une fois l’événement géré, la structure Evénement attend qu’un autre événement se

produise. La structure Evénements se trouve dans la palette Structures.

Une valeur entière reliée au terminal Timeout permet de spécifier le nombre de

millisecondes pendant lequel la structure Événement doit attendre qu'un événement se produise.

L’événement Timeout est prioritaire sur tous les événements gérés par la structure. La

valeur par défaut, de -1, correspond à un temps infini, ce qui équivaut au cas où la structure Evénement attend indéfiniment l’apparition d’un événement.

Pour ajouter une condition d’événement, on choisit l’option « Ajouter une

condition d’événement… » dans le menu obtenu par un clic droit sur le bord de la structure.

Partie I. Apprentissage de LabVIEW

228

Une fois, la condition ajoutée, on édite l’événement à gérer avec l’option « éditer les événements gérés par cette condition… ».

Nous obtenons la fenêtre suivante qui montre les sources événements au centre, dans notre

cas les objets de la face-avant, les événements à droite, ici Valeur changée qui consiste au changement de l’état de l’objet.

Dans cette fenêtre, on peut ajouter un événement ou supprimer l’événement actuel.

On peut visualiser toutes les conditions déjà éditées de la structure, par l’option « Visualiser la condition » du menu local.

Ceci permet d’aller vers une des conditions déjà éditées sans passer par le sélecteur

d’étiquettes, notamment lorsqu’il y a un nombre important de conditions.

Chapitre 6 - Les boucles et structures 229

Néanmoins, ceci peut se faire directement avec la souris en pointant l’étiquette de la condition sur laquelle on se trouve.

Dans ce menu local, on peut supprimer ou dupliquer une condition d’événement.

Pour plus de lisibilité, on peut éditer une étiquette pour chaque sous-diagramme en choisissant « Etiquette de sous-diagramme » dans « Eléments visibles » après un clic droit en positionnant le pointeur de souris sur le bord droit de la structure.

Partie I. Apprentissage de LabVIEW

230

Les variables trait, abscisses, titre, txt1 et txt2 sont déclarées comme globales dans le 1er nœud MathScript afin qu’on puisse changer leurs propriétés dans le 2ème nœud MathScript.

Dans cet exemple, nous avons choisi comme étiquette « Choix de la couleur du trait de la droite de régression » pour la condition n°6 correspondant à la condition « Couleur du trait ».

V.1. Gestion des propriétés d’un tracé

V.1.1. Modification de propriétés d’objets graphiques

Dans cet exemple, nous allons étudier la gestion des propriétés des graphiques et des textes grâce aux événements qui ont lieu sur la face-avant.

Nous traçons un nuage de points et la droite de régression selon le principe des moindres carrés.

La régression consiste à dire que la variance ),( ba de l’erreur, entre cette droite et les

mesures, est minimale, à savoir que les dérivées partielles a

et b

sont nulles.

Cette variance s’écrit : 22 )( bxay ii

Chapitre 6 - Les boucles et structures 231

En annulant ces dérivées partielles, nous obtenons :

2)(

)()(xx

yyxxa

i

ii ,

avec xayb .

Nous allons tracer le nuage de points ainsi que la droite de régression pour lesquels nous allons modifier, par programmation, les propriétés graphiques (épaisseur du trait, couleur, type de trait) ainsi que celles des caractères (titre, axes).

Dans le diagramme suivant, le nœud MathScript de gauche constitue le programme principal. On génère un nuage point et on calcule les paramètres a et b de la droite de régression comme précédemment. Le nuage de points est réalisé par un signal aléatoire pour lequel on applique une transformation linéaire. Dans la boucle While, nous gérons les événements qui ont lieu dans le panel. Ces événements sont le changement de couleur d’une courbe, d’épaisseur du trait, etc.

Nous allons gérer les événements : - Couleur des tracés, - Epaisseur des tracés, - Fonte du label de l’axe des x et titre du tracé du nuage de points et de la

droite de régression, - Etc.

Si on a relié une valeur entière au terminal Timeout, il est indispensable de gérer cet événement quand il aura lieu.

V.1.2. Modification de la couleur du nuage des points

La variable trait définit les deux traits, celui du nuage de points et de la droite de régression.

Partie I. Apprentissage de LabVIEW

232

Dans le nœud MathScript, on redéfinie la variable trait comme globale et on utilise la

commande set pour modifier la couleur du nuage de points. La couleur est spécifiée par une constante boite de couleur (palette Dialogue et

interface utilisateur) qu’on transforme en une valeur de la sous-palette RGB.

V.1.3. Modification du type de marqueur sur le nuage de points

Le type de marqueur est défini par une chaîne déroulante dans le panel.

Nous avons, ici, 3 choix : cercle, étoile et le signe plus. On utilise la chaîne déroulante pour spécifier le type du marqueur. Les éléments de cette

chaîne sont édités par l’option Editer les éléments… par un clic droit puis le bouton Insérer. Après avoir défini comme globale la variable trait, nous utilisons la commande set pour spécifier à la propriété Marker la valeur marker choisie dans la chaîne déroulante dans le panel.

Chapitre 6 - Les boucles et structures 233

V.1.4. Gestion de l’appui sur le bouton stop

Lorsqu’il y a changement de valeur du bouton (0 ou 1), le bouton de dialogue à 2 boutons affiche 2 messages qui permettent, soit de valider l’arrêt du VI soit sa continuation

Si l’utilisateur valide l’arrêt de ce VI, la valeur de la sortie de cette boite vaut 1. Nous

utilisons cette sortie pour la relier au terminal de condition d’arrêt de la boucle While. Dans ce cas particulier, nous effaçons le tracé du nuage de points et de la droite de

régression. Pour cela, le signal passe par une structure condition qui ferme tous les tracés par la commande close all dans un nœud MathScript.

Si on désire ne pas arrêter l’exécution du VI, il ne se passe rien, la valeur du signal de

sortie de la boite de dialogue, égale à 0 n’a aucun effet sur le terminal de condition d’arrêt de la boucle.

Partie I. Apprentissage de LabVIEW

234

Sur le panel, nous avons créé les chaînes « Arrêter ce VI ? », « Oui, arrêter » et « Non, continuer ».

Pour les rendre invisibles, nous avons utilisé des nœuds de propriété pour appliquer une valeur fausse à leur propriété Visible.

V.1.5. Gestion de l’épaisseur du trait

On redéfinit comme globale la variable trait. La commande set permet de modifier la valeur de la propriété LineWidth qui correspond à l’épaisseur du trait.

En utilisant la variable trait qui correspond aux 2 courbes, la commande set modifie l’épaisseur des 2 traits.

L’épaisseur est définie par un menu déroulant, Ring de la palette Menu déroulant et énum.

V.1.6. Gestion de la couleur du texte de l’affichage des paramètres a et b

On redéfinit les variables txt1 et txt2 comme globales et on spécifie leur propriété Color à la valeur couleur dans la palette RGB.

Chapitre 6 - Les boucles et structures 235

V.1.7. Police des caractères de l’axe des abscisses et du titre du graphique

On récupère le texte des abscisses et du titre, grâce à la commande get et on spécifie la valeur de l’entrée police à la propriété FontName.

La commande gca (get current axis) retourne un pointeur sur les axes

courants. Les pointeurs sont les variables abscisses et trait.

V.1.8. Modification de la couleur de la droite de régression

La modification de la couleur de la droite de régression constitue un événement qu’on gère dans la séquence « Couleur du trait ».

Comme précédemment, on affecte la valeur de l’entrée color à la propriété Color à

la 2ème composante de la variable trait qui correspond à la droite de régression.

Après avoir déclaré la variable trait comme globale, nous utilisons la commande set

pour affecter à la propriété Color la valeur Color de la palette RGB. On spécifie la nouvelle couleur du trait par une constante boite de couleur qu’on retrouve

dans la palette Dialogue et interface utilisateur.

Partie I. Apprentissage de LabVIEW

236

La constante couleur est transformée en valeur RGB. Le panel suivant montre les objets (menu déroulant, constante couleur, etc.) avec lesquels

on gère les événements.

La courbe suivante correspond à une épaisseur du trait de 18 ainsi que les couleurs, bleue

et verte, respectivement pour le nuage de points et la droite de régression. La police des caractères du texte, de l’axe des abscisses et le titre, est choisie du type

Arial. Le marqueur de la courbe du nuage de points est le signe ‘+’. La figure suivante représente le nuage de points avec des marqueurs sous forme de « + »

avec la couleur bleue et la droite de régression en vert. L’épaisseur du trait est de 18 et les paramètres a et b sont affichés en rouge.

Chapitre 6 - Les boucles et structures 237

Après un clic droit sur le bord de la structure, on peut réorganiser les conditions. En choisissant l’option « Réorganiser les conditions… ».

Pour cela, on sélectionne une condition et on la déplace à l’aide de la souris. Avec « Rechercher la commande », on aboutit à la commande relative à la condition.

V.2. Evénements liés au déplacement de la souris, dialogue utilisateur

On peut utiliser les actions du mouvement de la souris pour servir d’événements. Dans l’exemple suivant, on trace différents signaux selon qu’on sort ou qu’on rentre la

souris dans la fenêtre du panel du VI.

Partie I. Apprentissage de LabVIEW

238

Le type de signal à tracer dans un graphe change selon qu’on sort ou qu’on rentre la souris dans la fenêtre du panel du VI.

Lorsque la souris sort de la fenêtre, on trace la fonction 0.8 sin wt, avec la pulsation

w=2 rad/s, lorsqu’elle rentre dans la face-avant, le signal précédent élevé au carré, s’affiche dans le graphe. Lorsqu’on a spécifié l’événement « Entrée de la souris », on peut le retrouver par l’option « Editer les événements gérés par cette condition » du menu local.

V.2.1. Sortie de la souris dans la fenêtre du panel du VI

Nous affichons la fonction 0.8 sin(wt) de fréquence f=1Hz, en utilisant le VI Formula Waveform. Lorsque la souris sort de la face-avant, le tracé s’arrête et reprend lorsqu’elle rentre de nouveau.

V.2.2. Entrée de la souris dans la fenêtre du panel du VI

Lorsque la souris rentre dans la fenêtre de la face-avant, le signal est redressé et possède une amplitude plus faible.

Nous choisissons l’entrée de la souris comme événement à gérer.

Chapitre 6 - Les boucles et structures 239

V.2.3. Appui sur le bouton Stop

Si on appuie sur le bouton Stop, la boite de dialogue suivant s’affiche. On utilise le VI « Boite de dialogue à deux boutons » qui sort les valeurs

logiques 1 et 0, si on appuie, respectivement sur les boutons Oui et Non. Cette sortie logique est appliquée au terminal d’arrêt de la boucle While pour pouvoir

arrêter la boucle dans le cas où on appuie sur le bouton Oui, arrêter l’application.

Si on appuie sur le bouton Oui, arrêter l’application, le VI s’arrête.

On définit des nœuds de propriété afin de rendre invisibles les chaînes de caractères

Arrêter ?, Oui et Non que nous avons définies dans la face-avant. Lorsqu’on clique sur leur terminal dans le diagramme, elles apparaissent puis disparaissent

après appui de la souris sur le panel.

Partie I. Apprentissage de LabVIEW

240

V.2.4. Fermeture de la face-avant

Si veut fermer la fenêtre de la face-avant en appuyant sur la croix, à droite de la barre de titre, la même fenêtre de dialogue apparaît, la même après avoir appuyé sur le bouton Stop.

Nous créons des nœuds de propriété pour rendre invisibles les chaînes de caractère

Arrêter, Oui et Non, sur le panel. Dans le panel, on remarque le bouton Stop avec lequel on peut arrêter l’exécution du VI ainsi que les deux différentes formes du signal affiché.

Lorsque la souris rentre sur le cadre de la face-avant, on affiche le sinus, puis son carré lorsqu’en ressort. La même fenêtre de dialogue s’affiche également lorsqu’on arrête le programme par fermeture de la face-avant.

Chapitre 6 - Les boucles et structures 241

VI. Structure Elément en place

La structure Elément en place se trouve dans la palette Structures.

On utilise la structure Elément en place lorsqu’on modifie un élément d’un tableau, un cluster ou une waveform, sans que le compilateur LabVIEW garde les valeurs en mémoire. Les éléments sur lesquels on agit sont conservés dans le même espace mémoire.

Il y a ainsi une optimisation de l'utilisation de la mémoire et une augmentation des performances des VIs.

En cliquant avec le bouton droit de la souris sur la bordure de la structure, on sélectionne le nœud de bordure qui correspond à l’opération que l’on veut effectuer.

Partie I. Apprentissage de LabVIEW

242

VI.1. Opération sur les tableaux et waveforms

Nous réalisons les 4 opérations suivantes : 1- Ajouter un nœud Indexer/Remplacer les éléments d’un

tableau. Nous indexons l’élément de la 2ème ligne et 2ème colonne dont nous calculons la racine

carrée. Les autres éléments restent inchangés. 2- Ajouter un nœud Indexer/Remplacer les éléments d’un

tableau pour lequel on indexe le 2ème élément (index 1) du tableau de chaînes de caractères qu’on transforme en majuscules.

3- Ajouter un nœud Diviser/Remplacer des sous-tableaux. Ce nœud permet diviser un tableau en sous-tableaux le long de la dimension que l’on spécifie. On sort l’inverse des éléments du 1er tableau et le carré des éléments du second.

4- Ajouter un nœud Désassembler/Assembler les éléments d’une waveform. On applique une waveform en appliquant une formule temporelle avec une fréquence de 5 Hz.

Dans la structure, on ressort la valeur absolue du signal temporel de la waveform, les autres éléments restent inchangés.

Dans le diagramme suivant, nous allons voir l’intérêt de la structure élément en place. Nous allons étudier plusieurs exemples d’opérations qu’on peut réaliser en utilisant une

structure Elément en place et déduirons l’intérêt de cette structure sur le temps de calcul nécessaire à leur exécution.

Dans le diagramme suivant, nous disposons de Tableau 1 à 2 lignes et 2 colonnes. Nous insérons, à l’entrée de la structure, une indexation pour récupérer uniquement l’élément (0,1) du tableau dont nous prendrons la racine carrée, les autres éléments n’étant pas modifiés.

En sortie de Ajouter un nœud Indexer/Remplacer les éléments d’un tableau permet de remplacer l’élément (1,1) du tableau initial par sa racine carrée. Nous ressortons les indices de l’élément remplacé à savoir i=1 et j=1.

Egalement, nous récupérons l’élément (1,1) du tableau de chaînes Chaîne 1, à savoir la chaîne de caractères « aléatoire » pour la transformer en majuscules.

Après le remplacement, nous obtenons la chaîne Chaine 2 dont seul l’élément (1,1) est totalement en majuscule. Pour le tableau Tableau 3, nous inversons les éléments d’un sous-tableau et nous prenons le carré d’une autre partie de ce tableau.

Nous inversons les deux premières lignes du tableau Tableau 3 en spécifiant la valeur 2 à l’entrée Longueur divisée du nœud Indexer. Le reste est élevé au carré.

Nous vérifions, dans Tableau 4 que seule la dernière ligne est élevée au carré et que les valeurs des deux premières lignes sont les inverses de celles de Tableau 3.

Nous appliquons, ensuite, une waveform sinusoïdale d’amplitude 5, grâce au VI Formula Waveform.vi dont le signal peut-être spécifiée par une formule mathématique.

On récupère les éléments, le signal et ses attributs, par le nœud Désassembler/Assembler les éléments d’une waveform. Nous prenons la valeur absolue du signal temporel et on garde les mêmes attributs.

La valeur absolue est reliée au terminal Y du nœud Assembler de sortie tandis que celui des attributs est appliqué au terminal équivalent du nœud Désassembler de la waveform

Chapitre 6 - Les boucles et structures 243

d’origine. Nous avons du désassembler la waveform de sortie pour tracer son signal Y dans un graphe.

Pour placer un nœud d’indexation sur le bord intérieur gauche de la structure, on se place

sur ce bord et avec un clic droit de la souris, on choisit l’option Ajouter un nœud Indexer dans le menu local.

On fait de même sur le bord intérieur droit en ajoutant autre nœud d’indexation en le spécifiant dans son menu local.

Partie I. Apprentissage de LabVIEW

244

Dans la portion suivante de cette structure, on isole l’élément (2,2) de tableau Tableau 1 d’entrée pour effectuer sa racine carrée.

En isolant uniquement cet élément, LabVIEW optimise l'utilisation de la mémoire et augmente les performances des VIs.

Ainsi le compilateur LabVIEW n’a pas besoin de copier en mémoire les autres valeurs du tableau.

La racine carrée est appliquée uniquement à l’élément de valeur 3, soit l’élément (0,1)

qu’on spécifié par l’indexation. Tous les composants du tableau ne sont pas modifiés à part cet élément.

Dans la portion suivante, on fait de même pour un tableau de chaînes de caractères dont on

transforme en majuscule uniquement l’élément (1,1) à savoir la chaîne « aléatoire ».

On obtient le tableau de chaînes suivant. On remarque que seule la casse de chaîne « aléatoire » a changé en passant totalement

en minuscule à totalement en majuscule.

Dans le cas du 2ème exemple, on choisit les 2 premières lignes du tableau 2D, Tableau

3, dont on effectue l’opération inverse. Les éléments des lignes restantes, ici la 3ème ligne, les éléments sont élevés au carré.

Chapitre 6 - Les boucles et structures 245

Dans l’exemple suivant, nous générons le signal )2sin(*)(sin5 twt sous la forme d’une waveform. En choisissant l’option Ajouter un nœud Désassembler, on récupère les éléments de la waveform.

On récupère le signal contenu dans la waveform, à savoir le signal généré par le VI

Formula Waveform.vi, et on lui applique l’opération valeur absolue. Par le choix Ajouter un nœud Assembler par le clic droit sur le bord intérieur

droit, on construit une autre waveform dont le signal Y est le produit de la valeur absolue mais de mêmes attributs que la waveform d’origine. A la sortie de la structure, on récupère le signal de la nouvelle waveform qu’on affiche dans un graphe.

Dans le panel suivant, nous affichons les résultats des opérations effectuées dans la

structure Elément en place. Nous affichons également les indices des éléments concernés par les opérations effectuées

dans la structure. Dans le panel, nous avons mis en valeur, les 2 sous-tableaux auxquels on applique respectivement l’opération 1/x et x2.

Partie I. Apprentissage de LabVIEW

246

VI.2. Intérêt de la structure Elément en place

Nous allons étudier l’effet de l’utilisation de la structure Elément en place. Nous utilisons la structure Séquence déroulée avec 3 séquences.

Dans la première et la troisième étape de la structure séquence déroulée, nous utilisons le VI Compteur d’impulsions d’horloge (ms) dans la palette Informations temporelles, la différence des deux résultats nous renseigne sur la durée du calcul effectué dans la seconde séquence.

VI.2.1. Temps de calcul avec structure Elément en place

Dans le diagramme suivant, nous réalisons des opérations sur des éléments d’un tableau :

- racine carrée de l’élément (1,1) de Tableau 1, - transformation en majuscule de l’élément (1,1) du tableau de chaînes de caractères Chaine 1,

- inversion des 2 premières lignes et l’élévation au carré des éléments de la 3ème ligne de Tableau 3, - récupération de la valeur absolue du signal d’une waveform.

Nous utilisons une structure séquence déroulée à 3 étapes. Dans la 1ère étape, nous initialisons l’horloge à l’aide de la fonction tic. Dans la 3ème étape, nous mesurons le temps à l’aide de la même fonction, on retranche le

temps initial pour déduire la durée d’exécution de l’ensemble des VIs de l’étape 2.

Le temps d’exécution de l’ensemble des VIs de l’étape 2 est égal à 7 ms.

Chapitre 6 - Les boucles et structures 247

VI.2.2. Temps de calcul sans structure Elément en place

Nous faisons, ici, les mêmes opérations sans utiliser la structure Elément en place. Pour Tableau 1 de numériques et pour Chaine 1, nous utilisons la même méthode.

Nous indexons les éléments à remplacer et nous utilisons la fonction Remplacer une

portion d’un tableau en lui spécifiant les indices de la portion du tableau à remplacer.

Nous affichons l’élément à remplacer : la chaîne « aléatoire » du tableau de chaînes de

caractères. Pour Tableau 3, nous utilisons la fonction Sous-ensembles d’un tableau en

affichant l’indice et la longueur de la portion à retirer. Pour prendre la valeur absolue du signal contenu de la waveform sinusoïdale, on utilise la

fonction Obtenir les composantes d’une waveform pour avoir accès au signal Y.

Nous construisons une autre waveform en remplaçant, dans la première, le signal Y en utilisant la fonction Construire une waveform.

Ainsi, on garde les attributs initiaux de la waveform sinusoïdale. On affiche la nouvelle

waveform et on trace le signal Y dans un graphe. Le gain en temps de calcul avec l’utilisation de la structure élément en place est

d’autant plus appréciable que les dimensions des tableaux sont plus importantes.

Partie I. Apprentissage de LabVIEW

248

Nous obtenons 12 ms pour le temps de calcul. Nous affichons également le tableau

Tableau 1, l’élément dont nous prenons la racine carrée ainsi que le tableau résultat. Nous remarquons que, dans Chaine 2, seule la chaîne « aléatoire », que nous affichons dans le panel, a été totalement transformée en majuscules. Nous affichons aussi, séparément, les portions du tableau Tableau 3, qui ont été, respectivement inversée et élevée au carré.

Chapitre 6 - Les boucles et structures 249

VII. Structure Séquence déroulée

Contrairement à la structure séquence empilée où l’on ne voit qu’un seul diagramme à la fois, dans cette structure, tous les diagrammes sont visibles et sont exécutés de gauche à droite.

Le diagramme de gauche peut fournir, lorsqu’il a fini de s’exécuter, des valeurs au diagramme de droite.

Nous utilisons cette séquence pour être sûr qu’une étape finit de s’exécuter avant une autre. Dans le menu local (clic droit), nous pouvons ajouter une étape après ou avant.

Lorsqu’on coche l’option Redimensionnement automatique, l’étape adapte sa largeur ou sa hauteur au fur et à mesure qu’on ajoute des VIs. Comme il y a un ordre dans l’exécution des VIs de la structure (de gauche à droite), on a aussi le moyen d’ajouter une étape avant. Par un clic droit sur le bord de la structure, nous pouvons aussi dupliquer l’étape en cours. L’expression du régulateur es donnée par :

1

1

11

1

11)()(

zzKKK

zK

KzzU iipi

p

A partir de cette relation, nous en déduisons une relation de récurrence qui va lier, à chaque

instant d’échantillonnage k, l’échantillon u(k) du signal de commande à celui de l’instant k-1 ainsi que les échantillons précédents, ),...2(),1( kk du signal d’erreur entre consigne et le signal de sortie du processus.

)1()()()1()( kKkKKkuku pip

De même, le processus discrétisé du 1er ordre, de fonction de transfert :

11

121

1

1()(

zazbbzzH permet d’aboutir à l’équation de récurrence suivante :

)2()1()1()( 211 kubkubkyaky , )(ky étant le signal de sortie du processus.

Partie I. Apprentissage de LabVIEW

250

VII.1. Structure à 2 étapes

Dans le diagramme suivant, nous utilisons une structure séquence déroulée à 2 étapes. Le processus défini par les coefficients 1a , ,1b et ,2b ainsi que le régulateur défini par les

paramètres pK et iK , sont assemblés dans les clusters Process et PI. Dans la première étape, nous calculons, dans une boite de calcul, la sortie du processus en

fonction de la sortie précédente, la commande actuelle et celle de l’instant précédent. Nous créons 3 registres à décalage pour le signal d’erreur, le signal de sortie et la

commande. Les cellules de ces registres sont, toutes, initialisées à 0. Dans la deuxième étape nous générons le signal de commande du régulateur PI. En sortie

de cette étape, nous calculons le signal d’erreur que nous traçons dans le même graphe XY que le signal de commande. Nous traçons également, dans le même graphe XY, le signal de consigne et de sortie du processus.

Le signal de consigne est généré par une jauge de type Argent.

Sa valeur peut être spécifiée en bougeant l’aiguille mais aussi en spécifiant une valeur numérique plus précise dans l’afficheur numérique.

Le signal de sortie est affiché dans un bouton rotatif.

Le modèle discret du processus est :

1

11

11

121

11

8.01)5.01(

1)()(

zzz

zazbbzzH

Le régulateur a pour expression suivante :

1

1

1

1

1

11

11.05.0

1)()()(

zz

zzKKK

zzUzD iip

Chapitre 6 - Les boucles et structures 251

La fonction de transfert du système en boucle fermée est alors donnée par :

3.21

111

11

111

05.045.03.11)5.01()1.05.0(

)()(1)()()(

zzzzzz

zHzDzHzDzFTBF

Lorsqu’on pose z=1, soit z=ejwt|w=0 , on obtient le gain statique, soit FTBF(1)=1. Le signal de sortie suit parfaitement la consigne, en régime statique, grâce à la présence de

l’intégrateur dans l’expression du régulateur. On obtient les résultats suivants pour Kp=0.4 et Ki=0.1.

Pour changer la disposition des clusters, on choisit l’option Redimensionnement

auto. Dans le menu local (clic droit sur le cluster). On décide de présenter les clusters, Process et PI, horizontalement.

Partie I. Apprentissage de LabVIEW

252

VII.2. Structure séquence déroulée à 3 étapes

Dans cet exemple, nous utilisons 3 étapes de la structure séquence déroulée. Dans la 3ème étape, nous affichons, dans des graphes déroulants, les signaux de l’erreur, la commande, la consigne et la sortie du processus. De cette étape, nous transmettons l’erreur à la 2ème étape pour calculer le signal de commande. Il y a apparition du retard, par le nœud de rétroaction, à cause de l’avance, dans le temps, de cette étape sur la précédente.

Avec Kp = 0.02 et Ki = 0.01, Le système en boucle fermée se comporte comme un système

de second ordre d’amortissement optimal et de gain statique unité.

Pour Kp = 1 et Ki = 0.08, le signal de sortie du système accuse, pratiquement, 1

dépassement avant de se confondre parfaitement avec le signal de consigne grâce à l’action intégrale présente dans l’expression du régulateur.

Chapitre 6 - Les boucles et structures 253

Dans l’exemple que nous avons utilisé plus loin (résolution de l’équation du 2nd degré), nous avons utilisé cette séquence pour nous assurer que le calcul des solutions se fait bien après le calcul du discriminant.

VIII. Structure Séquence empilée

Contrairement à la structure Séquence déroulée, dans la structure empilée, on ne peut voir qu’un seul diagramme à la fois.

Les diagrammes sont exécutés dans l’ordre à partir du diagramme portant l’étiquette « 0 ».

Pour ajouter un diagramme ou une étape, nous choisissons l’option « Ajouter une étape après ».

Nous pouvons aussi en ajouter avant, supprimer une étape ou la dupliquer. Pour faire passer des variables d’une étape à une autre, nous devons ajouter une variable locale de séquence. Comme exemple, nous allons étudier un système de régulation PID en utilisant le module « Conception de contrôle et simulation ».

Nous allons utiliser, dans ce cas, le module Conception de contrôle et simulation pour étudier la réponse indicielle et réaliser une régulation PID.

La structure possède 3 séquences empilées. La séquence 0 permet de tracer la réponse indicielle du processus à réguler.

Partie I. Apprentissage de LabVIEW

254

Le signal de consigne et la sortie sont tracés dans la même étape alors que l’erreur et la commande sont transférées, à l’aide des variables locales de séquence, de la séquence 1 à la séquence 2 dans laquelle elles sont tracées.

La variable locale de séquence est créée après un clic droit sur le bord de la structure avec

le choix de l’option « Ajouter une variable locale de séquence ».

Sur le panel, nous observons la réponse indicielle du processus en boucle ouverte. Nous

retrouvons, le gain statique de 0.45 et la constante de temps de 1.5s. L’erreur de poursuite est nulle en régime permanent et la commande stable à la valeur de

2.22.

Chapitre 6 - Les boucles et structures 255

IX. Le nœud MathScript

Le nœud MathScript permet une programmation textuelle, à l’instar des fichiers « .m » de MATLAB dans l’interface graphique de LabVIEW.

Ces fichiers peuvent aussi s’exécuter dans la fenêtre LabVIEW MathScript.

IX.1. Récupération d’une sinusoïde par filtrage passe-bande

La transformée de Fourier d'un signal discret x(k) est calculée par la commande fft (algorithme TFR) avec la syntaxe :

fft(x) : transformée de Fourier du vecteur x, fft(x,N) : transformée de Fourier du vecteur x sur N points.

Si la longueur du vecteur x est plus petite que N, des zéros sont ajoutés. Dans le cas contraire, le signal x est tronqué.

On peut calculer directement la transformée de Fourier de plusieurs signaux dont les

vecteurs formeront les colonnes de la matrice x. Comme exemple, on s'intéressera à la synthèse d'un filtre passe-bande pour récupérer un

signal sinusoïdal à partir d'une somme de 3 sinusoïdes. On utilisera, pour ceci, des commandes disponibles dans le langage MathScript.

Partie I. Apprentissage de LabVIEW

256

On s'intéressera plus particulièrement à la synthèse d'un filtre passe-bande de type Butterworth, réalisée grâce à la commande butter de syntaxe :

[B,A] = butter(n,[f1 f2]/fe/2)

B, A : numérateur et dénominateur de la fonction de transfert en z du filtre, f1, f2 : fréquences limitant la bande passante du filtre, fe : fréquence d’échantillonnage, n : fixe l'ordre 2 du filtre.

Les fréquences f1 et f2 sont des fréquences normalisées à la moitié de la fréquence

d'échantillonnage. Dans le VI suivant, nous utilisons un filtre numérique pour extraire une sinusoïde dans un

signal formé par la somme de 3 autres sinusoïdes. Le diagramme est formé de 3 nœuds MathScript : le 1er pour générer et tracer le signal somme.

Dans le nœud du bas, nous calculons et traçons le module de la FFT du signal somme.

Dans le 3ème nœud MathScript, nous calculons, par la commande butter, le numérateur

B et le dénominateur A du filtre de Butterworth, du 2nd ordre et de type passe-bande. La bande passante s’étend de 20 Hz à 30 Hz afin de récupérer la sinusoïde de 25 Hz.

Les nœuds MathScript se transmettent les paramètres : fe (fréquence d’échantillonnage) xtot, le signal somme) et x2 ainsi que la sinusoïde d’origine à extraire.

Dans le panel, nous affichons le signal somme des 3 sinusoïdes ainsi que sa FFT dans laquelle nous retrouvons les pics aux fréquences 10 Hz, 25 Hz et 40 Hz.

Dans le spectre obtenu, nous vérifions aussi la périodicité fréquentielle de période 2fe ,

fe étant la fréquence d'échantillonnage. Dans le graphe de la FFT du signal somme, nous retrouvons bien les 3 sinusoïdes de 10 Hz, 25 Hz et 40 Hz, puis la périodicité du spectre du

Chapitre 6 - Les boucles et structures 257

fait de l’échantillonnage. Après une durée assez courte du régime transitoire, la sortie du filtre suit parfaitement la sinusoïde de 25 Hz.

Nous affichons aussi le numérateur et le dénominateur du filtre de Butterworth, soit la fonction de transfert suivante:

42

42

1

1

4128.0143.1106746.01349.006746.0

)()(

zzzz

zAzB

Le tracé de la fonction de transfert du filtre passe-bande est la suivante :

Dans le diagramme nous calculons aussi la FFT du signal de sortie du filtre.

Partie I. Apprentissage de LabVIEW

258

La figure suivante est la FFT du signal somme, dans lequel nous retrouvons des pics aux fréquences des 3 sinusoïdes.

La courbe suivante est la FFT du signal de sortie du filtre, c’est celle d’une sinusoïde de 25 Hz. Les quelques autres pics sont dus à la largeur du filtre qui couvre un peu les fréquences de 10 Hz et 40 Hz.

Si on choisit la largeur [22 Hz 26Hz] pour le filtre passe-bande, nous aurions une coupure

plus franche.

Chapitre 6 - Les boucles et structures 259

IX.2. Interpolation exponentielle

Nous disposons des 2 séries de mesures suivantes : x = [0.10 0.20 0.50 1.0 1.50 1.90 2.00 3.00 4.00 6.00] y = [0.95 0.89 0.79 0.70 0.63 0.58 0.56 0.45 0.36 0.28] Si nous traçons y en fonction de x, nous obtenons une forme de type exponentiel, bxeay . Nous utilisons un Graph XY de type Express.

Nous retrouvons bien une courbe de type exponentiel, bxeay .

Le but est de trouver les paramètres a et b. Nous allons utiliser 2 méthodes : la méthode de Newton et celle des moindres carrés en résolvant un système linéaire surdéterminé.

Nous faisons la transformation suivante:

z = log(y) = log(a ebx)

Nous obtenons ainsi le système linéaire : xyxbz )(log

Partie I. Apprentissage de LabVIEW

260

Nous cherchons alors les paramètres et du modèle linéaire par la méthode des moindres carrés.

IX.2.1. Méthode de Newton

La méthode de Newton donne les expressions suivantes des paramètres a et b :

Dans le VI suivant, nous calculons les paramètres a, b et traçons la courbe des mesures

et celle donnée par le modèle exponentiel. Dans le nœud MathScript, nous utilisons les opérations élément par élément grâce à la

propriété de vectorisation du langage MathScript. Les opérations élément par élément entre tableaux se fait en procédant d’un « . » tout

opérateur de calcul numérique tel *, / et ^..

On le remarque dans ce diagramme dans les opérations ‘. /,’ et ‘.*’ pour respectivement,

diviser, multiplier chaque élément du premier tableau par l’élément équivalent du second tableau.

Chapitre 6 - Les boucles et structures 261

L’opération ‘.^2’ permet d’élever au carré chaque élément d’un tableau. Ainsi les expressions des paramètres a, b ne comportent que des opérations élément par

élément, faciles à mettre en œuvre par l’utilisation du langage du nœud MathScript.

Dans ce panel, nous avons tracé les mesures y et les sorties du modèle, en fonction des

données x. Les 2 courbes tracées sur le panel correspondent aux valeurs des mesures et celles données

par le résultat de l’interpolation exponentielle. Nous avons couplé 2 tracés dans un graphe XY.

IX.2.2. Utilisation des VIs d’interpolation de LabVIEW

Le langage LabVIEW possède des VIs d’interpolation, linéaire, polynomiale ou exponentielle. Il serait intéressant de comparer les variances du résidu dans l’exemple précédent et le cas que nous abordons ici. Nous allons utiliser les VIs qui effectuent, respectivement, les interpolations, linéaire, polynomiale et exponentielle qu’on va comparer au cas précédent.

La structure condition possède 3 séquences : Séquence 0 (séquence par défaut)

Interpolation exponentielle

Séquence 1

Interpolation polynômiale

Séquence 2

Interpolation linéaire

Partie I. Apprentissage de LabVIEW

262

Un nœud de propriété a été lié à l’afficheur des coefficients du polynôme afin de le rendre visible uniquement lorsqu’on aura choisi l’interpolation polynômiale. Le choix de la méthode d’interpolation est fait à travers un menu déroulant sur le panel.

La méthode d’interpolation étant celle des moindres carrés, le résidu est l'erreur

quadratique moyenne ou variance de l’erreur. Cette variance de 4 10-4 est la moitié de celle de l’interpolation polynômiale et 10 fois plus faible que celle de l’interpolation linéaire.

Dans le panel, nous affichons les tableaux de mesures x, y, affichons les courbes des mesures et celle de l’interpolation. Un message d’erreur est affiché pour indiquer le type d’erreur éventuelle.

IX.2.3. Utilisation de la méthode des moindres carrés

Le modèle que nous cherchons, de type exponentiel, lie chaque valeur yk à la valeur xk, par la relation :

yk = a ebxk

Chapitre 6 - Les boucles et structures 263

Nous passons à une relation linéaire, en utilisant le logarithme, soit l’expression suivante :

kk xbay )log()log( Que l’on peut mettre sous la forme :

kxz ,

Cette égalité peut s’écrire sous la forme matricielle suivante :

1......1

.

.

.log

11

nn x

x

y

y

,

soit XZ ,

avec X la matrice de mesures et le vecteur paramètres à estimer. La matrice X étant rectangulaire, elle n’est pas inversible. L’algorithme des moindres carrés aboutit à la solution suivante par le jeu des opérations

matricielles suivantes qu’on applique aux deux termes de cette égalité:

- Multiplication à gauche par la transposée de X, soit :

XXZX TT

- En multipliant à gauche par l’inverse de XTX, on obtient l’estimation du vecteur paramètres :

ZXXX TT 1)(ˆ

Nous allons utiliser le nœud MathScript pour implémenter cet algorithme. Les paramètres a et b du modèle peuvent alors être obtenus comme suit :

)exp(ab

Dans le diagramme suivant, nous définissons les tableaux x et y des données. Nous

construisons la matrice X et prenons le logarithme népérien du vecteur y. Nous calculons le vecteur estimé, en utilisant les propriétés de transposition, inversion et

produit matriciel du langage du nœud MathScript. Nous récupérons les paramètres a et b en indexant le vecteur estimé des paramètres et en sortie du nœud MathScript.

Partie I. Apprentissage de LabVIEW

264

Nous calculons l’erreur entre les données y et celles données par le modèle, bxaym . Grâce au VI Std Deviation and Variance.vi nous calculons la moyenne et la

variance de l’erreur de modélisation. Les mesures réelles et celles obtenues par le modèle sont tracées dans un graphe XY.

Dans le panel, nous affichons la matrice X et le vecteur Z obtenu à travers le logarithme du vecteur de mesures y.

La moyenne de 0.0027 et la variance de 0.0013 montrent que la modélisation exponentielle est très bonne.

Nous affichons les 4 premières valeurs de l’erreur de modélisation.

Chapitre 6 - Les boucles et structures 265

IX.3. Distributions, triangulaire et gaussienne, par la méthode de Box-Muller

Soit u1 et u2, 2 nombres aléatoires compris entre 0 et 1, de distribution uniforme. On génère un nombre x, aléatoire de distribution triangulaire par l’expression suivante :

2)( 21 uuabax ,

avec a et b les bornes du triangle. Avec 1u et 2u , 2 variables aléatoires de distribution uniforme dans l’intervalle [0 1], la loi

de Gauss de moyenne et d’écart-type est donnée par l’expression suivante, par la méthode de Box-Muller :

*)2cos(*)ln(2 21 uux Dans l’exemple du diagramme suivant, nous avons choisi de générer une loi triangulaire

symétrique avec a=0 et b=1. La moyenne et l’écart type de la loi de Gauss sont choisis égaux à 0 et 1.

Les expressions des lois, triangulaire et gaussienne, sont définies dans des nœuds

MathScript. L’histogramme est généré par le VI General Histogram.vi de la palette

Mathématiques Probabilités et statistiques. Le panel suivant représente ces 2 distributions, triangulaire et gaussienne.

Partie I. Apprentissage de LabVIEW

266

IX.4. Equation du 2nd degré

Nous allons étudier le calcul des solutions d’une équation du 2nd degré dans les cas où le déterminant est positif (racines réelles) et négatif (racines complexes conjuguées).

Le déterminant est calculé dans une boite de calcul, laquelle est insérée dans l’étape 0 de la structure Séquence déroulée. Cette séquence transmet les paramètres a et b ainsi que le déterminant à l’autre séquence. Le test du signe du déterminant se fait dans une structure Séquence condition, que nous avons insérée dans la séquence 1 de la structure Séquence déroulée. Nous avons décidé de calculer les solutions complexes dans un nœud MathScript. Lorsque le déterminant est positif, le calcul des solutions x1 et x2 se fait dans la séquence « Vrai », d’une Structure Condition.

abx

abx

2

2

2

1

Avec cab 42

Lorsque le déterminant est négatif, nous utilisons la séquence « Faux » pour calculer les

parties réelles et imaginaires des solutions complexes x1 et x2. Dans le nœud MathScript, nous calculons les parties, réelle et imaginaire, de la solution

x1.

abx

2)Re( 1 ,

ax

2)Im( 1

Chapitre 6 - Les boucles et structures 267

Les 2 solutions, étant complexes conjuguées, nous avons :

)Im()Im(),Re()Re( 1212 xxxx

A partir des parties, réelle et imaginaire, nous obtenons les solutions x1 et x2, complexes en coordonnées cartésiennes, en utilisant la fonction Re/Im en complexe.

Dans le cas du discriminant strictement négatif, nous calculons les parties, réelle et imaginaire, en considérant la valeur absolue du discriminant.

Nous les transformons en notation complexe en dehors du nœud MathScript. Le déterminant est calculé, auparant, dans une boite de calcul. Pour pouvoir afficher les

solutions sous leurs formes complexes, nous devons faire un clic droit sur les indicateurs x1 et x2 et choisir la représentation CDB (Complexe double précision) avec l’option Représentation du menu local.

Partie I. Apprentissage de LabVIEW

268

Lorsque les solutions sont réelles, elles sont affichées dans leur forme complexe avec la partie imaginaire nulle.

C’est le cas suivant où le determinant est nul, avec 2 solutions égales et réelles :

Avec un déterminant négatif, 7 , dans notre cas, les 2 solutions sont complexes

conjuguées.

IX.5. Régulation proportionnelle et intégrale, PI

Dans cet exemple, nous allons utiliser les différentes structures étudiées précédemment, pour réaliser une régulation proportionnelle et intégrale.

Le programme que l’on réalisera va consister en plusieurs séquences de la structure

Séquence déroulée; le tout sera inséré dans une boucle While avec un registre à décalage pour stocker la commande et la sortie de l’instant précédent.

Chapitre 6 - Les boucles et structures 269

IX.5.1. Sous-VI du processus

Le modèle est du 1er ordre numérique de fonction de transfert suivante :

11

11

1)(

zazbzH .

Ce modèle est programmé dans le sous-VI Processus-1er-ordre.vi. Les paramètres de ce processus sont définis dans le panel sous forme du cluster Process

parameters. Dans le diagramme, ces paramètres sont obtenus par désassemblage de ce cluster.

Le processus est défini par l’équation de récurrence liant la sortie y(k) à l’entrée u(k) par :

)1()1()( 11 kubkyaky

u1, y1 et y2 sont respectivement u(k-1), y(k-1) et y(k). Les valeurs précédentes de la

commande et de la sortie seront obtenues grâce à des registres à décalage.

Partie I. Apprentissage de LabVIEW

270

IX.5.2. Sous-VI du régulateur PID

Ce régulateur comporte une partie proportionnelle de gain Kp et une autre de type intégrale de paramètre Ki. Le rôle de la partie de l’action proportionnelle est de réaliser une commande, Kp (t), d’autant plus grande que l’erreur l’est aussi.

Dans cette commande, la partie intégrale consiste à intégrer l’erreur, soit : k

ikpip IKikKiKkKku

1)()()()(

Ik représente la valeur de l’intégrale ou somme des erreurs jusqu’à l’instant courant k. Ainsi, cette intégrale peut être définie par : kkk II 1 .

Le régulateur PI peut être alors défini par :

kkk

kkikp

IIKKku

1

1)()(

Ce régulateur est défini dans le sous-VI « Regulateur-PI.vi ».

La valeur de l’intégrale de l’instant discret précédent, 1kI , est obtenue grâce à un troisième

registre à décalage. Les paramètres Kp et Ki du régulateur sont définis, dans le panel, par le cluster Kp, Ki du PID.

Chapitre 6 - Les boucles et structures 271

IX.5.3. Programme principal de la régulation PID

Dans le diagramme suivant nous réalisons une régulation PID. L’erreur, différence entre la consigne et la sortie du processus et la commande issue du

régulateur sont assemblées pour être affichées dans le cluster Commande & Erreur. La sortie et la consigne sont aussi affichées dans le cluster Consigne & sortie. La

période d’échantillonnage est choisie égale à 1000 ms en utilisant le VI Attendre un multiple de ms.

Le panel est constitué de 2 onglets. Dans l’onglet Courbes, on affiche la consigne et la sortie du processus ainsi que le signal d’erreur et la commande issue du régulateur.

Le régulateur et le processus sont définis les sous-VIs créés précédemment.

Le signal de sortie rejoint la consigne après seulement 1 dépassement. L’erreur statique est nulle grâce à la présence de l’intégration dans l’expression du régulateur.

Partie I. Apprentissage de LabVIEW

272

IX.5.4. Régulation PI dans une boucle de contrôle et simulation

Dans cette boucle, nous avons réalisé un régulateur PI discret sous sa forme parallèle :

1)(

zTKKzD ip

Le régulateur est suivi d’un bloqueur d’ordre 0 pour attaquer le processus continu du 1er ordre :

15.11)(p

pH

Nous avons utilisé des VIs de l’outil Conception de contrôle et simulation. Le signal de consigne carré est généré par le bloc Pulse Signal de la sous-palette Signal Generation. Le régulateur PI est réalisé par la somme d’une action proportionnelle et d’une intégrale par l’intégrateur discret Discrete Integrator de la sous-palette Discrete Linear Systems. Le processus est le modèle analogique du 1er ordre de gain statique unité et de constante de temps 1.5s. Comme le processus est analogique pour une régulation numérique, nous avons installé un bloqueur d’ordre Discrete Zero-Order Hold de la sous-palette Discrete Linear Systems. Nous affichons le signal de sortie et la consigne dans un même graphe déroulant et le signal de commande dans un graphe XY. Le bloc Collector permet d’associer le signal et le temps de simulation.

Dans ce panel, nous affichons la consigne dans un réservoir et les paramètres Kp et Ki du

régulateur sous forme de glissières verticales.

Partie I. Chapitre 7 - Les sous-VIs et sous-systèmes de simulation

I. Sous-VI d’un contrôleur proportionnel et intégral I.1. VI du régulateur PI I.2. Edition de l’icône du sous-VI I.3. Disposition des connecteurs des entrées-sorties du sous-VI II. Sous-VI du processus du 1er ordre discret III. Régulation d’un système du 1er ordre III.1. Réponse indicielle du système à réguler III.2. Résultats de la régulation IV. Sous-VI de limitation d’un signal V. Sous-VI du modèle de moteur à courant continu VI. Sous-systèmes de simulation VI.1. Création d’un sous-système de simulation VI.2. Sous-système de simulation d’un pendule amorti VI.3. Sous-système de simulation d’un modèle de moteur DC

273DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _7,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie I / Apprentissage de LabVIEW 274

I. Sous-VI d’un contrôleur proportionnel et intégral

I.1. VI du régulateur PI

Un sous-VI est une sorte de sous-programme qu’on peut utiliser dans un VI ou programme de plus haut niveau.

Les sous-VIs permettent la programmation avec beaucoup de modularité. Le régulateur consiste à calculer, à chaque instant d’échantillonnage kT, la commande

u(kT) à appliquer au processus que l’on veut réguler en fonction des entrées/sorties des instants antérieures.

Dans le cas de ce régulateur proportionnel et intégral PI, l’expression donnant la commande

u(kT) est : )1()()()1()( kKkKKkuku pip

avec )(k l’erreur de poursuite, soit la différence consigne moins la sortie du processus. On

utilise le VI Formula comme suit :

Nous allons réaliser le régulateur PI par le VI Formule de la sous-palette Arithmétique de la palette Express.

Avant de créer le sous-VI, nous devons définir ses entrées sorties en branchant les contrôles

et les indicateurs correspondants.

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 275

Nous insérons les commandes et les indicateurs dans le diagramme du sous-VI, comme dans le cas de notre régulateur PI suivant :

I.2. Edition de l’icône du sous-VI

Pour créer l’icône du sous-VI, on fait un clic droit sur l’icône en haut à droite de la fenêtre de la face-avant et on choisit l’option Editer l’icône ou tout simplement par un double clic.

Nous obtenons la fenêtre suivante à 4 onglets : 1- Modèles : Ce sont les modèles d'icônes que nous pouvons utiliser en arrière-plan de l'icône. Ce sont des images png, bmp et jpg stockées dans le répertoire LabVIEW Data\Icon Templates. Par défaut, l’image de l’icône est celle qu’on trouve en haut à droite de la fenêtre des VIs LabVIEW :

Partie I / Apprentissage de LabVIEW 276

Grâce au menu Edit, nous pouvons effacer cette image et choisir un modèle parmi la liste dans le répertoire Icon Templates.

2- Texte de l’icône : Nous pouvons éditer 4 lignes de texte dont nous pouvons choisir la couleur, la police de caractères, la justification et la taille. A droite, nous pouvons remarquer des outils de dessin et en bas le choix des couleurs des faces, avant et arrière. Nous avons dessiné la réponse d’un système en boucle fermée par un PI. L’expression REG est obtenue par l’édition du texte de la ligne 3. L’expression PID est réalisée par l’outil texte .

3- Symboles : Dans cet onglet, nous trouvons les symboles classés par thème qu’on peut inclure dans l’icône. Ces symboles sont sous forme d’images PNG (Portable Network Graphics).

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 277

On les trouve dans le répertoire LabVIEW Data\ Glyphs. Avec EDIT Importer une image d’un fichier, nous pouvons utiliser une image spécifique en dehors des symboles prédéfinis. 4- Calques :

Dans la figure suivante, nous pouvons faire varier la transparence des 4 calques qui forment le modèle. Nous avons augmenté la transparence du modèle d’un filtre passe-bande et l’expression REG éditée précédemment.

I.3. Disposition des connecteurs des entrées-sorties du sous-VI

Dans notre cas du régulateur PI, nous devons connecter 5 fils d’entrée au sous-VI, 3 pour amener les signaux suivants :

- erreur à l’instant courant kT, )(k - erreur à l’instant précédent (k-1)T, )1(k - commande appliquée à l’instant précédent, )1(ku - Et 2 autres connecteurs d’entrée pour les paramètres du régulateur : ip KK , . En sortie,

nous devons connecter un seul fil pour sortir le signal de commande ).(ku

Chaque connecteur peut être défini comme nécessaire, recommandé ou optionnel. Nous décidons de placer ces connecteurs selon la disposition suivante :

Partie I / Apprentissage de LabVIEW 278

Pour obtenir cette configuration, nous pouvons ajouter, enlever un connecteur (Add Terminal, Remove Terminal) ou choisir une des configurations suivantes ou ces deux opérations.

Nous choisissons le modèle qui correspond à la disposition précédente. Dans le cas où on ne trouve de modèle parmi cette liste qui corresponde parfaitement à la disposition souhaitée nous pouvons ajouter, supprimer un terminal et certaines opérations comme la rotation, le basculement, etc.

Nous pouvons également déconnecter un terminal ou tous les terminaux à la fois.

Une fois obtenu la bonne configuration, il faut bien positionner les connecteurs. Pour cela, avec le pointeur de la souris sous forme de bobine de fil, on vient

successivement sélectionner le connecteur et le terminal (un contrôle ou indicateur) du panel. Si l’on se trompe, nous pouvons déconnecter le terminal par l’option Déconnecter ce

Terminal et tous les connecteurs à la fois par Déconnecter tous les terminaux. Pour connecter un terminal à une entrée ou sortie du sous-VI, on clique sur ce terminal puis ensuite sur l’entrée ou sortie considérée, à l’aide de la souris sous forme de bobine. Nous montrons dans cet exemple, la connexion de l’entrée (k) à son terminal.

Dans le chapitre « Prise en main » et le paragraphe de régulation, nous avons utilisé

ce PID avec une autre disposition.

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 279

Une fois ce sous-VI enregistré, pour l’utiliser dans un VI de plus haut niveau, on utilise l’option Sélectionner un VI … Après sélection du sous-VI dans son répertoire, nous obtenons le sous-VI dont nous faisons

apparaître les différents terminaux.

II. Sous-VI du processus du 1er ordre discret

Partant de sa fonction de transfert discrète :

11

11

1

1

1)(

zazb

azbzH

Nous obtenons l’équation de récurrence liant l’entrée u(k) à la sortie y(k).

)1()1()( 11 kybkyaky

C’est cette équation récurrente que l’on programmera pour réaliser le sous-VI. Ce sous-VI aura 2 entrées, la commande u(k-1), la sortie précédentes y(k-1), et 1 sortie y(k)

du système à réguler. Pour insérer un sous-VI dans un VI de plus haut niveau, nous devons sélectionner la

fonction « Sélectionner un VI… ». Lorsqu’un sous-VI manque, à sa place il apparaît un point d’interrogation. On peut le

remplacer, par un clic droit, par un autre sous-VI comme suit. Remplacer Toutes les palettes Sélectionner un VI

Ainsi, le sous-VI correspondant s’insère automatiquement dans le programme principal.

Partie I / Apprentissage de LabVIEW 280

On s’intéresse à la création du sous-VI qui modélise un système du 1er ordre. Sa sortie y(k) est définie par l’équation récurrente suivante en fonction de la commande ou entrée u(k).

)1()1()( 11 kubkyaky

On utilise l’opérateur retard 1z effectué par le nœud de rétroaction de la palette

Structures pour retourner les valeurs précédentes u(k-1) et y(k-1). Cet opérateur retard est équivalent à l’utilisation d’un registre à décalage dans une boucle

For ou While.

Pour réaliser le sous-VI, une autre méthode consiste à sélectionner l’ensemble du diagramme à la souris ou par Ctrl A.

Ensuite, dans le menu Edit, on sélectionne l’option Créer un sous-VI. Dans le menu local, nous pouvons changer la direction de ce nœud de rétroaction ainsi que

sa forme.

L’ensemble des VIs qu’on transforme en sous-VI est alors le suivant :

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 281

L’autre manière de créer ce sous-VI consiste à sélectionner l’ensemble de ces VIs et

utiliser l’option Créer un sous-VI du menu Edit.

Le sous-VI créé possède la forme classique suivante avec ses connecteurs. La position des connecteurs ne respecte pas le fait que ce sous-VI doit avoir une entrée u(k)

à gauche, une sortie y(k) à droite et les paramètres a1 et b1 au centre. Pour cela, on doit déconnecter tous ces connecteurs avant de changer la disposition

(Déconnecter tous les terminaux).

Partie I / Apprentissage de LabVIEW 282

On vérifie le bon fonctionnement de ce sous-VI en traçant la réponse indicielle d’un

système du 1er ordre.

III. Régulation d’un système du 1er ordre

III.1. Réponse indicielle du système à réguler

Nous générons un signal carré à l’aide du VI Express Simulate Signal, de la sous-palette Traitement du signal Génération de waveforms, signal qu’on applique au sous-VI qui représente le processus du 1er ordre.

Pour afficher le signal de consigne dans un même graphe que le signal de sortie du

processus, nous devons les assembler dans un tableau par la fonction Construire un tableau.

En sortie de la boucle For, nous obtenons une matrice à 2 colonnes (signaux) et 100 lignes.

On obtient la réponse suivante d’un système du 1er ordre, régime transitoire en ).1(T

e

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 283

III.2. Résultats de la régulation

Nous avons utilisé 2 sous-VIs que nous avons réalisés précédemment; celui du régulateur PI et du système du 1er ordre.

Le signal de consigne est obtenu par un bouton rotatif dont les limites sont, respectivement 0 et 10. Ce signal est enregistré dans une variable locale nommée step(x) comme le nom de l’indicateur de la consigne.

Cette même variable locale, en lecture, est utilisée pour tracer la consigne en même temps

que le signal de sortie du processus en utilisant le VI Assembler de la palette Cluster. Il en est de même pour le tracer du signal d’erreur et de commande issu du régulateur PI.

Les paramètres a1 et b1 du processus ainsi que les paramètres Kp et Ki du régulateur PI sont fixés dans des commandes sur la face-avant.

Partie I / Apprentissage de LabVIEW 284

La face-avant comporte les 2 graphes déroulants, les paramètres du régulateur et du système ainsi que le bouton rotatif de la consigne.

L’effet du nœud de rétroaction a pour de retarder le signal de sortie d’une période d’échantillonnage.

IV. Sous-VI de limitation d’un signal

On s’intéresse à créer un sous-VI qui permet de limiter un signal entre une valeur minimale min et une valeur maximale Max.

Nous avons utilisé un nœud MathScript avec les entrées Val_max (valeur maximale),

Val_min (valeur minimale) et x, le signal à limiter. La sortie y est le signal limité. Pour limiter le signal, nous avons utilisé l’expression conditionnelle suivante :

y=Max*gt(x,Max)+min*lt(x,min)+x*((x>=min)&&(x<Max))

Lorsque le signal est plus grand que la valeur maximale, Max, la commande gt (greater than : plus grand que) donne la valeur logique 1, ainsi le signal vaut Max.

Partout ailleurs, l’expression vaut zéro logique.

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 285

Lorsque le signal est plus petit que la valeur min, la commande lt (less than : plus petit que) donne 1 logique et le reste de l’expression vaut zéro logique.

Lorsque le signal est compris entre les valeurs min et Max, l’expression ((x>=min)&&(x<Max))vaut 1 logique et le reste vaut zéro, ainsi le signal x garde sa valeur.

Nous réalisons un sous-VI comme suit :

Nous allons utiliser ce sous-VI pour limiter entre -0.8 et 0.5, un signal sinusoïdal

d’amplitude 1. Le signal limité et la sinusoïde sont tracés dans le même graphe déroulant en utilisant le

bloc Assembler de la palette Cluster, class et variant.

Partie I / Apprentissage de LabVIEW 286

Le sous-VI est inséré dans ce diagramme grâce à la fonction « Sélectionner un VI… ».

Nous sélectionnons le VI dans le répertoire de travail :

Dans le diagramme suivant, nous utilisons un signal sinusoïdal que l’on va limiter entre une

valeur minimale Val_min et maximale Val_max. Ces valeurs sont spécifiées, dans le panel, par un vu-mètre pour la valeur minimale entre -1

et 0 et un bouton rotatif, entre 0 et 1, pour la valeur maximale. Le signal sinusoïdal de fréquence 30 Hz, sous forme de waveform, est généré par le VI

Sine waveform.vi.

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 287

Le panel montre que les 2 signaux sont confondus lorsque la sinusoïde est comprise entre les valeurs limites -0.8 et 0.5.

Nous vérifions que le signal de sortie du sous-VI est bien limité entre -0.8 et 0.5.

V. Sous-VI du modèle de moteur à courant continu

On considère un moteur à courant continu schématisé par sa partie électrique de l’induit et mécanique du rotor.

Partie I / Apprentissage de LabVIEW 288

Les parties, électrique et mécanique, sont régies par les équations suivantes :

wfdtdwJ

edtdiLiRu

La force électromotrice e et le couple sont, respectivement proportionnels à la vitesse de

rotation w et au courant d’induit i avec le même coefficient K .

iKwKe

Les variables d’état sont le courant d’induit et la vitesse de rotation et les équations d’état

sont les suivantes. La commande est la tension u appliquée à l’induit.

uL

w

i

Jf

JK

LK

LR

dtdw

dtdi

0

1

En intégrant la vitesse, nous obtenons la position qui sera la 3ème sortie avec la vitesse de

rotation w et le courant d’induit i. Nous considérons les valeurs numériques suivantes :

R= 1 Ohm, L=0.120 H K=0.0050 N.m/A f= 0.02 N.m/(rad/s), J=0.001 kg.m2

Nous allons utiliser un modèle d’état pour calculer la vitesse de rotation et le courant d’induit en fonction de la tension appliquée à l’induit.

Dans le nœud MathScript, nous spécifions les matrices A et B ci-dessus. Comme il y a 2

sorties et 2 variables d’état, la matrice C d’observation doit être une matrice identité. Cette matrice est déterminée par la commande eye du langage MathScript.

C = eye(2)= 1001

La matrice D, tableau 1D (2 lignes et 1 colonne) de zéros est donnée par la commande

zeros :

D = zeros(2,1) = 00

Le modèle d’état analogique est créé par la commande ss.

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 289

Ce modèle d’état analogique est discrétisé à la période d’échantillonnage Sampling

Time grâce au VI CD Convert Continuous to Discrete.vi. Les matrices A, B, C et D de l’état discret sont transmises au bloc Discrete State-

Space sous la forme d’un cluster qu’on applique à l’entrée supplémentaire State-Space. Pour cela, il fallait double cliquer sur ce bloc et spécifier la valeur Terminal pour Parameter source.

Nous avons affiché les équations du modèle d’état discret grâce au VI CD Draw State-

Space Equation.vi. Le modèle d’état étant dynamique, nous avons du le placer dans une boucle For. Comme le système est de type MIMO, nous avons utilisé la fonction Construire un

tableau pour représenter la valeur scalaire du signal de commande sous la forme d’un tableau.

Le courant d’induit et la vitesse angulaire sont obtenus par indexation du tableau de la sortie.

L’angle Theta est calculé comme l’intégrale discrète de la vitesse angulaire w, soit :

)(1

1)( 1 zwz

zTheta

ou : )()1()( kwkThetakTheta

Nous utilisons un registre à décalage dans la boucle For afin de calculer l’angle à partir de

la vitesse angulaire selon cette équation de récurrence. En exécutant ce diagramme, nous avons le panel suivant sans les valeurs de Theta, ni du

courant d’induit, ni de la vitesse car il n’y a pas de tension appliquée à l’induit. Par contre, on peut afficher l’équation du modèle d’état discret.

Partie I / Apprentissage de LabVIEW 290

Dans le diagramme suivant, nous avons utilisé le sous-VI auquel on applique un signal carré représentant la tension d’induit.

Les valeurs de R, L, K, J et f sont définies en tant que commandes dans le panel. Nous avons appliqué un signal carré à l’induit du moteur.

Dans le panel suivant, nous affichons les courbes de la tension appliquée à l’induit, celles du courant, la vitesse de rotation de l’arbre moteur ainsi que la position angulaire.

La position est linéaire pour une tension constante et constante pour une tension nulle.

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 291

VI. Sous-systèmes de simulation

VI.1. Création d’un sous-système de simulation

Les sous-systèmes de simulation sont les équivalents des sous-VIs pour les systèmes de la palette Conception de contrôle et simulation.

Après avoir sélectionné l’ensemble des VIs du sous-système à masquer, nous choisissons l’option Créer un sous-système de simulation du menu Edition après avoir sélectionné l’ensemble des VIs qui feront partie du sous-système.

VI.2. Sous-système de simulation d’un pendule amorti

On considère une masse m suspendue par un fil rigide, inextensible, de masse négligeable, de longueur l et de masse m. Le fil forme un angle par rapport à la verticale.

La conservation de l’énergie mécanique (somme de l’énergie cinétique et de l’énergie potentielle), donne :

cstemgllmEpEc )cos1(21 22

Partie I / Apprentissage de LabVIEW 292

La dérivée de cette équation, constante, par rapport au temps, est nulle, soit :

sinlg

C’est l’équation d’un oscillateur non harmonique à cause de l’élément non linéaire sin . Si la masse est soumise à un frottement visqueux de coefficient f, l’équation devient :

2sinlmf

lg

On se propose de programmer cette équation différentielle non linéaire. On utilise l’opérateur de l’intégration de la sous-palette Conception de contrôle et simulation Simulation Continuous Linear Systems pour obtenir l’angle , sa vitesse et son accélération .

La condition initiale 0 est spécifiée à l’aide d’une structure condition. A l’instant t=0, cet angle vaut 4/3 en ajoutant cette valeur à l’angle .

En dehors de cet instant, cet angle n’est pas modifié. Nous avons utilisé un nœud d’expression dans lequel on multiplie l’entrée 1 par la valeur 4/3 .

Le temps de simulation est fourni par le bloc Simulation Time de la sous-palette Utilities.

On sélectionne l’ensemble de ces blocs puis on choisit l’option Créer un sous-système de simulation du menu Edition. Nous obtenons le sous-système suivant :

Pour afficher les VIs qu’il inclut, nous choisissons Open Subsystem dans le menu local (clic droit). Le type de l’icône est Dynamic. Nous pouvons choisir un autre style avec Icon Style. Si nous choisissons le style Express, nous obtenons, en tirant vers le bas le bord de l’icône :

Nous utilisons ce sous-système dans une boucle de simulation pour laquelle on choisit les

paramètres suivants : - Final Time : 10s, - Step Size : 0.1s, - Solver : Runge-Kutta d’ordre 4.

Les paramètres du pendule (m, l et f) sont spécifiés dans le panel. L’angle est affiché

dans un Waveform Chart de la sous-palette Graph Utilities. La boucle peut être arrêtée lorsqu’on appuie sur le bouton Halt ?.

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 293

Cet appui provoque un 1 logique qui provoque l’arrêt de la boucle grâce au bloc Halt Simulation.

Sur le panel, nous observons des oscillations dont l’amplitude diminue selon une enveloppe exponentielle.

Pour f=0, nous obtenons des oscillations harmoniques.

La période de ces oscillations est donnée par :

Partie I / Apprentissage de LabVIEW 294

sglT 4185.12

En choisissant bien l’échelle du temps, nous trouvons, approximativement 7 périodes entre

les instants 70 et 80s, ce qui fait une période de 7

10T 1.4286s.

VI.3. Sous-système de simulation d’un modèle de moteur DC

Nous allons créer un sous-système de simulation d’un moteur à courant continu pour lequel nous avons réalisé, précédemment, un sous-VI.

Pour des besoins de comparaison, nous allons calculer le modèle d’état discret qui permet d’obtenir les valeurs du courant d’induit et de la vitesse angulaire.

Dans le diagramme suivant, nous avons créé le modèle d’état analogique du moteur en utilisant les variables symboliques des paramètres électromagnétiques R, L, f, J et K du moteur. Ceci est réalisé par le VI CD Construct State-Space Model.vi en choisissant Symbolic dans le menu polymorphe de ce VI.

Après avoir échantillonné ce modèle d’état analogique à la période Sampling Time, nous transmettons le cluster qui définit ce modèle d’état discret au bloc Discrete State-Space par son entrée State-Space.

Cette entrée supplémentaire est créée lorsqu’on définit la valeur Terminal à Parameter source après un double clic.

Dans le panel suivant, les matrices d’état sont définies par les variables symboliques des

paramètres du moteur.

Chapitre 7 / Les sous-VIs et sous-systèmes de simulation 295

A l’entrée Variables du VI, nous avons appliqué un cluster comportant chaque variable et sa valeur numérique.

Nous obtenons la même équation du modèle d’état discret que celle que nous avons obtenue lorsque nous avons défini le modèle du moteur par un sous-VI.

Dans ce panel, nous n’avons pas de valeurs numériques du signal de sortie car nous avons exécuté le sous-système de simulation sans appliquer de tension d’induit.

Dans le diagramme suivant, nous avons utilisé le sous-système de simulation sous forme d’une icône de type Express.

Partie I / Apprentissage de LabVIEW 296

Nous obtenons les mêmes résultats dans le panel suivant que ceux du sous-VI précédent.

Partie I. Chapitre 8 - Régressions et interpolations

I. Régression linéaire I.1. Calcul scalaire des paramètres a et b I.2. Calcul matriciel II. Interpolation exponentielle et logarithmique II.1. Interpolation exponentielle II.2. Interpolation logarithmique III. Interpolation polynomiale d’une fonction sigmoïde III.1. Interpolation par la commande III.2. Interpolation par la fonction Ajustement polynomial général IV. Interpolation gaussienne V. Interpolation par Splines V.1. Utilisation du VI Cubic Splin Fit V.2. Utilisation de la commande interp1 du nœud MathScript

297DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _8,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

298 Partie I / Apprentissage de LabVIEW

I. Régression linéaire

Le tableau suivant présente, approximativement, la distance de freinage sur route sèche d’un véhicule correctement entretenu, à partir d’une vitesse de 60 km/h.

Vitesse (v en km/h) 60 90 100 110 130

Distance (d en m) 25 50 62 75 110

On se propose d’interpoler linéairement la relation de la distance de freinage en fonction de la vitesse par la fonction :

bvad .

I.1. Calcul scalaire des paramètres a et b

On cherche à ajuster les paramètres a et b de telle sorte que la somme des carrés des écarts d’ordonnées soit minimum.

n

kkk dbvaba

1

22 )(),(

Cet écart est minimum si :

0),(),( 22

bba

aba

Ceci nous donne :

2

11

2

1 11

n

kk

n

kk

n

k

n

kkk

n

kkk

vvn

dvdvna

2

11

2

1 11 1

2

n

kk

n

kk

n

k

n

kkkk

n

k

n

kkk

vvn

dvvvdb

Nous réalisons cette interpolation linéaire de 2 façons, en programmant ces expressions

dans le nœud MATLAB Script et en utilisant le VI Linear Fit d’interpolation linéaire. Le nœud de script se trouve dans la sous-palette Mathématiques Scripts et

formules Nœuds de script Script MATLAB.

Ce nœud appelle le logiciel MATLAB pour exécuter le script, MATLAB doit être installé au préalable pour pouvoir exécuter ce script.

Ce script est écrit selon la syntaxe de MATLAB. Dans ce script, on utilise la fonctionnalité des opérations point par point sur les vecteurs.

Chapitre 8 / Régressions et interpolations 299

Ces nœuds de script MATLAB ne sont disponibles que sous Windows car LabVIEW utilise la technologie ActiveX pour implémenter ces nœuds de script.

Dans ce diagramme, nous récupérons les paramètres a et b de la droite de régression que

nous envoyons dans le cluster Paramètres. Les valeurs de la distance mesurée et celle de la droite de régression sont assemblées dans

des clusters qui sont convertis en tableau. A ce tableau, on ajoute le cluster Distance-Vitesse obtenu par le VI Linear Fit.vi.

Le tableau de clusters, obtenu est envoyé au graphe XY dans lequel, nous traçons les données de mesures, les résultats du script MATLAB et du VI Linear Fit.

300 Partie I / Apprentissage de LabVIEW

Dans le panel, nous représentons les points de mesures ainsi que les résultats des 2 types d’interpolation.

Nous obtenons parfaitement les mêmes résultats pour les paramètres a et b, les 2 droites sont confondues.

I.2. Calcul matriciel

Si nous disposons de n mesures de la distance en fonction de la vitesse, nous avons, pour la mesure n° i, la relation suivante :

iii bvad

i est l’erreur de la mesure. Si nous considérons toutes les n mesures, nous avons la relation matricielle suivante :

Xdba

v

vv

d

dd

nn

n

.

.

.

11.1.1.11

.

.

.2

1

2

12

1

+

Chapitre 8 / Régressions et interpolations 301

X est la matrice de mesures, D le vecteur de mesures, le vecteur paramètres et le vecteur d’erreurs de mesures.

On suppose que l’erreur de mesure est un bruit blanc, i.e. que son autocorrélation est une

impulsion de Dirac. Nous considérons les 10 mesures suivantes :

Vitesse (v en km/h) Distance (d en m)

30 8

40 30

50 50

60 70

70 90

80 110

90 130

100 150

110 170

120 190

Les valeurs estimées par le modèle sont données par :

ˆˆ Xd L’erreur d’estimation est estimée par :

dd ˆ L’expression à minimiser est :

XXdXdd

XdXd

Xdbvad

TTTTT

T

i

n

ii

ˆˆ2

)ˆ()ˆ(

ˆ)ˆˆ(1

En dérivant par rapport à ˆ , on obtient :

dXXX TT 1)(ˆ

Nous utilisons la fenêtre MathScript pour programmer un script MATLAB dans lequel on spécifie cette expression.

302 Partie I / Apprentissage de LabVIEW

Nous obtenons le même résultat que dans le cas scalaire.

II. Interpolation exponentielle et logarithmique

II.1. Interpolation exponentielle

On s’intéresse à la caractéristique d’une diode.

La caractéristique, ID=f(UD), donnant le courant direct ID en fonction de la tension UD est

donnée par l’expression suivante :

T

D

T

D

UU

S

UU

SD

eI

eII 1

IS : courant de fuite de quelques dizaines de A (selon la diode, sa puissance, sa

technologie, etc.),

Chapitre 8 / Régressions et interpolations 303

qTkUT : tension thermodynamique, égale à mV26 à la température ambiante de 25°C

ou 298 K. Avec :

k : constante de Boltzman = 1.38 e-23 J/K, q : charge de l’électron = 1.6 e-19 C, T : température en degrés Kelvin.

A l’aide de mesures par le montage électrique suivant, on obtient des mesures du courant I=ID et de la tension U=UD.

On obtient le tableau suivant :

U(V) I(A)

0.600 0.0050 0.650 0.0080 0.700 0.0200 0.725 0.0300 0.750 0.0500 0.760 0.0600 0.770 0.0800 0.800 0.1600 0.820 0.2000 0.830 0.2400

Le VI Exponential Fit.vi permet de faire une interpolation

exponentielle d’une série de mesures x sous la forme :

ceay bx ,

avec a l’amplitude, b l’atténuation et c l’offset. Nous choisissons la méthode des moindres carrés pour obtenir ce modèle exponentiel. On se propose d’estimer les valeurs des paramètres UT et IS.

304 Partie I / Apprentissage de LabVIEW

D’après l’expression théorique de cette caractéristique, nous devons avoir un offset c nul,

SIa et b

UT1 .

Nous utilisons un graphe XY de type Express pour tracer les mesures I=f(U) ainsi que

celles obtenues par interpolation.

Dans le panel suivant, nous affichons les mesures, la sortie du modèle ainsi que les valeurs des paramètres a, b et c. Nous en déduisons la valeur du courant de fuite IS ainsi que UT.

Chapitre 8 / Régressions et interpolations 305

Nous obtenons un courant de fuite de 17 pA et une tension thermodynamique de 27.1 mV. La variance de l’interpolation est égale à 0.012.

II.2. Interpolation logarithmique

Nous utilisons le tableau précédent donnant le courant qui circule dans la diode en fonction de la tension à ses bornes.

On considère le montage électrique suivant d’un amplificateur logarithmique. La caractéristique I(U) d’une diode est donnée par l’expression suivante :

TUU

S eII En divisant par Is et en prenant le logarithme, nous obtenons :

ST I

IUU log

Le VI d’ajustement logarithmique utilise la méthode des moindres carrés et celle de Levenberg-Marquardt pour ajuster des données à une fonction logarithme d’expression suivante :

)(log xbay c

x étant la séquence, c la base du logarithme, a l'amplitude et b l'échelle.

Ce VI permet d’estimer les valeurs de a et b qui font que y soit le plus proche des mesures.

Dans notre cas, les paramètres a et b à estimer nous permettent d’obtenir les valeurs approchées du courant de fuite IS et de la tension thermodynamique UT.

Ces quantités ont déjà été estimées précédemment par l’interpolation exponentielle.

Dans notre cas, nous avons les équivalences suivantes :

bI

aU

S

T

1

Dans le diagramme suivant, nous utilisons le VI Logarithm Fit.vi avec lequel on fait une interpolation de la tension aux bornes de la diode en fonction du courant.

Nous traçons la sortie de ce VI et les mesures du tableau précédent.

L’échelle et l’amplitude nous permettent d’obtenir la tension thermodynamique UT ainsi que le courant de fuite IS.

306 Partie I / Apprentissage de LabVIEW

Nous obtenons quasiment la valeur 0.026 V de la tension thermodynamique UT. De même, la valeur du courant de fuite IS est la même que celle obtenue par l’interpolation exponentielle.

Chapitre 8 / Régressions et interpolations 307

III. Interpolation polynomiale d’une fonction sigmoïde

On se propose d’interpoler la fonction sigmoïde d’expression suivante :

xexf

11)(

par un polynôme d’ordre 3.

III.1. Interpolation par la commande polyfit

On génère une sigmoïde en lui ajoutant un bruit gaussien d’écart-type 05.0 dans la première étape de la séquence déroulée.

Dans la deuxième étape, nous utilisons un nœud MathScript dans lequel on fait appel aux fonctions polyfit et polyval. La commande p=polyfit(x,y,3) permet d’interpoler la mesure y=f(x) par un polynôme d’ordre 3.

Nous obtenons le polynôme suivant :

5013.01911.00005.00039.0 23 xxxp

La fonction polyval permet de calculer la valeur du polynôme que nous traçons sur le même graphe XY que la sigmoïde bruitée. Pour tracer ces courbes en fonction de la variable x, nous devons utiliser la fonction Assembler de la palette Cluster, class et variant.

Dans le panel, nous pouvons choisir Graphe XY ou Graphe XY Express pour tracer ces courbes. Pour tracer l’histogramme de l’erreur d’interpolation, nous utilisons le VI Créer un histogramme de la sous-palette Mathématiques Probabilités et statistiques. Ce VI est de type Express. En double-cliquant sur ce VI, nous avons la possibilité de choisir le nombre d’intervalles (classes) de l’histogramme ainsi que leurs valeurs, minimale et maximale. Dans cette boite de dialogue, nous disposons d’un aperçu des résultats.

308 Partie I / Apprentissage de LabVIEW

Pour avoir un tracé précis, on double-clique sur ce VI pour spécifier le nombre d’intervalles de l’histogramme ainsi que les valeurs, minimale et maximale des abscisses.

Nous obtenons un histogramme qui tend vers une tendance gaussienne. Nous calculons la moyenne et la variance de cette erreur d’interpolation en utilisant le VI

Variance et écart type de la sous-palette. Nous obtenons une moyenne nulle et une variance 00254.02 .

III.2. Interpolation par la fonction Ajustement polynomial général

Chapitre 8 / Régressions et interpolations 309

Le VI General Polynomial.vi possède les entrées et sorties suivantes :

Dans notre exemple, on spécifie l’ordre 3 pour le polynôme d’interpolation. Si l’entrée

Pondération n’est pas spécifiée, tous ses coefficients sont égaux à 1. Nous avons choisi la méthode des moindres carrés avec l’algorithme de la décomposition

LU une forme particulière d'élimination de Gauss Jordan, utilisée pour la résolution des systèmes linéaires.

Ce type d’interpolation consiste à minimiser l’erreur quadratique pondérée de l’erreur entre les mesures yi et les sorties générées par le polynôme, fi.

1

0

2)(1 N

iiii yfw

N, avec iw , les coefficients de pondération optionnels.

Nous trouvons les mêmes valeurs pour les coefficients du polynôme d’interpolation, la moyenne et la variance de l’erreur d’interpolation.

Le résidu correspond à la variance de l’erreur et la sortie erreur à la moyenne de cette dernière.

310 Partie I / Apprentissage de LabVIEW

Dans le panel, nous affichons la sigmoïde bruitée et le tracé des valeurs du polynôme d’interpolation.

Pour chacune des 2 types d’interpolation, comme polyfit du nœud MathScript ou VI polyfit, nous affichons les valeurs de la moyenne et de la variance de l’erreur d’interpolation.

Pour le cas de la commande polyfit, nous affichons l’histogramme de cette erreur qui semble avoir une distribution gaussienne.

Nous remarquons que ces 2 méthodes donnent quasiment les mêmes résultats. En utilisant un nœud MathScript, l’affichage d’un polynôme se fait par ordre des puissances décroissantes contrairement à LabVIEW.

L’interpolation de données provenant d’un polynôme permet d’obtenir les mêmes coefficients de ce dernier.

La moyenne de l’erreur d’interpolation est quasiment nulle et la variance égale à 0.003 dans les 2 cas.

Dans l’exemple suivant, nous utilisons le polynôme du 2nd degré suivant :

1)( 2 xxxp

Nous utilisons pour cela le nœud d’expression pour programmer ce polynôme. Nous cherchons à faire une interpolation avec un polynôme du 3ème degré de type :

012

23

3)( axaxaxaxf

Chapitre 8 / Régressions et interpolations 311

Lorsqu’on n’ajoute pas de bruit aux données, le coefficient a3 est négligeable.

a3 = -2,47088e-16

Les autres coefficients sont les mêmes que celui du polynôme de départ.

IV. Interpolation gaussienne

On se propose d’estimer la gaussienne qui correspond à l’histogramme de l’interpolation polynomiale de la sigmoïde précédente. Nous générons, cette fois-ci la sigmoïde dans le même nœud MathScript dans lequel nous appliquons les commandes utiles à l’interpolation polynomiale. Dans le diagramme suivant, nous utilisons la même sigmoïde bruitée que nous avons interpolée précédemment. Nous utilisons ici, la même interpolation avec un polynôme

312 Partie I / Apprentissage de LabVIEW

de degré 3. Nous récupérons la valeur Y du signal contenu dans la waveform de la sortie Histogramme. Nous utilisons le VI Gaussian Peak Fit.vi pour interpoler ce signal par une gaussienne d’expression :

ceaxhmx

2

2

2)(

)( , avec a l’amplitude, m la moyenne et c l’offset.

Dans ce panel, nous affichons l’histogramme réel ainsi la gaussienne estimée par interpolation. Nous obtenons une moyenne nulle et une variance 2=2.18.

Chapitre 8 / Régressions et interpolations 313

V. Interpolation par Splines

V.1. Utilisation du VI Cubic Splin Fit

L’inconvénient d’une interpolation polynomiale est sa divergence ou l’apparition d’oscillations, notamment lorsque le nombre de points est supérieur à 10. Il est alors préférable d’effectuer une interpolation polynomiale par morceaux, appelée Spline. Le VI Cubic Splin Fit.vi d’interpolation par Spline cubique f(x) permet d’interpoler des mesures (xi,yi) en minimisant la fonction suivante :

dxxfxpxfywpnx

x

n

iiii

221

0

1

0

)('')()1()(

p est dit paramètre d’Equilibrage, wi est le ième élément de Pondération, )(x est

une fonction constante définie par morceaux, dite de Lissage. L’interpolation par Spline cubique correspond à p =1. S’il est égal à 0, il s’agit d’une interpolation linéaire. Ce paramètre doit se trouver dans l’intervalle [0 1].

La fonction Spline passe parfaitement par tous les points mais elle est moins lisse que lorsque le paramètre d’équilibrage p tend vers 0. Nous utilisons aussi le VI Ajustement pour faire une interpolation avec un polynôme d’ordre 3.

Le VI Ajustement de courbe possède les entrées/sorties suivantes :

Signaux/Positions Signal à interpoler/abscisses Meilleur ajustement Résultat de l’interpolation Résiduel Erreur d’interpolation

Erreur quadratique Variance de l’erreur d’interpolation Coefficients polynôme Coefficients du polynôme d’interpolation

314 Partie I / Apprentissage de LabVIEW

Les paramètres du polynôme de degré 3, affichés dans un graphe, sont donnés dans la fenêtre de dialogue, obtenue en double-cliquant sur le VI Ajustement. L’erreur quadratique (variance de l’erreur d’interpolation) est très faible (1e-3).

V.2. Utilisation de la commande interp1 du nœud MathScript

La commande y1=interp1(x,y, x1)permet de réaliser une interpolation de y=f(x) afin d’obtenir la valeur du vecteur y1 correspondant aux abscisses données par le vecteur x1.

L’interpolation par Spline cubique est obtenue par :

y1=interp1(x,y, x1,’cubic’)

Par défaut, sans rien spécifier, l’interpolation est linéaire.

Chapitre 8 / Régressions et interpolations 315

La commande plot permet de tracer les résultats des 2 variantes de la commande interp1.

A l’aide de la commande legend, nous pouvons afficher la légende des différents tracés en spécifiant, dans l’ordre, les chaînes de caractères correspondantes. Nous obtenons le tracé suivant.

Partie I. Chapitre 9 - Le nœud MathScript et la fenêtre MathScript LabVIEW

I. Le nœud MathScript I.1. Définition et exemple I.2. Import et export de scripts I.2.1. Import I.2.2. Export I.3. Fonctions mathématiques intégrées dans le module MathScript I.3.1. Surface 3D I.3.2. Courbe 3D I.3.3. Débogage du code d’un nœud MathScript I.4. Quelques exemples I.4.1. Réponse indicielle d’un système analogique du 2nd ordre I.4.2. Transformée de Fourier I.4.3. Filtre FIR passe-bas

II. La fenêtre MathScript LabVIEW II.1. Description de ce module II.2. Exemple III. Quelques fonctions de MathScript III.1. Fonctions relationnelles III.2. Systèmes discrets III.2.1. Utilisation du nœud MathScript III.2.2. Utilisation de la fenêtre MathScript IV. Calculs matriciels IV.1. Système matriciel déterminé IV.2. Système matriciel surdéterminé, identification d’un processus du 1er ordre V. Réponse indicielle de processus du 1er ordre et 2nd ordre V.1. Système du 1er ordre V.1.1. Système du 1er ordre analogique V.1.2. Système discret du 1er ordre V.2. Réponse indicielle d’un système du 2ème ordre V.2.1. Second ordre analogique V.2.2. Second ordre discret VI. Fonctions graphiques VI.1. Graphiques 2D VI.2. Graphiques 3D VII. Appel de fonctions MathScript

317DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _9,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

318 Partie I / Apprentissage de LabVIEW

I. Le nœud MathScript

I.1. Définition et exemple

Le noeud MathScript est une structure dans laquelle on peut programmer textuellement avec la syntaxe de MATLAB ou utiliser des scripts textuels créés dans un environnement MATLAB ou compatible. Cependant, le moteur du module MathScript RT ne supporte pas toutes les fonctions supportées par le logiciel MATLAB.

Le nœud MathScript s’insère dans un diagramme LabVIEW dans lequel on réalise la programmation graphique, le langage G de LabVIEW.

Le nœud MathScript se trouve dans la sous-palette Structures.

On se propose de générer le signal suivant :

atetfty )2sin()(

Le paramètre a, la fréquence f et le temps t sont des entrées du nœud MathScript et le signal y sa sortie.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 319

Pour spécifier une entrée du nœud, on place le pointeur de la souris sur le bord gauche du nœud et on sélectionne « Ajouter une entrée ».

On fait de même pour définir la sortie y qu’on place sur le bord droite du nœud, en choisissant « Ajouter une sortie ». Le temps t sera défini par l’index i d’une boucle While.

Le nœud MathScript inséré dans la boucle While se présente comme ceci, avant de déclarer ses variables de sortie.

Une fois connues les variables de sortie dans le code à l’intérieur et qu’on désire spécifier les variables de sortie, ces dernières sont connues.

320 Partie I / Apprentissage de LabVIEW

En posant le pointeur de souris et après un clic droit, nous n’avons qu’à choisir ces variables dans une liste.

Une fois qu’on a défini dans le nœud la variable z de la 2ème ligne, et qu’on ajoute cette sortie, cette dernière est déjà connue. Nous n’avons qu’à la choisir dans la liste.

Nous ajoutons une 2ème entrée z représentant l’enveloppe de la décroissance exponentielle afin de l’afficher en même temps que la sinusoïde amortie.

Pour cela, nous utilisons la fonction construire de la sous-palette Tableau.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 321

Les paramètres a et f traversent la boucle While pour servir d’entrées au nœud MathScript.

Le nœud MathScript, avec ses entrées/sorties, possède l’allure suivante. Nous avons aussi inséré le cluster d’erreur en sortie du nœud.

La boucle While est cadencée à la période temporelle de 0.2 s.

Le paramètre a est défini dans le panel par une glissière verticale de type argent tandis que la fréquence f est spécifiée par une jauge de type argent.

Nous avons tracé l’enveloppe décroissante en même temps que la sinusoïde amortie dans le même graphe déroulant. Pour cela, les valeurs instantanées de ces 2 signaux forment un vecteur avant d’être envoyé au graphe déroulant.

Le bouton stop permet d’arrêter l’exécution de la boucle While.

322 Partie I / Apprentissage de LabVIEW

Pour permettre le débogage facile du code, nous pouvons choisir de mettre les variables d’entrées/sorties en couleur. Ceci se fait par un clic droit sur le bord droit du nœud MathScript ou à l’intérieur. Dans ce cas, on met en évidence le type des données.

En effet, les variables de type Double sont en orange et les variables entières en bleu.

Nous pouvions importer ce code d’un fichier .m par le menu précédent. De même, nous pouvons exporter le code contenu dans le nœud MathScript dans un script .m dont on spécifie le nom et l’emplacement dans le disque dur.

Nous pouvons créer et supprimer les points d’arrêt. Les croix signifient des erreurs dans ces lignes de code car nous n’avons pas encore défini les variables utilisées dans le code.

I.2. Import et export de scripts

I.2.1. Import

Par un clic droit sur le bord droit du nœud MathScript, nous choisissons l’option « Importer… », afin d’importer un fichier .m qui permet de résoudre un système linéaire.

I.2.1.1. Nœud MathScript à 1 sortie, sans entrée

L’importation d’un fichier .m de MATLAB® se fait par un clic droit à l’intérieur du nœud MathScript et choisir l’option Importer… pour spécifier le fichier .m à importer.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 323

Nous importons le fichier syst_lin.m qui se troue dans le répertoire courant. Ce fichier permet de résoudre un système linéaire de 3 équations à 3 inconnues de type BxA par la méthode des moindres carrés.

Le fichier syst_lin.m utilise la méthode des moindres carrés pour résoudre un système de 3 équations à 3 inconnues.

Les 3 solutions sont les suivantes.

x = 2.8769 4.0824 -1.7288

324 Partie I / Apprentissage de LabVIEW

En choisissant le fichier syst_lin.m dans le répertoire courant, nous obtenons le diagramme suivant.

La solution, donnée par :

BAAAx TT 1)( .

est une sortie du nœud qu’on affiche dans un indicateur. Pour que la sortie soit bien affichée, nous devons adapter le type de la variable x à celui de l’afficheur. Cette variable x est un vecteur de 3 valeurs réelles. Par un clic droit, nous choisissons un Tableau 1D de type Double.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 325

Ce nœud MathScript ne possède pas d’entrées car la matrice A et le vecteur B sont définis à l’intérieur du nœud.

I.2.1.2. Nœud MathScript à 2 entrées et 1 sortie

Nous créons la matrice A et le vecteur B dans le panel. Ce sont des entrées du nœud MathScript. Dans le diagramme, nous transposons le vecteur B défini dans LabVIEW et nous affichons le cluster d’erreur en sortie du nœud MathScript. Nous désassemblons le cluster d’erreur afin de récupérer l’élément status qui prend la valeur logique 1 lorsqu’il y a erreur. Sa valeur est envoyée dans l’afficheur status.

Nous obtenons une erreur de code 90011 pour une erreur de dimensions des matrices. La LED status s’allume (valeur logique 1) et une croix rouge s’affiche dans l’élément état du cluster d’erreur. Nous avons cherché à connaître les dimensions des tableaux A et B. Rien n’indique qu’il peut y avoir une erreur sans connaître le code de l’erreur.

Nous transposons le tableau dans le nœud MathScript par l’opérateur « ’ ».

326 Partie I / Apprentissage de LabVIEW

Il n’y a pas d’erreur et nous obtenons la solution du système.

I.2.1.3. Indices dans un nœud MathScript et dans LabVIEW

Les indices des tableaux dans LabVIEW commencent par la valeur 0 et 1 dans les tableaux du nœud MathScript ou MATLAB®.

Dans le panel du VI suivant, nous spécifions une matrice A carrée à 2 lignes et 2 colonnes ainsi qu’un vecteur B à 3 éléments.

6903.20803.13972.42229.0

A ,

548.134422.27691.6B

On indexe, dans LabVIEW, la matrice A pour avoir l’élément de la 1ère ligne et de la 1ère colonne qu’on note A00_Lbv. Grâce à la fonction Indexer un tableau, on récupère l’élément (0,0).

Dans le nœud MathScript, on récupère l’élément A(1,1).

De même, le deuxième élément du vecteur B, B2_Nd est B2 dans le nœud MathScript mais B1 dans LabVIEW.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 327

Nous vérifions l’égalité des éléments indexés dans LabVIEW et le nœud MathScript.

I.2.2. Export

Dans ce cas, on choisit l’option « Exporter… », du menu local obtenu par un clic droit à l’intérieur du nœud. On s’intéresse au nœud MathScript suivant dans lequel on trace la surface spécifiée par la fonction peaks de MATLAB®.

La commande view(az, el) permet de spécifier l’azimuth et l’élévation à partir du point de vue. L’exécution de ce nœud donne le résultat suivant :

328 Partie I / Apprentissage de LabVIEW

Lorsqu’on désire l’exporter, on doit nommer le fichier .m qui doit contenir son code et qu’on enregistre dans le répertoire de travail, qui est le bureau dans notre cas particulier.

Le fichier sera nommé surface.m.

La lecture de ce fichier par MATLAB® donne :

I.3. Fonctions mathématiques intégrées dans le module MathScript

Lorsqu’on demande de l’aide sur ce nœud, nous obtenons la liste de toutes les catégories de fonctions que l’on peut utiliser dans ce nœud MathScript.

Nous choisissons Aide dans le menu obtenu par un clic droit sur le bord du nœud.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 329

Nous obtenons un exemple de programme et un certain nombre de liens dont celui de « fonctions MathScript intégrées » qui liste différents domaines de fonctions mathématiques dont les fonctions mathématiques de base, les fonctions avancées, etc.

I.3.1. Surface 3D

I.3.1.1. Tracé 3D en sinus

Le programme suivant, permet de tracer la surface de la fonction, à 2 variables, suivante :

)sin( 22 yxAZ

Ce programme comporte 2 nœuds MathScript, les deuxième ne servant qu’à tracer la courbe à l’aide de la commande mesh de MATLAB®.

330 Partie I / Apprentissage de LabVIEW

Dans le panel, nous spécifions l’amplitude A, seule entrée du nœud MathScript. Les variables x et y sont égales et varient entre et . On sort de la boucle While s’il y a apparition d’une erreur (status=1) ou si l’on appuie sur le bouton stop dans le panel.

Dans le panel, nous affichons la commande Amplitude avec son afficheur numérique ainsi que le cluster d’erreur.

Nous obtenons la surface suivante.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 331

I.3.1.2.Tracé 3D en sinus cardinal

Une autre surface 3D est donnée par l’expression suivante.

22 )()((sin yxcz

Nous devons utiliser la commande meshgrid pour obtenir la matrice Z qui correspond à une surface qui parcourt tous les x et tous les y dans l’intervalle [-10 10] par pas de 0.25. Nous allons tracer cette surface par la commande mesh du nœud MathScript ainsi que par l’utilisation du VI 3D Surface.vi. Cette commande a besoin d’une matrice pour balayer un certain nombre de valeurs de x et y, transformés en vecteurs. Ce VI a besoin des vecteurs x et y ainsi que de la matrice Z obtenue par la commande meshgrid.

La commande mesh donne la courbe de surface 3D suivante :

332 Partie I / Apprentissage de LabVIEW

I.3.2. Courbe 3D

Dans le nœud MathScript suivant, on trace la variable 2t en fonction des variables x et y variant sinusoïdalement en fonction du paramètre temps t par les expressions suivantes :

)cos()sin(ty

tx

Grâce à la commande set on utilise le pointeur h pour spécifier la valeur 4 à la largeur du trait de la courbe tracée. Lorsque l’élément status vaut 1, on arrête l’exécution du VI en appliquant cette valeur à la fonction Stop.

La fonction plot3 permet de tracer une courbe à 3 dimensions. Dans notre cas, nous traçons une hélice à 3 dimensions.

Le panel est vide car on n’affiche aucune valeur et on ne trace aucune courbe dans LabVIEW.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 333

I.3.3. Débogage du code d’un nœud MathScript

On peut déboguer le code d’un nœud MathScript en plaçant une sonde. On obtient la fenêtre suivante qui récapitule les différentes variables dont le temps de calcul.

Nous pouvons aussi placer un point d’arrêt dans une ligne quelconque du code pour localiser une erreur. On utilise le menu local du nœud MathScript dans lequel on choisit l’option « Placer un point d’arrêt » du menu « Point d’arrêt ».

A l’arrivée à la ligne où se trouve le point d’arrêt, le VI s’arrête. Dans ce nœud MathScript, nous traçons la surface 3D suivante par la commande mesh :

22 yxz

On efface les points d’arrêts en choisissant Effacer les points d’arrêt du script dans le menu local obtenu par un clic droit à l’intérieur du script.

334 Partie I / Apprentissage de LabVIEW

I.4. Quelques exemples

I.4.1. Réponse indicielle d’un système analogique du 2nd ordre

On considère un système de fonction de transfert:

220518.0)(

pppF

Le numérateur et le dénominateur sont spécifiés, respectivement, par la constante num et le tableau den, insérés dans le cluster « fonction de transfert ».

Dans le diagramme, nous récupérons le numérateur et le dénominateur à partir du cluster pour servir d’entrées au nœud MathScript. Dans cette structure, nous mettons en œuvre cette fonction de transfert par la commande tf.

Cette fonction de transfert est récupérée dans la sortie sys et représentée par le cluster sys Ce cluster est formé par la valeur de la période d’échantillonnage (nulle dans ce cas analogique), les tableaux Numerator et Denominator ainsi que de la chaîne « System Model ».

Nous obtenons la réponse indicielle grâce à la commande step. Le système est un 2nd

ordre d’amortissement optimal. En effet, la 2ème oscillation est négligeable devant la première.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 335

I.4.2. Transformée de Fourier

Dans le nœud MathScript suivant, nous générons un signal sinusoïdal dont nous traçons la FFT ainsi que le signal temporel.

Dans la fenêtre de Tracé 1, nous obtenons le tracé du signal temporel sinusoïdal et à droite, sa transformée de Fourier. Nous obtenons un seul pic du fait que le signal est sinusoïdal.

336 Partie I / Apprentissage de LabVIEW

Dans le panel, nous spécifions la fréquence d’échantillonnage fe et le nombre de points avec lequel on calcule la transformée de Fourier discrète TFD.

I.4.3. Filtre FIR passe-bas

Dans le diagramme suivant, nous utilisons la commande firls qui génère la réponse impulsionnelle du filtre passe-bas dont on spécifie les bandes, coupée et passante.

Cette commande utilise la méthode des moindres carrés. Elle retourne la réponse

impulsionnelle du filtre. La commande freqz permet d’obtenir et de tracer la réponse en fréquences du filtre, en

utilisant la réponse impulsionnelle h.

Dans le panel suivant, nous avons la réponse impulsionnelle et la réponse en fréquences du

filtre passe-bas.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 337

II. La fenêtre MathScript LabVIEW

Ce module permet d’écrire des scripts et de les tester avant de les insérer dans le nœud MathScript au sein du langage graphique ou langage G. Pour afficher ce module, on utilise le menu Outils/Fenêtre MathScript.

II.1. Description de ce module

Ce module est composé de 4 fenêtres :

Fenêtre de résultat

Cette fenêtre affiche les commandes entrées dans la fenêtre de commande et la réponse à celles-ci.

Fenêtre de commande

Dans cette fenêtre, on peut spécifier des commandes et voir leur résultat dans la fenêtre de résultat. Si une commande tient sur plusieurs lignes, on doit utiliser les touches « Shift-Entrée ». Les flèches vers le haut et vers le bas pour afficher l’historique des commandes pour les exécuter à nouveau. Cette fenêtre ainsi que celle de commande peuvent être redimensionnées.

338 Partie I / Apprentissage de LabVIEW

Fenêtre Variables/Script/Historique

Cette fenêtre contient les 3 onglets : Variables, Script et Historique.

Onglet Variables :

Cet onglet liste les variables utilisées dans la fenêtre de commande ou dans le script.

Cet onglet est composé de 3 colonnes :

Liste de variables

Cette fenêtre classe, par ordre alphabétique les variables globales et locales définies dans le script ou la fenêtre de commande. Lorsqu’on définit les variables comme globales dans le script, à l’aide de la commande global, celles-ci peuvent être passées entre une fenêtre MathScript LabVIEW et un nœud MathScript ou entre deux nœuds MathScript.

Les variables locales ne sont connues que dans le même nœud MathScript ou la même fenêtre MathScript LabVIEW.

Exemple 1 : Définition de variables

Dans l’exemple suivant, nous avons inséré un ensemble de commandes dans la fenêtre de commande. Ces dernières sont affichées dans la fenêtre de résultat mais seul le résultat de la variable x est retourné à la suite. Dans l’onglet Variables nous avons l’affichage, par ordre alphabétique, des variables définies dans les commandes. Lorsqu’on double clique sur la variable x, par exemple, sa valeur est affichée dans l’aperçu avec l’indication x[1, 21] pour signifier que x est un vecteur d’une ligne et 21 colonnes.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 339

Lorsqu’on double clique sur la variable Z et qu’on coche la case « Graphique en premier », nous obtenons la courbe représentant Z au lieu de ses valeurs numériques.

Nous obtenons le graphique suivant :

Passage de variables

Dans l’exemple suivant, nous allons étudier le passage de variables entre 2 nœuds MathScript et entre un nœud MathScript et une fenêtre MathScript LabVIEW.

On utilise un nœud MathScript dans le diagramme suivant dans lequel nous ne faisons que tracer la courbe définie par la variable Z déjà définie dans la fenêtre MathScript LabVIEW.

Dans le tableau suivant, nous représentons l’ensemble de commandes précédé par la définition de la variable globale Z : global Z, ainsi que l’onglet Variables dans lequel nous observons la variable globale Z et les variables locales x, X, y et Y.

340 Partie I / Apprentissage de LabVIEW

Après avoir validé l’ensemble de ces commandes dans la fenêtre de commande, nous allons tracer la variable Z dans un nœud MathScript.

Dans le 1er cas, dans le nœud MathScript suivant, nous ne faisons que tracer la surface correspondant à la variable Z, définie comme globale dans la fenêtre MathScript LabVIEW.

Dans le diagramme suivant, nous utilisons 2 nœuds MathScript avec une autre variable W.

A noter que nous devons, encore une fois, déclarer la même variable comme globale.

Nous obtenons la même courbe que celle que nous eue par la fenêtre MathScript LabVIEW.

Script

Dans l’onglet Script nous éditons un script et la flèche verte permet de l’exécuter. Avec les autres menus nous pouvons sauvegarder le script avec l’extension .m, faire de la recherche, etc.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 341

Historique

Cette fenêtre permet d’afficher l’historique des commandes exécutées dans la fenêtre de commande.

II.2. Exemple

Dans cet exemple, on insère des instructions séparément dans la fenêtre de commande. Nous nous proposons de résoudre un système de 3 équations à 3 inconnues de type : BxA ,

Nous choisissons d’utiliser la solution donnée par BApinvx *)( , avec )(Apinv , la pseudo inverse de la matrice A, soit :

TT AAAApinv 1)()(

Cette méthode donne une solution même si A n’est pas inversible, soit parce que la matrice A n’est pas carrée (système surdéterminé) ou que le déterminant de A est nul même si elle carrée. A chaque fois qu’on appuie sur la touche « Entrée » après une commande, nous obtenons un autre affichage de celle-ci dans la fenêtre de résultat.

342 Partie I / Apprentissage de LabVIEW

Dans l’onglet Variables, nous obtenons l’affichage des variables locales A, B et x avec leurs dimensions et leurs types.

III. Quelques fonctions de MathScript

III.1. Fonctions relationnelles

Les fonctions que l’on peut utiliser dans les expressions relationnelles sont les suivantes :

Exemples simples, opérations élémentaires

Dans le diagramme suivant, nous étudions quelques opérations conditionnelles élémentaires.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 343

Les commandes eq(A,B), ge(A,B), ne(A,B) et lt(A,B) donnent respectivement un 1 logique (Vrai) lorsque A est, respectivement, égal B, plus grand que B, différent de B et plus petit que B. Nous avons les équivalences suivantes :

>> eq(A,B)==(A==B) % A égal à B ans = 1 >> ge(A,B)==(A>B) % A plus petit que B

ans = 1 >> ne(A,B)==(A~=B) % A différent de B

ans = 1 >> lt(A,B)==(A<B) % A plus petit que B

ans = 1

Comme les instructions sont équivalentes, la commande précédente d’équivalence « == » donne toujours1 (vrai). La comparaison d’une matrice et d’un scalaire se fait pour tous les éléments de la matrice au même scalaire.

Dans le panel suivant, nous spécifions deux matrices carrées, A et B ainsi qu’une constante C. La condition vraie correspond à une LED allumée. Avec les matrices A, B et le scalaire C suivants, les matrices A et B ne sont égales que pour l’élément (2,2).

La matrice A est plus grande que B pour les éléments (1,1) et (2,2). Les matrices A et B sont différentes aux éléments (1,1), (1,2) et (2,1). Les éléments (1,2) et (2,1) de la matrice A sont supérieurs aux scalaires C. La matrice A est inférieure à B aux éléments (1,2) et (2,1).

344 Partie I / Apprentissage de LabVIEW

III.2. Systèmes discrets

III.2.1. Utilisation du nœud MathScript

On considère le système discret de fonction de transfert suivante:

211

9.085.111)(

zzzH

La fonction de transfert peut être obtenue par la commande tf à laquelle on transmet le numérateur num, le dénominateur den et la période d’échantillonnage de 0.1s. Les polynômes en z sont spécifiés selon les puissances décroissantes en z. La commande dstep permet de tracer la réponse indicielle du système discret )( 1zH . La commande dcgain calcule le gain statique du système.

La fonction de transfert H1 est affichée en tant que cluster dans lequel nous retrouvons le numérateur, le dénominateur et la période d’échantillonnage de 100 ms. La LED status est éteinte du fait qu’il n’y a aucune erreur. Le gain statique est calculé en remplaçant z par 1,

soit : 209.85.11

1)1(H , ce que nous obtenons dans le panel suivant.

Nous obtenons une réponse indicielle avec plusieurs dépassements du fait que le système est sous amorti.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 345

Le système précédent peut se mettre sous la forme générale canonique du 2nd ordre, qui fait intervenir le coefficient d’amortissement et la pulsation propre 0w .

22

11

1

11)(

zzzH ,

avec

)exp(

)1cos()exp(2

02

2001

10 0 , est la pulsation normalisée.

III.2.2. Utilisation de la fenêtre MathScript

Dans la fenêtre MathScript suivante, nous programmons ce système sous amorti H1 puis le second ordre d’amortissement optimal, H2.

La fonction de transfert est obtenue grâce à la commande tf à laquelle on transmet le numérateur, le dénominateur et la cadence d’échantillonnage.

346 Partie I / Apprentissage de LabVIEW

La commande dstep, sans arguments de retour, permet de tracer la réponse indicielle de la fonction de transfert. Celle du système sous amorti H1 est la suivante.

Il y a plusieurs dépassements autour de la valeur statique. Nous nous proposons d’étudier

un système du 2nd ordre d’amortissement optimal 71.022 . Si nous choisissons

1.00 , nous utilisons la fenêtre MathScript pour calculer les paramètres 1 et 2 . La réponse indicielle du second ordre optimal accuse un seul dépassement avant de se stabiliser sur la valeur statique.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 347

IV. Calculs matriciels

On s’intéresse à la résolution des systèmes d’équations linéaires. On considère principalement les cas où le nombre des équations est, successivement, égal au nombre et supérieur, au nombre d’inconnues. Ce sont les cas dits déterminés et surdéterminés.

IV.1. Système matriciel déterminé

Soit le circuit suivant composé de 3 résistances et de 2 générateurs de tension continue.

On donne : 10021 RR , 220R , VE 121 , VE 52 Les courants i1 et i2, parcourant les résistances R1 et R2, sont donnés par le système suivant à

2 équations à 2 inconnues:

2

1

2

1

ii

AEE

Lorsqu’on met ce système sous la forme A X = B avec yx

X , cette solution est donnée

dans le cas de ce système par BAX 1 . On se propose de calculer les courants i1 et i2. Nous pouvons, soit appliquer la loi des mailles, soit utiliser le théorème de Millman pour

calculer la tension aux bornes de la résistance R. La loi des mailles donne :

12221212

21111211

)()()()(

iRiRRiRiiREiRiRRiRiiRE

Nous obtenons la notation matricielle suivante :

2

1

2

1

2

1

ii

RRRRRR

EE

348 Partie I / Apprentissage de LabVIEW

Le courant i2, dans le sens donné dans le sujet est négatif car la tension E1 est plus élevée

que E2. Dans la 2ème partie du diagramme, nous avons considéré une valeur infinie de la résistance

R, ce qui donne le schéma équivalent suivant :

De ce schéma équivalent, nous avons :

ARREEii 035.0

2007

21

2121

Nous faisons la différence 21 EE et la somme 21 RR que nous sauvegardons dans des

variables locales. Nous comparons cette valeur théorique et celle obtenue par le VI dans ce cas particulier.

Leur différence est plus petite, en valeur absolue, à 10-3. La LED qui est l’indicateur de cette comparaison s’allume bien.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 349

IV.2. Système matriciel surdéterminé, identification d’un processus du 1er ordre

On se propose d’identifier un processus discret du 1er ordre suivant :

)()2()1()1()( 211 kkubkubkyaky

avec un bruit blanc, gaussien et centré.

Nous considérons le cas :

8.01a , 11b et 5.02b

Le bruit est gaussien, centré et de variance 1.

Les mesures sont données par le VI suivant. Nous considérons 100 mesures.

Les paramètres du processus que nous désirons retrouver, sont assemblés, dans le panel, pour former le cluster Cluster Paramètres.

Nous désassemblons le cluster pour ressortir les paramètres a1, b1 et b2 que l’on transmet à la boite de calcul dans laquelle on programme l’équation de récurrence qui retourne la sortie y(k) du processus en fonction de sa valeur antérieure y(k-1) ainsi que les valeurs, actuelle et antérieures, de l’entrée u(k).

350 Partie I / Apprentissage de LabVIEW

Nous créons des registres à décalage pour avoir les valeurs antérieures, de la sortie, y(k-1) et des commandes u(k-1) et u(k-2).

Nous ajoutons un bruit blanc gaussien et centré par le VI Gaussian Noise Waveform.vi de la sous-palette Traitement du signal Génération de Waveforms Wfm Gauss. Nous spécifions une variance unité.

Ce bruit permet de simuler des mesures réelles.

La commande appliquée au processus est une séquence binaire pseudo aléatoire (SBPA) de période 127.

Ce signal, compris entre 0 et 1, est généré par le VI MLS Sequence Waveform.vi de la sous-palette Traitement du signal Génération de Waveforms Wfm MLS.

En appliquant l’expression (2x-1) par le nœud d’expression, nous obtenons un signal de commande compris entre -1 et 1.

Le signal de sortie y(k) et de commande u(k) sont sauvegardés dans un fichier texte grâce au VI Write To Spreadsheet File.vi de la palette E/S sur fichiers Ecrire tableur.

Dans ce panel, nous affichons l’entrée u(k) de type SBPA, entre -1 et 1, ainsi que la sortie y(k) correspondante dans un même graphe XY.

Nous affichons également quelques premières valeurs de ses entrées-sorties, le nombre de mesures, le cluster des paramètres, le chemin dans lequel on enregistre le fichier texte ainsi que le terminal d’itération de la boucle For.

Lorsqu’on exécute ce fichier, on choisit le chemin dans lequel on enregistre le fichier ainsi que son nom.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 351

Dans le VI suivant, nous lisons le fichier sauvegardé par l’intermédiaire Read From Spreadsheet File.vi et récupérons la taille du fichier qu’on désigne par N qui est uns entrée du nœud MathScript. A partir de la matrice lue dans le fichier sauvegardé, nous récupérons les entrées/sorties u(k) et y(k), soit :

)(....

)3()2()1(

Ny

yyy

et

)(....

)3()2()1(

Nu

uuu

Par la boucle For, nous avons les valeurs retardées de u et y, à savoir y(k-1), u(k-1) et u(k-2). Nous avons alors les différents vecteurs suivants :

)1(....

)4()3()2(

Ny

yyy

,

)1(....

)4()3()2(

Nu

uuu

et

)2(....

)5()4()3(

Nu

uuu

Comme à chaque instant k, nous avons la relation suivante :

)2()1()1()( 211 kubkubkyaky

Globalement, nous avons la relation matricielle suivante :

)(....

)3()2()1(

Ny

yyy

N

bba

NuNuNy

uuyuuyuuy

.

.

.

.

)2()1()1(........

)5()4()4()4()3()3()3()2()2(

3

2

1

2

1

1

soit : BAY ,

352 Partie I / Apprentissage de LabVIEW

avec :

A=

)2()1()1(........

)5()4()4()4()3()3()3()2()2(

NuNuNy

uuyuuyuuy

et

2

1

1

bba

Nous construisons la matrice A dans le nœud MathScript.

En multipliant à gauche, la relation matricielle par TA , nous obtenons :

BAAA TT

La matrice A , n’étant pas carrée, la solution X0 est donnée par la méthode des moindres carrés,

soit : BAAA TT 1)(

Dans ce VI, nous rassemblons les différents vecteurs )1(),(),1(),( kukukyky et )2(ku dans le cluster Cluster de sortie.

Dans le panel, nous affichons les entrées-sorties lues dans le fichier (toutes les lignes), les clusters des tableaux y(k), u(k) et leurs valeurs retardées, les matrices A, le vecteur B et leur vecteur paramètres identifié.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 353

Nous retrouvons les paramètres suivants :

0,500583-0,992203

798823.0, proches de ceux que nous avons spécifiés au départ

0,5-18.0

2

1

1

bba

V. Réponse indicielle de processus du 1er ordre et 2nd ordre

V.1. Système du 1er ordre

V.1.1. Système du 1er ordre analogique

Nous considérons le circuit RC suivant dont Ve et Vs sont, respectivement, les tensions

d’entrée et de sortie.

La loi aux mailles nous donne :

RtVstVe

dttdVsCti )()()()( ,

soit :

354 Partie I / Apprentissage de LabVIEW

)()()( tVedt

tVsRCtVs

La réponse à un échelon de valeur Ve0 est donnée par :

)1()( /0

teVetVs , avec ,CR la constante de temps

Dans le diagramme, nous traçons le signal temporel de sortie dans un graphe XY. Les

valeurs de R et C sont assemblées dans le cluster paramètres que nous désassemblons dans

ce diagramme.

Dans le graphe suivant, nous vérifions bien qu’à t=t=10s, la sortie est égale 0.63, soit

63% de la valeur maximale.

V.1.2. Système discret du 1er ordre

Considérons un système un système du 1er ordre suivant:

1

11

11

121

11

8.01)5.01(

1)()(

zzz

zazbbzzH

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 355

Nous allons d’abord étudier le temps de réponse avec la réponse indicielle.

Le temps de réponse à 5% d’un système du 1er ordre est égal à 3 , avec la constante de

temps. La constante de temps est le temps auquel la sortie atteint 63% de la valeur maximale de 2.5, soit 1.57, soit un temps de réponse .7,4 str Le curseur nous donne s3 et un gain statique de 2.5 qui correspond bien à celui qu’on obtient lorsqu’on remplace z par 1, soit H(1).

V.2. Réponse indicielle d’un système du 2ème ordre

V.2.1. Second ordre analogique

Le modèle du moteur à courant continu est régi par 2 équations : l’équation électrique au

niveau de l’induit et l’équation mécanique au niveau de l’arbre.

356 Partie I / Apprentissage de LabVIEW

)()()()( tedt

tdiLtiRtu

:, LR résistance et inductance d’induit,

:, iu tension et courant d’induit,

:e force électromotrice induite.

Pour l’équation mécanique, on utilise le principe fondamental de la dynamique (PFD) :

)()( tfdt

tdJ

On donne :

m.N/A0,506kg.m 0.05J

N.m.s 0.0000142H 0.1

1

2

KJfLR

En posant KE (f.e.m proportionnelle à la vitesse de rotation) et iK (couple

moteur proportionnel au courant d’induit), nous obtenons le schéma bloc suivant :

Nous obtenons la fonction de transfert, du 2nd ordre, suivante :

fRKpp

fRK

fRKp

fJp

RL

fRK

pUppH

me

22

)1()1()1()1()()()(

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 357

20

2

0

0

222

2

22

2111

1

)1/(

)(1

wp

wp

H

p

fRK

p

fRK

fRK

fRK

ppfR

KfR

K

meme

meme

RL

e etfJ

m , sont les constantes de temps, électrique et mécanique.

Par identification, nous obtenons la pulsation propre et le coefficient d’amortissement

suivants:

me

fRK

w

2

0

1

)1(21

2

fRK

me

me

Les paramètres électromécaniques sont assemblés dans un cluster au niveau du panel.

Il est désassemblé dans le diagramme et ses éléments vont servir d’entrées au nœud

MathScript. Dans ce nœud, nous calculons le numérateur et le dénominateur de la fonction de

transfert.

La fonction conv permet de calculer le produit des polynômes 1pRL et

1pfJ auquel on ajoute le scalaire

fRK 2

. Le résultat se présente comme le

polynômefR

Kpp2

2 00 .

Nous calculons le coefficient d’amortissement et la pulsation propre 0w d’après les

expressions précédentes.

358 Partie I / Apprentissage de LabVIEW

Nous trouvons le même gain statique, proche de 2, sur la courbe et par calcul. D’autre part,

le coefficient d’amortissement est proche de 2/2 , valeur qui correspond à un amortissement

optimal pour lequel la courbe n’accuse qu’un seul dépassement, comme le montre cette

réponse indicielle.

V.2.2. Second ordre discret

Le script suivant permet de programmer la réponse indicielle du système de 2nd ordre. Nous

choisissons un coefficient d’amortissement optimal, 22 .

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 359

La fonction de transfert de ce système est donnée par :

22

11

211

11)(

zzzH

, avec

)2exp(

)1cos()exp(2

02

2001

Le temps de réponse de ce système est approximativement 5 fois plus élevé que celui du 1er

ordre précédent. Nous observons un seul dépassement du fait du choix de .7.0 De plus le gain statique

est égal à 1 contrairement à celui du 1er ordre, égal à 2.5.

360 Partie I / Apprentissage de LabVIEW

VI. Fonctions graphiques

VI.1. Graphiques 2D

Dans le script suivant, nous faisons appel à différentes façons de réaliser un graphique 2D.

L’ensemble des instructions de ce script peut être inséré dans la fenêtre de commande pour obtenir les mêmes résultats.

VI.2. Graphiques 3D

Comme graphiques 3D, nous pouvons réaliser des surfaces, volumes, etc. Dans l’exemple suivant, nous traçons la surface donnée par l’expression :

22),( yxyxfz

pour x et y variant de -10 à 10 avec un pas de 0.5.

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 361

Dans la 1ère figure, nous traçons ses contours par la commande meshc, dans la 2ème figure la surface est donnée par la commande surf.

VII. Appel de fonctions MathScript

Nous pouvons faire appel à des fonctions développées dans la fenêtre MathScript LabVIEW.

Ces fonctions sont des fichiers « .m » que l’on sauvegarde dans un répertoire connu de LabVIEW.

Comme exemple, nous allons développer la fonction sin_card.m qui permet de calculer le sinus cardinal de l’angle (rad) qu’on lui envoie comme paramètre d’appel.

Nous allons utiliser les relations conditionnelles qui valent 1 quand elles sont vérifiées et 0 partout ailleurs.

362 Partie I / Apprentissage de LabVIEW

xxxxxc

)0()sin()0()(sin

Pour x=0, nous avons (x==0)=1 d’où sinc(0)=1. Lorsque x est différent de zéro, nous avons (x==0)=0, alors sinc(x)=sin(x)/x. Ainsi, nous avons bien levé l’indétermination en x=0. A droite de la fenêtre suivante, nous trouvons le code de cette fonction que nous

sauvegardons sous le nom sin_card.m. Dans la fenêtre de commande, nous spécifions les 3 instructions suivantes : % définition de l’angle alpha=-4*pi:pi/100:4*pi; % appel de la fonction sin_card y=sin_card(alpha); % tracé de la fonction sinus cardinal plot(alpha,y)

Chapitre 9 / Le nœud MathScript et la fenêtre MathScript 363

Les relations conditionnelles prennent généralement beaucoup de temps. Il est plus intéressant de passer par le test « if ».

Nous éditons le fichier sin_card2.m dans lequel on appelle la fonction sin_card.m à

laquelle on transmet l’angle sur lequel on désire avoir le sinus cardinal.

Nous obtenons les mêmes résultats qu’avec l’utilisation des relations conditionnelles.

Partie I. Chapitre 10 - Les nœuds de propriété

I. Propriétés d’une table Express II. Propriétés des onglets II.1. Onglet afficheurs II.2. Onglet graphe des valeurs II.3. Histogramme II.4. Diagramme II.4.1. Génération du signal et tracé de l’histogramme II.4.2. Utilisation des nœuds de propriété II.4.3. Diagramme général II.4.4. Gestion des propriétés d’un graphe II.4.5. Nœuds de propriété de classe VI et classe Application III. Les nœuds de méthode

DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _10,365N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie I / Apprentissage de LabVIEW

366

Les nœuds de propriété permettent d’accéder à certains éléments d’un objet en lecture ou en écriture. Les propriétés à lire sont symbolisées, à gauche, par une petite flèche et ceux à écrire, par une petite flèche à droite. On peut passer du mode lecture à celui de l’écriture et inversement en choisissant « passer en écriture » ou « passer en lecture », dans le menu local.

Certaines propriétés ne peuvent pas être écrites et d’autres pas lues. En écriture, on peut définir plusieurs propriétés d’un VI. On peut créer une propriété en

tirant vers le bas avec l’outil flèche de la souris ou par « ajouter un élément » par un clic droit.

Pour modifier une propriété, on utilise l’outil doigt ou « sélectionner une propriété » par l’outil flèche. Un nœud de propriété s’exécute de haut en bas. Si on a choisi « Ignorer les erreurs à l'intérieur du nœud » dans le menu local, le nœud effectue les propriétés restantes si une erreur survient dans une propriété.

Si on a branché un indicateur sur le cluster d’erreur, on peut obtenir des informations sur la propriété qui a causé l’erreur.

On peut créer un nœud de propriété sur un objet du panel en sélectionnant, dans le menu

local, « Créer un nœud de propriété » et en sélectionnant une propriété. Le nœud et la propriété sont créés automatiquement dans le diagramme. Le nœud et l’objet sont ainsi implicitement liés.

Pour supprimer le lien avec cet objet du panel, on choisit « Déconnecter de la commande » du menu local.

I. Propriétés d’une table Express

La table Express est obtenue dans la palette Indicateurs texte comme suit:

Nous ne pouvons écrire dans une table que des chaînes de caractères. Nous nous proposons

d’afficher dans une table 10 valeurs aléatoires et celles du sinus cardinal. Les 10 valeurs aléatoires sont générées dans une boucle For.

Chapitre 10 / Les nœuds de propriété

367

Les valeurs de sinus cardinal sont générées par le VI Sinc Pattern.vi de la sous-palette Traitement de signal Gen. Signaux.

Les 2 signaux sont rassemblés en tableau par le VI « Construire un tableau » que

nous affichons dans le tableau « tableau ajouté 2». Nous devons convertir les valeurs réelles en données dynamiques avant d’entrer dans le VI

« Construire une table » de type Express. Ce VI réalise une transposition des données avant de les afficher dans la table. Pour insérer un en-tête à la table, nous devons faire appel à la propriété « EntCol[] » pour en-tête de colonnes. Nous devons utiliser un nœud de propriété de la palette « Contrôle d’applications ».

Partie I / Apprentissage de LabVIEW

368

On insère le nœud de propriété dans le diagramme et on choisit l’objet pour lequel on veut récupérer (mode lecture) ou modifier certaines propriétés (mode écriture).

Le nœud est lié à l’objet « table écrite ». Nous choisissons alors la propriété que l’on

veut modifier par écriture ou récupérer par lecture. Dans cet exemple, nous :

- lisons la valeur de la table par lecture de la propriété Valeur, - spécifions les en-têtes des colonnes par l’écriture de la propriété EnCol[], - récupérons le nombre de lignes de la table par lecture de la propriété NbLignes, - récupérons le nombre de colonnes de la table par lecture de la propriété NbCols, - récupérons les en-têtes des colonnes déjà spécifiés par lecture de EnCol[].

Chapitre 10 / Les nœuds de propriété

369

Une propriété peut passer du mode lecture à celui d’écriture et inversement. La propriété EntCol[] est d‘abord en mode écriture pour recevoir le vecteur suivant de chaînes de caractères :

Plus loin, cette même propriété est mise en mode lecture pour récupérer le même vecteur :

La couleur de la valeur de la propriété donne une idée de son type :

- EntCol[] : chaîne de caractères - NbLignes, NbCols : entiers

Ajouter/Supprimer un élément consiste à ajouter ou supprimer une autre

propriété, à lire ou à écrire, de l’objet considéré. Dans l’exemple suivant, on sélectionne la propriété « Chaînes d’en-tête de

colonne [] » pour insérer des entêtes à chacune des colonnes de la table.

Partie I / Apprentissage de LabVIEW

370

Pour que ces en-têtes soient visibles en 1ère ligne de la table, nous devons choisir « En-

têtes de colonnes » parmi les éléments visibles.

Parmi les éléments de la table qu’on peut rendre visibles, il y a aussi les traits verticaux,

horizontaux, des barres de défilement, etc. Dans le panel suivant, nous affichons les tableaux de valeurs aléatoires et du sinus cardinal,

ainsi que le tableau à 2 dimensions formé par ces 2 signaux.

Chapitre 10 / Les nœuds de propriété

371

La lecture de la propriété Valeurs donne les valeurs de la table sans l’en-tête des colonnes.

Les propriétés Nblignes et NbCols retournent 12 lignes et 2 colonnes.

II. Propriétés des onglets

Nous allons utiliser les nœuds de propriété pour gérer les propriétés des tables (lecture et écriture des en-têtes des colonnes, lecture de la table, du nombre de lignes, de colonnes), des onglets, etc.

II.1. Onglet afficheurs

Dans le VI noeud_propriété_2.vi de cet exemple, nous générons un signal aléatoire gaussien dont la variance est, elle aussi, aléatoire de distribution uniforme dont la valeur est comprise entre 0 et 1.

Dans l’onglet « Afficheurs », nous affichons les variations de ce signal, de sa moyenne et de sa variance.

Nous avons utilisé des objets de la face-avant de type Argent pour Vu-mètre,

Réservoir, Jauge afin de représenter, respectivement, la moyenne, la variance et les valeurs du signal.

Partie I / Apprentissage de LabVIEW

372

Le tableau Position permet de spécifier les coordonnées, horizontale et verticale, des

onglets. On peut rendre visible ou invisible l’indicateur Tank de la variance du bruit gaussien dont

la variance est elle-même une variable aléatoire uniforme. Nous ne gérons, dans ce programme, que la position horizontale.

II.2. Onglet graphe des valeurs

Dans cet onglet, nous représentons le signal et ses valeurs.

Chapitre 10 / Les nœuds de propriété

373

II.3. Histogramme

Dans cet onglet, nous représentons l’histogramme des valeurs du signal. Nous avons imposé 1000 intervalles pour l’histogramme qui est bien d’allure gaussienne centrée.

II.4. Diagramme

II.4.1. Génération du signal et tracé de l’histogramme

La partie du diagramme qui génère ce signal est la suivante :

Partie I / Apprentissage de LabVIEW

374

Nous utilisons le VI « White Noise Waverform.vi » de la sous-palette « Génération de waveforms » de la palette « Traitement du signal» pour générer un bruit blanc gaussien centré sous forme de waveform.

Pour afficher les valeurs de sortie des VIs « Obtenir les composantes d’une

waveform », « Histogram.vi », « Std Deviation and Variance.vi », il faut juste mettre l’outil Bobine à la sortie de ces VIs et choisir « Créer Indicateur » après un clic droit.

Ce VI génère un signal de type waveform. Pour afficher les valeurs de ce signal, nous

devons récupérer le signal temporel Y de la waveform :

Chapitre 10 / Les nœuds de propriété

375

II.4.2. Utilisation des nœuds de propriété

II.4.2.1. Visibilité d’objets

Nous désirons afficher un message d’aide à chaque fois qu’on clique sur le bouton « Description du programme ». Le texte à afficher est écrit dans la fenêtre « message » sur la face-avant. Ce message peut être visible avec le nœud de propriété.

.

Nous utilisons le VI « Three Button Dialog.vi » pour afficher ce message.

Partie I / Apprentissage de LabVIEW

376

Pour ne pas afficher le titre et le contenu de ce message de façon continue, nous associons à ces 2 objets la propriété Visible qu’on met à la valeur fausse « F ».

Ainsi, ce message et son titre s’effacent lorsqu’on exécute le programme. Rien ne se passe si on n’appuie pas sur le bouton « Description du programme ».

Lorsqu’on appuie sur le bouton « Description du programme », il y a affichage du

message suivant :

De plus, les étiquettes des pages de chaque onglet sont aussi écrites sur le panel. On fait de

même que pour le message précédent. Pour afficher ces étiquettes, il suffit de mettre à « T » la propriété « Visible » de chaque

étiquette.

Chapitre 10 / Les nœuds de propriété

377

II.4.2.2. Adaptation de la largeur des étiquettes

En choisissant « Size To Contents », la taille de l’étiquette prend la taille de son titre.

Si la composante status du cluster d’erreur vaut 1 (présence d’une erreur), l’exécution du VI s’arrête après l’envoi ce 1 logique au bloc STOP.

II.4.2.3. Position horizontale des onglets

On considère la possibilité de modifier la position horizontale des onglets.

Partie I / Apprentissage de LabVIEW

378

Le choix de la propriété Position se fait comme suit :

II.4.2.4. Gestion des étiquettes des onglets

On spécifie l’indépendance des étiquettes des onglets en reliant la constante booléenne T (True) à la propriété SsTitreOngl.

Ensuite, on définit ces différentes étiquettes à travers les chaines de caractères Titre 1,

Titre 2, et Titre 3 que nous définissons dans la face-avant.

Pour accéder aux pages des 3 onglets, nous utilisons la propriété Pages d’un nœud de

propriété lié à l’objet Commande des onglets.

Chapitre 10 / Les nœuds de propriété

379

En sortie de cette propriété, nous récupérons un tableau, à 3 dimensions correspondant aux

3 pages. Il suffit d’indexer le tableau au numéro de la page pour spécifier son titre.

Partie I / Apprentissage de LabVIEW

380

Ci-dessous, le nœud de propriété EtiquetteIndep à laquelle on applique une constante logique T, soit l’autorisation des étiquettes indépendantes.

Dans le menu local, afin de choisir une propriété, on choisit Sélectionner une

propriété. Dans notre cas, on choisit la propriété Etiquette indépendante.

Nous pouvons également choisir les couleurs d’arrière-plan et de premier plan.

Chapitre 10 / Les nœuds de propriété

381

II.4.3. Diagramme général

Dans le diagramme général suivant, on fait apparaître les 3 parties distinctes étudiées précédemment.

II.4.4. Gestion des propriétés d’un graphe

Les propriétés d’un objet s’adaptent automatiquement à l’objet auquel on lie un nœud de propriété. Nous allons considérer un graphe dans lequel on trace un sinus cardinal auquel on superpose un bruit blanc gaussien. A ce graphe on lie un nœud de propriété.

Le nœud de propriété se trouve dans la sous-palette « Contrôle d’applications ».

Nous devons spécifier ensuite à quel objet est lié ce nœud de propriété. Comme nous le

voyons ci-dessous, ce nœud est lié à l’objet Graphe du diagramme.

Partie I / Apprentissage de LabVIEW

382

Pour un objet auquel on lie le nœud de propriété, on doit sélectionner la propriété qu’on

doit lire (mode lecture) ou écrire (mode écriture).

Par défaut, cette propriété est en lecture. Après un clic droit, nous choisissons l’option

« Changer en écriture ».

Chapitre 10 / Les nœuds de propriété

383

Le diagramme avec les nœuds de propriété est le suivant. Nous allons étudier, dans ce

diagramme, différents types de propriétés afin de contrôler quelques paramètres du graphe.

II.4.4.1. Couleur du tracé

Nous nous proposons de modifier la couleur du tracé de ce panel. Nous utilisons une structure condition pour pouvoir obtenir 3 couleurs différentes : Le jaune, le rouge et le vert. Dans la face-avant, ces 3 couleurs sont choisies par 3 LEDs qui s’allument par relâchement.

La structure séquence commandée par l’ensemble de ces couleurs contient une constante

couleur qui va attaquer la propriété Tracé.Coul afin de mettre la courbe affichée à la couleur choisie.

Cette constante couleur se trouve dans la sous-palette « Dialogue et interface utilisateur ».

Partie I / Apprentissage de LabVIEW

384

Pour changer de couleur, il suffit, de placer le pinceau sur la constante couleur. Dans

chaque étape de la séquence condition, nous plaçons la constante couleur correspondante au titre de la séquence.

La propriété Tracé.Nom permet d’écrire le nom du tracé « Sinus cardinal bruité ».

Nous pouvons supprimer le tracé grâce au bouton Tracé.visibles qui agit sur la propriété Tracé.Visible ? avec la valeur logique 0.

On place l’outil pinceau sur la constante couleur pour changer cette dernière.

Chapitre 10 / Les nœuds de propriété

385

II.4.4.2. Style du tracé

Pour modifier le style du tracé, nous utilisons la propriété Tracé.StyleLigne.

Comme pour la couleur, nous utilisons une séquence condition pour choisir entre 3 styles :

Traits pleins, Tirets et Pointillés. Toutes les propriétés du graphe sont en mode écriture.

Partie I / Apprentissage de LabVIEW

386

II.4.4.3. Gestion des coordonnées des abscisses et des ordonnées du tracé

Nous allons gérer le minimum et le maximum des axes des abscisses de X et des Y du tracé. Dans cet exemple, nous allons utiliser le nœud de propriété dans le sous-VI sous_VI_property_nodes.vi. Afin de transmettre la référence au sous-VI, nous devons utiliser le VI Référence du VI serveur qu’on doit lier à l’objet Graphe dont on modifie certaines propriétés dans le sous-VI.

Le nœud de propriété qu’on utilise dans un sous-VI doit recevoir le VI Ctrl Reference qu’on doit lier à l’objet Graphe pour lequel on désire modifier quelques propriétés.

Nous spécifions les propriétés correspondant aux minimums et maximums des échelles X

et Y pendant qu’on rend visible la légende de l’échelle.

Chapitre 10 / Les nœuds de propriété

387

Le sous-VI, ses commandes et la référence du VI serveur sont les suivants :

II.4.4.5. Lecture de propriétés d’un objet

Nous allons utiliser d’autres propriétés dont on veut connaître les valeurs grâce aux nœuds de propriété dont voici le diagramme et la face-avant correspondants.

La connaissance du système d’exploitation, l’année de la version de la version de LabVIEW (application) ainsi que la langue est indépendante de l’application en cours. Dans ce cas, le nœud de propriété n’est lié à aucun objet.

Partie I / Apprentissage de LabVIEW

388

Dans cet exemple, nous affichons les valeurs des propriétés : - Nom du système d’exploitation, - L’année de la dernière version de LabVIEW, - Langue de l’application.

Dans l’exemple qui suit, nous nous intéressons à l’écriture de la propriété du tracé en même temps que de l’épaisseur du trait et la lecture du nom de la classe de l’objet Graphe.

Si on doit limiter la valeur de cette épaisseur entre une valeur minimale et une valeur maximale, nous devons spécifier les valeurs des propriétés Echelle Gamme Minimum et Echelle Gamme Maximum respectivement à 1 et 5 avec un incrément de 1.

Chapitre 10 / Les nœuds de propriété

389

Nous avons alors les parties du diagramme et du panel correspondantes à la propriété que nous avons modifiée pour l’épaisseur du trait:

Nous présentons ci-après le diagramme complet.

Dans la face-avant, nous avons le cas d’un tracé, visible, d’épaisseur 4, de couleur rouge, et

en pointillés, tel que spécifié dans les propriétés correspondantes.

Partie I / Apprentissage de LabVIEW

390

II.4.5. Nœuds de propriété de classe VI et classe Application

II.4.5.1. Propriétés d’une application

Recherche des VIs en mémoire

Pour rechercher les VIs en mémoire de l’ordinateur local, on utilise un nœud de propriété lié à l’application pour lequel on choisit la propriété « VIs exportés en mémoire ».

Dans le panel, nous obtenons la liste des VIs présents en mémoire.

Chapitre 10 / Les nœuds de propriété

391

Ce sont les fichiers dont la liste s’affiche dans le menu « fenêtre » de chaque fenêtre de LabVIEW.

Propriétés de l’application LabVIEW

Dans le diagramme suivant, nous récupérons quelques propriétés de l’application LabVIEW.

Ces propriétés sont : - l’année de la version avec App.Annéevers, - le chemin du répertoire avec App.Rép, - la marque du processeur avec App.CPUCible, - le nom de l’utilisateur fourni par la propriété App.NomUtilis, - le numéro de version fourni par la propriété App.version.

Pour utiliser ce nœud de propriété, nous devons d’abord récupérer le VI Nd propriété

de la palette Contrôle d’applications. Ensuite, pour lier ce nœud de propriété à l’application locale, nous devons ouvrir une

référence d’application qui ouvre un refnum d’application.

Les propriétés précédentes donnent les résultats suivants :

- 2012 pour l’année de la version de LabVIEW, - C:\Program Files\LabVIEW2012 pour le chemin du répertoire où se trouve

l’application LabVIEW, - la marque Intel pour le processeur du PC, - mohand comme utilisateur,

Partie I / Apprentissage de LabVIEW

392

- LabVIEW est à sa 12ème version.

Dans le diagramme suivant, le nœud de propriété nous permet d’avoir d’autres propriétés comme la version de LabVIEW, le type de système d’exploitation, etc.

Chapitre 10 / Les nœuds de propriété

393

III. Les nœuds de méthode

Les propriétés sont les attributs d'un VI ou d'un objet du panel. Dans un nœud de méthode, on effectue des actions sur un VI, un objet ou une application. On utilise un nœud de méthode pour réaliser une action ou une méthode sur un VI, un objet ou une application spécifique. La différence avec un nœud de propriété est qu’un nœud de méthode n’exécute qu’une seule méthode ou action sur un VI ou application.

Dans ce diagramme, nous avons utilisé un nœud de méthode et un nœud de propriété pour

le graphe.

La méthode utilisée est ExportDonnéesTracéVersExcel qui permet d’exporter vers

Excel les données tracées dans Graphe. Le nœud de propriété permet d’écrire 3 propriétés

Partie I / Apprentissage de LabVIEW

394

liées au même graphe. La première, Coul.d’AP ou couleur d’arrière plan que l’on a choisie bleue. La constante couleur qu’on applique la propriété Coul. d’AP est obtenue dans la palette Dialogue/IU.

Pour choisir la couleur de cette constante, il suffit d’amener le pinceau, faire un clic droit de la souris et sélectionner une couleur dans la palette.

La propriété suivante concerne la taille du tracé. Les valeurs 600 et 400 définissent, respectivement, la taille horizontale et verticale.

La troisième propriété autorise le clignotement du graphe.

Partie I. Chapitre 11 – Les entrées/sorties sur fichiers

I. Fichiers de type tableur I.1. Sauvegarde d’un fichier tableur I.2. Lecture d’un fichier tableur II. Fichier texte II.1. VIs de la palette E/S sur fichiers II.2. VIs de type Express II.2.1. Ecriture de fichier II.2.2. Lecture du fichier III. Fichiers binaires III.1. Sauvegarde dans un fichier binaire III.2. Lecture d’un fichier binaire IV. Fichiers de waveforms IV.1. Ecriture et lecture dans une séquence déroulée IV.2. Lecture et écriture dans une séquence empilée IV.3. Export de la waveform dans un fichier tableur IV.4. Export de 3 waveforms IV.4.1. Sous-VI générateur de 3 waveforms IV.4.2. Export d’un tableau de waveforms V. Fichiers TDMS V.1. Utilisation des VI Express V.2. VIs de la sous-palette TD en continu V.2.1. Ecriture de fichiers TDMS V.2.2. Lecture de fichiers TDMS V.2.3. Propriétés d’un fichier TDMS V.2.4. Création de groupes et propriétés pour un fichier TDMS VI. Export de données de LabVIEW vers Excel VI.1. Menu Exporter par un clic droit VI.2. Utilisation d’un nœud de méthode VII. Fichiers Zip VII.1. Création d’un nouveau fichier Zip VII.2. Ajout du fichier Zip VII.3. Fermeture du fichier Zip VIII. Fichiers XML VIII.1. Ecriture des fichiers XML VIII.2. Lecture des fichiers XML IX. Stockage de données sous différents formats IX.1. Ecriture avec les VIs de type Express IX.1.1. Ouverture, création d’un nouveau fichier IX.1.2. Définition des propriétés IX.2. Lecture avec les VIs de type Express X. Gestion des répertoires

395DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _11,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie I / Apprentissage de LabVIEW

396

LabVIEW propose de nombreux formats de fichiers d’E/S. Certains possèdent l’avantage d’interchangeabilité sur différents plateformes avec l’inconvénient de leur volume comme les fichiers ASCII.

La lecture des fichiers binaires ne pose pas de problème majeur avec les machines de plus en plus rapides mais ne peuvent pas être partagés sur différentes plateformes.

On peut dénombrer 3 types :

- chaînes dans des fichiers texte, - tableaux 1D ou 2D dans des fichiers texte de type tableur, - tableaux 1D ou 2D de type binaire.

National Instruments a développé le format TDMS, format de fichier propriétaire, qui

remplace le format TDM. Ce format permet de gérer et de documenter les fichiers de mesure, très répandus dans

l’industrie. L’avantage des fichiers au format TDMS sur ceux au format TDM est le nombre illimité de

voies et de groupes de voies. Les fichiers de format TDMS sont des fichiers binaires de waveforms. Dans l’industrie, nous avons généralement besoin de sauvegarder les mesures acquises sur

le banc pour les analyser ensuite en temps différé. LabVIEW possède plusieurs fonctions d’E/S pour sauvegarder des signaux dans plusieurs types de fichiers (texte, tableur, binaire, etc.). Les VIs correspondants à l’écriture et lecture de fichiers se trouvent dans la palette E/S sur fichiers, représentée par une disquette. LabVIEW propose beaucoup d’autres types d'E/S sur fichiers : binaire, journaux, ZIP et XML.

Chapitre 11 / Les entrées/sorties sur fichier

397

I. Fichiers de type tableur

Un fichier tableur est celui dans lequel les données sont délimitées, généralement par des tabulations.

I.1. Sauvegarde d’un fichier tableur

Pour simuler les mesures de 2 capteurs, non générons 2 signaux, le premier étant un signal aléatoire, le deuxième est un signal sinusoïdal auquel on ajoute un bruit uniforme.

Dans ce VI, pour générer ce 2ème signal, nous devons disposer du module « Conception de contrôle et simulation ». Avec la fonction Construire un tableau 2D, on assemble les 2 tableaux 1D pour faire un tableau 2D qu’on transpose avant la sauvegarde dans un fichier tableur. La commande Chemin permet d’ouvrir une fenêtre de dialogue dans laquelle on choisit l’emplacement et le nom du fichier.

Le panel affiche le tableau 2D des mesures ainsi que la commande Chemin. Nous avons

appliqué la valeur booléenne F (Faux) à l’entrée Ajouter au fichier ? afin qu’un nouveau fichier remplace celui, de même nom, sur le disque.

Idem pour l’entrée Transposer car le tableau 2D a déjà été transposé.

Partie I / Apprentissage de LabVIEW

398

Si on ouvre ce fichier dans Excel, nous trouvons les 10 mesures suivantes.

I.2. Lecture d’un fichier tableur

Dans le diagramme suivant, nous lisons le fichier sauvegardé précédemment.

Nous avons appliqué la valeur F (faux) à l’entrée Transposer pour ne pas transposer le

tableau lu. Nous vérifions que les valeurs lues sont parfaitement les mêmes que celles qui sont

sauvegardées.

Chapitre 11 / Les entrées/sorties sur fichier

399

Nous devons préciser le nom du fichier ainsi que son chemin, soit pour son écriture à l’aide du VI Write to Spreadsheet File.vi, soit pour sa lecture avec le VI Read From Spreadsheet File.vi

Le chemin et le nom du fichier sont spécifiés grâce à la commande « Cmde chemin » de

la palette Chaîne et chemin de la face-avant.

Le VI chemin, , permet de spécifier l’emplacement d’un fichier sur le disque. Si ce chemin n’est pas spécifié,

celui-ci et le nom du fichier doivent être renseignés dans une boite de dialogue.

Le diagramme du VI Write Spreadsheet String.vi exécute plusieurs opérations

sur le fichier à écrire.

Création du fichier sur le disque

Ecriture du fichier texte

Fermeture du fichier

Partie I / Apprentissage de LabVIEW

400

Ces VIs se trouvent dans la palette E/S sur fichiers.

II. Fichier texte

II.1. VIs de la palette E/S sur fichiers

On se propose de réaliser un programme qu’on est amené à utiliser dans l’industrie : mesures, régulation, affichage des courbes et sauvegarde des résultats dans un fichier texte dans le but d’un traitement hors ligne.

Nous utilisons une structure séquence empilée de 3 étapes. L’étape 0 consiste à faire des mesures, l’étape 1 pour la sauvegarde des données et la dernière pour l’affichage des courbes.

Chapitre 11 / Les entrées/sorties sur fichier

401

Dans cette étape, nous assemblons les 2 données dans un tableau 2D qu’on transforme en chaînes de caractères. Nous avons choisi un format flottant à 2 décimales « %.2f » en faisant la concaténation des 3 chaînes « %. », « 2 » et « f ».

Les données sont sauvegardées dans un fichier texte grâce à la fonction Ecrire dans

un fichier texte. On désassemble le cluster d’erreur pour récupérer l’élément status qui prend la valeur 1 lorsqu’il y a erreur. Dans ce cas, cette valeur booléenne 1 arrête l’exécution du VI grâce à l’activation de la fonction STOP.

A l’extérieur de la structure, nous avons spécifié l’en-tête du fichier. Cet en-tête comprend

la date et l’heure, une tabulation, la chaîne x1, une tabulation, la chaîne x2 suivie d’un retour à la ligne :

Cet en-tête est enregistré dans le fichier avant les données. Il est affiché sur le panel dans la

chaîne de caractères En-tête.

Dans la séquence 2, nous affichons les valeurs dans un graphe déroulant.

Partie I / Apprentissage de LabVIEW

402

Le panel affiche l’en-tête, le tableau 2D des 10 mesures à sauvegarder et les courbes des mesures.

Lorsqu’on ouvre le fichier par le tableur Excel, nous avons les données avec 2 chiffres

après la virgule.

Des VIs des versions précédentes de LabVIEW peuvent toujours être utilisés, comme pour

le cas du VI Write Caracters To Files.vi qui remplit les mêmes fonctions que Ecrire dans un fichier texte.

Dans le diagramme suivant, dans l’en-tête, nous commençons par afficher la date et l’heure

dans la chaîne de caractères chaîne de date/heure. Le même chemin est utilisé pour la sauvegarde de l’en-tête et des données.

Chapitre 11 / Les entrées/sorties sur fichier

403

Dans le VI suivant, nous utilisons une boucle For pour générer les données. Nous spécifions le chemin par la constante « C:\Livre_Labview2012\Entrées

sorties sur fichiers\ ». Comme le nom du fichier n’est pas spécifié, celui-ci devra être renseigné dans une boite de

dialogue. Le format choisi est un flottant à 4 chiffres après la virgule.

Dans le panel, nous représentons uniquement le tableau des données de mesure. La boucle

For est cadencée à 0.2s. Le deuxième tableau 1D est généré par une boucle de contrôle et simulation.

Partie I / Apprentissage de LabVIEW

404

II.2. VIs de type Express

Lorsqu’on fait des mesures, ces dernières doivent être sauvegardées dans un fichier texte dans un tableur tel qu’Excel pour un traitement différé.

Dans cet exemple, nous générons un sinus cardinal que nous sauvegardons dans un fichier

texte grâce au VI Write Measurement File.

II.2.1. Ecriture de fichier

Nous générons 10 valeurs d’un bruit blanc uniforme à travers une boucle For. Le signal est du type waveform.

En sortie de la boucle, nous obtenons un tableau de 10 waveforms que nous traçons dans le graphe Waveform chart et affichons dans le tableau Array.

Nous transformons ces waveforms en données dynamiques que nous appliquons à l’entrée

Signaux du VI Express Ecrire dans un fichier de mesures. Le nom du fichier est spécifié dans la commande Filename. Un commentaire peut être rajouté au fichier. Ce commentaire, spécifié dans la commande

Comment, sera récupéré dans le VI Express Lire un fichier de mesures.

Chapitre 11 / Les entrées/sorties sur fichier

405

Dans la fenêtre de dialogue, nous spécifions que nous sauvegardons le signal dans un fichier texte de type LVM, avec séparateur tabulation, sans en-tête et sans colonne de temps.

Dans le panel, nous affichons les valeurs du fichier de mesures, spécifions son nom ainsi

que le chemin et un commentaire. Nous affichons également dans un graphe les valeurs du fichier ainsi sauvegardées dans un fichier texte.

Partie I / Apprentissage de LabVIEW

406

Le fichier texte ainsi obtenu affiche d’abord un en-tête dans lequel on trouve : - la tabulation comme type de séparateur, - la virgule comme séparateur décimal, - le nom de l’opérateur et la date de la mesure.

Chapitre 11 / Les entrées/sorties sur fichier

407

II.2.2. Lecture du fichier

On se propose de lire un fichier, de type lvm, à l’aide du VI Express Lire un fichier de mesures.Pour cela, il suffit juste de spécifier le chemin du fichier. En plus de la lecture du fichier de données, nous récupérons également le commentaire éventuel.

Si une erreur intervient ou si on appuie sur le bouton Quit LabVIEW ?, nous arrêtons l’exécution du VI grâce à l’envoi d’un 1 logique sur la fonction STOP.

Sur le panel, nous spécifions le chemin du fichier et affichons ses 10 valeurs et les

affichons dans le graphe Waveform Chart. Nous récupérons aussi le chemin du fichier ainsi que le commentaire spécifié lors de l’écriture de ce fichier.

III. Fichiers binaires

III.1. Sauvegarde dans un fichier binaire

Dans ce VI, nous nous proposons de sauvegarder, dans un fichier binaire, une dizaine de valeurs d’un sinus que l’on programme à l’aide du bloc Noeud d’expression de la palette Numérique.

Partie I / Apprentissage de LabVIEW

408

Nous ajoutons à ce sinus un bruit uniforme.

Avant d’écrire le fichier, la fonction File Dialog permet d’entrer le nom du fichier .dat dans le répertoire qu’on choisit.

On ouvre ensuite le fichier et on sauvegarde les mesures dans un fichier binaire. On ferme le fichier une fois les mesures sauvegardées.

Ces mesures sont tracées dans Waveform Graph et affichées dans le tableau Mesures. Dans le panel, on trace et on affiche les valeurs sauvegardées dans le fichier binaire.

Chapitre 11 / Les entrées/sorties sur fichier

409

III.2. Lecture d’un fichier binaire

Avant d’ouvrir le fichier et de le lire, nous spécifions son nom, BinaryFile.dat. On ouvre le fichier en précisant qu’on effectue uniquement la lecture (read-only). Nous calculons la taille du fichier, en octets, par la fonction Obtenir la taille du fichier. On divise cette taille par 8 pour obtenir le nombre d’octets, le quotient est appliqué à l’entrée nombre de la fonction Lire un fichier binaire.

Le même chemin se propage dans toutes les fonctions. Nous utilisons un réel double pour spécifier le type de données. On finit par fermer le fichier par la fonction Fermer le fichier. Le tableau de sortie est affiché dans le tableau données et tracé dans le graphe Graphe.

Les données sauvegardées sont parfaitement les mêmes que celles qu’on a lues.

Partie I / Apprentissage de LabVIEW

410

IV. Fichiers de waveforms

Les fonctions d’écriture et de lecture de fichiers waveforms se trouvent dans la sous-palette E/S sur fichier de waveform. Le VI Export Waveforms to Spreadsheet File.vi permet de convertir un tableau 2D ou 1D de nombres en une chaîne de texte et écrit la chaîne dans un nouveau fichier à flux d'octets ou ajoute la chaîne à un fichier existant.

IV.1. Ecriture et lecture dans une séquence déroulée

Dans le diagramme suivant, nous utilisons une structure séquence déroulée avec 3 étapes qui se déroulent l’une après l’autre.

Dans la première étape, nous enregistrons une waveform (forme d’onde) dans le fichier fichier_waveform sur le bureau (Desktop).

La deuxième séquence permet de lire ce fichier et afficher sur le panel les valeurs de ces 2 waveforms.

Lors de la troisième séquence, nous testons l’égalité de ces waveforms.

Chapitre 11 / Les entrées/sorties sur fichier

411

La LED Egal affiche 1 (couleur verte) lorsque tous les éléments des 2 tableaux sont égaux.

Sur ce panel, nous avons spécifié la formule qui permet de générer la waveform qu’on enregistrera et qu’on lira ensuite pour comparaison.

IV.2. Lecture et écriture dans une séquence empilée

Dans le diagramme suivant, l’écriture et la lecture du fichier se font dans une structure séquence empilée.

Partie I / Apprentissage de LabVIEW

412

Dans la séquence 0, on écrit la waveform dans le fichier fichier.lvm.

La séquence 1 ne comporte qu’une temporisation de 1 s. Dans la séquence 2, la waveform qu’on lit est transférée à la séquence 3 pour affichage à

travers une variable locale de séquence.

IV.3. Export de la waveform dans un fichier tableur

Dans le diagramme suivant, nous avons une séquence déroulée avec 3 étapes. Dans la 1ère, nous enregistrons la waveform dans le fichier journal

fichier_waveform.txt. Nous pouvons également le faire en .dat. Dans la 2ème étape, nous lisons ce fichier que nous exportons dans le fichier tableur

fichier_tableur.xls, le format d’Excel. Nous utilisons un cluster d’erreur en entrée du générateur de la waveform et un cluster en

sortie du VI Export Waveforms To Spreadsheet File.vi.

Chapitre 11 / Les entrées/sorties sur fichier

413

Nous avons tracé la waveform qu’on a lue dans la 2ème étape de la séquence.

En ouvrant le fichier fichier_tableur.xls, nous avons 1000 valeurs dont nous affichons les quelques premières valeurs suivantes :

Partie I / Apprentissage de LabVIEW

414

IV.4. Export de 3 waveforms

On se propose de réaliser un sous-VI qui permette de générer 3 waveforms différentes afin de les utiliser dans l’exportation de fichiers waveforms vers des fichiers de type tableur.

IV.4.1. Sous-VI générateur de 3 waveforms

La 1ère waveform est générée par la formule contenue dans la chaîne de caractères formula, définie sur la face-avant par sin(w*t)*sin(2 t). La 2nde est formée d’un signal gaussien centré dont on fixe l’écart-type sur la face-avant. La 3ème waveform est le signal de sortie d’un filtre FIR (Réponse Impulsionnelle Finie) de

type passe-bas d’ordre 12 dont on spécifie les caractéristiques fréquentielles des bandes, passante et coupée.

Le signal d’entrée du filtre est une waveform carrée dont la fréquence est spécifiée dans

le panel, de fréquence 10 Hz. L’ensemble de ce programme est transformé en sous-VI que nous utilisons ci-après. Le panel de ce sous-VI montre la formule de la 1ère waveform, l’écart-type du bruit

gaussien de la 2ème waveform, les caractéristiques du filtre : les gains des bandes, passante et coupée, ainsi que le choix de la fenêtre de Hamming pour limiter le nombre d’échantillons de réponse impulsionnelle.

Le graphe montre le signal carré et son équivalent filtré par le filtre FIR.

Chapitre 11 / Les entrées/sorties sur fichier

415

Dans le diagramme suivant, nous indexons le tableau de sortie du sous-VI « sous_VI_3waveforms.vi » pour récupérer les 3 waveforms dont nous décalons deux d’entre elles avec les offsets de 2 et -2.

Dans le panel correspondant, nous affichons la formule qui génère la 1ère waveform, la fréquence du signal carré qui sera filtré par le filtre FIR pour former la 3ème waveform, l’écart-type du bruit formant la 2ème waveform.

Nous visualisons les 3 waveforms décalées ainsi que leurs valeurs numériques dans le graphe ainsi que dans les afficheurs de waveforms.

Nous affichons également la formule formula ainsi que la fréquence du signal et l’écart-type du bruit.

En sortie du sous-VI nous obtenons un tableau de waveforms qu’on indexe pour obtenir les 3 wavefoms dont on récupére le signaux temporels Y qu’on assemble en tableau à des fins d’affichage.

Partie I / Apprentissage de LabVIEW

416

IV.4.2. Export d’un tableau de waveforms

Le programme suivant concerne l’export d’un fichier waveform en fichier tableur qu’on peut lire dans Excel, par exemple.

Nous considérons le vecteur de 3 waveforms que l’on sauvegarde sous le nom « fichier_waveform » dans la première étape de la structure Séquence déroulée. Dans la deuxième séquence, nous lisons ce fichier waveform et affichons uniquement la première waveform.

Dans la troisième étape, nous utilisons le VI « Export Waveforms To Spreadsheet File (1D).vi » pour transformer le fichier waveform en fichier tableur. Ce fichier tableur de nom « 3waveforms.xls » est un fichier de type Excel. S’il y a une

Chapitre 11 / Les entrées/sorties sur fichier

417

erreur en sortie des VIs, l’élément status, du cluster error out, vaut 1 et permet de quitter le programme.

Dans le fichier xls, nous affichons les valeurs et traçons les courbes des waveforms.

Toutes les waveforms commencent au même instant t0=0 et sont échantillonnées avec une période de 1 ms.

V. Fichiers TDMS

V.1. Utilisation des VI Express

Partie I / Apprentissage de LabVIEW

418

Ce sont les mêmes VIs qui permettent d’écrire et de lire les fichiers LVM.

Ce format de fichier a été défini par National Instruments. TDMS vient de « Technical Data Management Streaming » pour gestion de données de mesures. Ce format de fichier binaire n’est pas supporté par Excel.

Nous générons un bruit gaussien centré réduit (moyenne nulle et écart-type unité) grâce au VI Gaussien White Noise Waveform de type waveform.vi de la sous-palette Traitement du signal Génération de waveforms Wfm gauss.

La fenêtre de dialogue du VI Express de sauvegarde de fichier TDMS est la suivante.

Chapitre 11 / Les entrées/sorties sur fichier

419

On spécifie le fait que le fichier créé écrase le fichier existant de même nom, qu’il existe un en-tête et une colonne temps.

En haut, à gauche nous spécifions l’emplacement du fichier ainsi que son nom avec l’extension .tdms.

Dans le panel, nous affichons les clusters d’erreur d’entrée et de sortie, les valeurs du signal (cluster signal en sortie), la valeur spécifiée de l’écart-type, le commentaire ainsi que le graphe temporel du bruit gaussien.

Nous allons relire ce fichier, tracer les valeurs lues et les comparer à celles du fichier sauvegardé. Pour cela, nous allons utiliser la structure séquence déroulée.

Dans la 1ère étape, nous lisons le fichier fichier_tdms.tdms qui se trouve dans le bureau. Dans la 2ème étape, le signal après le passage en type DBL (réel double) à partir du type dynamique, est affiché dans un graphe et dans le tableau Array. La LED EOF ? s’allume lors qu’on atteint la fin du fichier (End of File) qui a été entièrement été lu.

Partie I / Apprentissage de LabVIEW

420

Dans le panel, nous retrouvons parfaitement les mêmes valeurs du fichier enregistré et ainsi que la nature gaussienne du bruit. Sa moyenne est quasiment nulle et son écart-type proche de l’unité.

V.2. VIs de la sous-palette TD en continu

Les VIs de la sous-palette TDM en continu sont les suivants :

Chapitre 11 / Les entrées/sorties sur fichier

421

V.2.1. Ecriture de fichiers TDMS

Choix du nom de fichier et de son répertoire

On choisit d’enregistrer le fichier Sinc_périodique.tdms dans le répertoire de données par défaut des applications LabVIEW (LabVIEW Data) grâce à la fonction Composer un chemin à laquelle on applique le répertoire par défaut et le nom du fichier TDMS.

Ouverture du fichier TDMS

Partie I / Apprentissage de LabVIEW

422

On applique le chemin composé et on spécifie l’option create or replace pour créer ou remplacer le fichier TDMS.

Ecriture du fichier TDMS

On décide d’enregistrer un tableau à 2 colonnes, 128 valeurs, d’un motif Sinus cardinal et d’un bruit gaussien d’écart-type unité.

Nous avons un seul groupe nommé Signaux Sinc Bruit et 2 voies, Sinus

cardinal et Bruit gaussien. Nous spécifions une amplitude de 2 et un nombre de passages par zéros de 10 pour le motif

du sinus cardinal. Pour obtenir un tableau 2D, nous utilisons la fonction Construire.

On ferme ensuite le fichier avec la fonction TDMS – Fermer.

TDMS – Viewer

TDMS – Viewer permet d’afficher les valeurs du fichier, pour chacune des voies ou toutes les voies du groupe.

Dans l’exemple suivant, on sélectionne le groupe et nous affichons toutes les courbes (2

dans notre cas) de ce groupe. TDMS-Viewer a besoin uniquement qu’on spécifie le nom chemin

« C:\Users\mohand\Documents\LabVIEW Data\Sinc_périodique.tdms ». Nous affichons les courbes du sinus cardinal et du bruit gaussien.

Chapitre 11 / Les entrées/sorties sur fichier

423

Dans l’onglet Valeurs (table), nous affichons les valeurs des 2 voies, Sinus cardinal et Bruit gaussien du groupe Signaux Sinc Bruit.

Dans l’onglet Propriétés, nous affichons les propriétés suivantes :

- la valeur NI_ArrayColumn, soit la colonne 0 du premier signal, - NI_ChannelLength, soit la taille 128 du canal, - NI_DataType, 10 pour le type décimal.

Partie I / Apprentissage de LabVIEW

424

Pour lire un fichier TDMS par Excel, il est nécessaire de disposer de « Complément

Excel TDM pour Microsoft Excel ». Pour ouvrir un fichier TDMS par Excel, nous cliquons droit sur ce fichier et nous choisissons Ouvrir avec Excel Importer.

Nous obtenons 2 feuilles, la 1ère pour la documentation (propriétés) et l’autre pour les

valeurs qu’on peut traiter temps différé.

Nous pouvons enregistrer sous le nom par défaut Book.xls.

Chapitre 11 / Les entrées/sorties sur fichier

425

V.2.2. Lecture de fichiers TDMS

La lecture du fichier TDMS se fait par la fonction TDMS-Lire. Comme pour son écriture, on compose le chemin du fichier, on ouvre ce fichier et on termine par sa fermeture.

Dans ce VI, on récupère la waveform de sortie qu’on indexe 2 fois et dont on sort le contenu Y qu’on assemble sous un tableau 2D. On trace ce tableau dans Graphe et on affiche ses valeurs dans tableau ajouté après qu’on ait transposé le tableau 2D.

Le tracé et le tableau de valeurs sont donnés dans le panel suivant.

V.2.3. Propriétés d’un fichier TDMS

On peut obtenir les contenus d’un fichier TDMS enregistré sur disque, les noms des groupes et ceux des propriétés.

Dans le diagramme suivant, on commence par ouvrir une boite de dialogue pour choisir le fichier TDMS pour lequel on désire obtenir les propriétés.

Grâce au VI TDMS-Obtenir des propriétés, on obtient la valeur « Sinc périodique » qui est le nom du groupe.

Partie I / Apprentissage de LabVIEW

426

Par le VI TDMS-Répertorier le contenu, on obtient d’une part les noms des groupes et ceux des groupes et des voies. On finit par fermer le fichier.

Dans le panel, nous retrouvons le nom du groupe Signaux Sinc et les 2 voies, Sinus cardinal et Bruit gaussien.

V.2.4. Création de groupes et propriétés pour un fichier TDMS

Création de fichier à 2 Groupes à plusieurs voies

Dans le diagramme suivant, nous enregistrons un fichier TDMS à 2 groupes, Groupe 1 à 3 voies et Groupe 2 à 2 voies. Pour Groupe 1, nous avons les propriétés suivantes :

Chapitre 11 / Les entrées/sorties sur fichier

427

On fait de même pour Groupe 2 avec ses noms de propriétés, Signal SBPA et Bruit uniforme avec leurs valeurs tension et courant.

On écrit les valeurs de Groupe 1 comme étant celles du sinus, triangle et carré de même fréquence 10 Hz et de même amplitude unité. On finit par fermer le fichier.

Les 2 voies de Groupe 2 contiennent le signal Signal avec Bruit gaussien et

Bruit Gaussien autour d’une valeur continue de valeur nulle.

Lecture de fichier à 2 Groupes à plusieurs voies

Après l’ouverture de la fenêtre de dialogue dans laquelle nous validons le nom et l’emplacement du fichier, nous le lisons et le fermons et nous faisons appel à l’afficheur TDMS-File Viewer.vi.

Partie I / Apprentissage de LabVIEW

428

Dans le viewer, nous sélectionnons l’ensemble des groupes et nous obtenons tous les noms et toutes les valeurs des propriétés.

Ci-dessous, nous affichons les noms et les valeurs de propriété.

En sélectionnant Groupe 1 et l’onglet Valeurs (table), nous affichons les valeurs des signaux Triangle et Carré.

L’onglet Valeurs analogiques (graphe) trace les courbes des 3 signaux de

Groupe 1. Dans l’afficheur de fichier, nous visualisons les groupes ainsi que leurs signaux. Dans le

cas de l’affichage suivant, nous visualisons le groupe 1 et affichons l’ensemble de ses signaux.

Chapitre 11 / Les entrées/sorties sur fichier

429

VI. Export de données de LabVIEW vers Excel

En plus des méthodes utilisées précédemment, nous pouvons en utiliser d’autres pour passer des données de LabVIEW à Excel.

VI.1. Menu Exporter par un clic droit

L’export des données vers Excel peut se faire par un clic droit sur la courbe. Pour sélectionner la waveform n°1, on indexe le tableau de waveforms de sortie, avec 0

comme index. Dans le diagramme précédent, nous avons utilisé le sous-VI générateur de 3 waveforms

dont on indexe le signal la sortie. Nous avons créé un noeud de propriété lié à la commande fréquence spécifiée dans le

panel sous la forme d’un bouton rotatif. Les propriétés (minimum, maximum, incrément) sont spécifiées par les commandes équivalentes du panel. Le cluster d’erreur en sortie du sous-VI passe à travers ce nœud de propriété.

Partie I / Apprentissage de LabVIEW

430

En pointant la courbe du signal de la waveform n°1, on peut exporter les données vers Excel en choisissant l’option Exporter Exporter les données vers Excel à partir du menu local obtenu par un clic droit sur la courbe.

Excel s’ouvre sur les valeurs exportées. Nous avons les colonnes Temps et Amplitude. Dans ce panel, les limites, basse et haute, ainsi que l’incrément du bouton fréquence.

Chapitre 11 / Les entrées/sorties sur fichier

431

Cet export peut se faire aussi par un clic droit sur un tableau de valeurs, comme celles de la première waveform. Cette méthode d’export peut se faire de n’importe quel graphe, graphe déroulant, table, tableau ou commande de données numériques. En modifiant les limites des échelles de l’abscisse X, on modifie le nombre des valeurs affichées et ainsi n’exporter que ces dernières sélectionnées. Quant aux tableaux, ils exportent la totalité des valeurs qu’ils contiennent.

VI.2. Utilisation d’un nœud de méthode

On crée un nœud de méthode qu’on lie au scope waveform1. On sélectionne ensuite la méthode Exporter les données vers Excel du menu local.

Partie I / Apprentissage de LabVIEW

432

Nous obtenons les mêmes résultats précédents dans une feuille Excel qui s’ouvre

automatiquement.

VII. Fichiers Zip

VII.1. Création d’un nouveau fichier Zip

Comme pour les fichiers TDMS, avant d’enregistrer un fichier sous sa forme compressée, on commence par créer un nouveau fichier Zip, ce qui équivaut à son ouverture. Nous avons besoin de connaître la cible, à savoir le nom du fichier Zip qu’on veut créer avec son emplacement.

Avec la constante F (Faux), on décide de ne pas confirmer l’écrasement d’un fichier existant avec le même nom.

Le fichier zip en sortie est similaire à un refnum ou un numéro identificateur ID. C’est ce même numéro qu’on utilise en entrée des VIs Add File to Zip.vi et Close Zip File.vi.

VII.2. Ajout du fichier Zip

La création du fichier revient à ajouter le fichier indiqué par le chemin du fichier source.

Ajoute le fichier indiqué par chemin du fichier source à un fichier zip.

Chapitre 11 / Les entrées/sorties sur fichier

433

Dans notre cas, nous désirons zipper le fichier de type Excel, Bachir.xlsx. Ce fichier se trouve dans le bureau (Desktop).

Le chemin du fichier source est alors : :\Users\mohand\Desktop\Bachir.xlsx.

Le chemin de destination dans le zip correspond au nom du fichier à zipper, soit : Bachir.xlsx.

VII.3. Fermeture du fichier Zip

Comme pour les fichiers TDMS, on finit toujours par fermer le fichier ouvert, grâce au VI Close Zip File.vi. Le VI Strip Path renvoie le nom de la dernière composante d'un chemin et le chemin raccourci qui conduit à cette composante.

Ce VI donne comme résultat « Bachir.xlsx » à partir du fichier source

« C:\Users\mohand\Desktop\Bachir.xlsx ». On transforme ce résultat chemin en chaîne de caractères et on récupère sa longueur grâce à

la fonction Array Subset qui renvoie un sous-tableau qu’on remet sous la forme de chemin grâce à la fonction Tableau de chaînes en chemin.

Nous créons alors un fichier Zip dans le bureau comme nous l’avons spécifié.

Les fichiers d’origine et son équivalent zippé sont les suivants et se trouvent sur le bureau.

Partie I / Apprentissage de LabVIEW

434

VIII. Fichiers XML

La langage XML (pour Extensible Markup Language) est un langage balisable extensible. Il est extensible car il permet d’inclure plusieurs langages.

Il est balisable car il contient les chevrons « < > » à l’intérieur des quelques on trouve des balises. Ce type de langage a été créé pour faciliter l’échange entre plusieurs systèmes d’informations.

VIII.1. Ecriture des fichiers XML

Nous générons 2 signaux que nous désirons enregistrer dans un fichier XML. Le nœud MathScript génère le sinus cardinal sinc(x) avec x allant -3 à +3 . La fonction Aplatir en XML permet de convertir des données de n'importe quel type, appliquées à l’entrée « « données quelconques » en une chaîne XML selon le schéma XML de LabVIEW.

Les 2 chaînes obtenues, à partir des 2 signaux, sont concaténées et la chaîne obtenue est appliquée à l’entrée Entrée XML du VI Write to XML(string).vi qui enregistre le signal dans un fichier XML. Nous décidons d’enregistrer ce fichier dans le répertoire courant des données (LabVIEW Data) avec le nom fichier.xml.

En sortie, nous récupérons l’emplacement dans la sortie XML File Path(duplicate). La chaîne XML est obtenue dans XML String.

Dans le panel, nous affichons les 2 courbes du sinus cardinal et du bruit uniforme. Dans la

chaîne XML, nous reconnaissons les balises du langage XML entre 2 chevrons. <Cluster> :les données de la chaîne XML sont dans un cluster à 3 éléments. <Name></Name> : le cluster n’a pas de nom

Chapitre 11 / Les entrées/sorties sur fichier

435

<NumElts>3</NumElts> : 3 éléments du cluster <DBL> : type double <Name>t0</Name> : temps initial t0 <Val>0.00000000000000</Val> : valeur de t0=0 </DBL> <DBL> <Name>dt</Name> : variable dt <Val>0.10000000000000</Val> : valeur dt=0.1 </DBL> <Array> : tableau <Name>y</Name> : nom du tableau <Dimsize>601</Dimsize> : dimension du tableau de 601 valeurs <DBL> <Name></Name> <Val>-3.28350493402542E-2</Val> : 1ère valeur du tableau y </DBL> <DBL> <Name></Name> <Val>-3.20027878597894E-2</Val> : 2ème valeur du tableau y </DBL> Toutes les valeurs du tableau sont affichées dans la chaîne XML. Il y a toujours une balise

ouvrante et une balise fermante. Dans le panel, nous affichons la chaîne XML, le tableau Y et le cluster d’origine, nommé

cluster de sortie. Nous affichons également le chemin du fichier XML, obtenu en sortie du VI Write to XML.

Partie I / Apprentissage de LabVIEW

436

VIII.2. Lecture des fichiers XML

Nous allons lire le fichier précédemment enregistré. Après avoir défini le répertoire courant et le nom de fichier fichier_XML.xml, la lecture du fichier XML se fait à l’aide du VI Read From XML File.vi. La chaîne retournée est affichée dans la chaîne XML Elements. C’est un tableau à 2 éléments correspondants aux 2 signaux de l’enregistrement.

Nous décidons d’étudier uniquement le 1er élément en indexant ce tableau de chaînes en spécifiant la valeur 0 de cet index ; ce qui correspond au sinus cardinal. La chaîne résultante de l’indexation est affichée dans la chaîne valeur.

On passe du type de données de XML à celui de LabVIEW en précisant le type de données, un cluster à 3 éléments, 2 doubles 0 et 0.1 pour t0 et dt et un tableau de doubles, pour les valeurs du tableau Y.

Nous désassemblons ce cluster, qu’on affiche dans valeur, pour récupérer les variables

t0, dt et le tableau Y qu’on affiche dans Tableau et traçons dans Graphe. Nous affichons le répertoire où se trouve le fichier, les différentes chaînes XML ainsi que

le graphe du sinus cardinal.

Chapitre 11 / Les entrées/sorties sur fichier

437

IX. Stockage de données sous différents formats

Les VIs de la palette Stockage/DataPlugin permettent de gérer différents types de fichiers : tdm, tdms, lvm, etc. Il y a les VIs d’ouverture, lecture, écriture et fermeture mais on peut aussi définir et obtenir les propriétés comme les VIs concernant les fichiers TDMS.

IX.1. Ecriture avec les VIs de stockage de données

IX.1.1. Ouverture, création d’un nouveau fichier

On ouvre le fichier de type TDMS sous le nom Mesures.tdms. des fichiers de données avec différents formats de stockage pour la lecture ou l'écriture.

Partie I / Apprentissage de LabVIEW

438

Avec le VI de type Express Ouvrir un stockage on peut ouvrir et ou créer un fichier. Avec la constante de type Enumération, on choisit l’option create pour créer un nouveau fichier TDMS.

Le refnum de stockage et le cluster d’erreur se propagent dans tous les VIs de la sous-palette.

IX.1.2. Définition des propriétés

Après exécution du VI suivant, on crée le fichier TDM suivant : C:\Users\mohand\Desktop\fichier_tdm.tdm

Ecriture du 1er groupe de données

Grâce au VI Ecrire des données [Groupe de voies], on écrit le groupe Mesures définies comme Mesures brutes avant filtrage par un filtre IIR (Réponse Impulsionnelle Infinie).

Ecriture des données du groupe

Grâce au VI Ecrire des données [Voie] on écrit 2 données du groupe : un signal carré auquel on ajoute un bruit blanc uniforme d’écart-type 0.5 et un signal triangulaire avec un bruit gaussien d’écart-type 0.2.

Ces signaux sont assemblés par le VI Assembler des signaux qui renvoie un signal qu’on applique à l’entrée Signal.

On fait de même pour le 2ème groupe et les 2 voies qui correspondent aux mesures brutes filtrées par un filtre passe-bas IIR de type Butterworth du 2ème ordre dont on définit, dans le panel, les valeurs des fréquences, haute et basse, de la bande passante ainsi que l’ondulation dans cette bande ainsi que l’atténuation de la bande coupée.

On finit par fermer le stockage.

Chapitre 11 / Les entrées/sorties sur fichier

439

En ouvrant le fichier dans Excel avec Excel Importer, nous obtenons le fichier xlsx

suivant dans lequel nous retrouvons le nom de la racine, à savoir Mesure de température & pression, dans l’onglet de même nom, ainsi que les noms des 2 groupes et les noms de chacune de leurs 2 voies. Nous avons aussi l’auteur, la date et l’heure de l’enregistrement.

Nous affichons, ci-après quelques valeurs du temps et des signaux filtrés qu’on trace dans

Excel. Nous retrouvons les mêmes courbes que dans le panel du VI de LabVIEW.

Dans le panel, nous retrouvons le cluster des paramètres du filtre, le chemin du fichier ainsi

que les courbes des mesures brutes et celles filtrées par le filtre IIR passe-bas de Butterworth.

Partie I / Apprentissage de LabVIEW

440

IX.2. Lecture avec les VIs de type Express

On applique l’option open à l’entrée fonction (Open : 0) du VI Express Ouvrir un stockage de données pour ouvrir le fichier TDM déjà enregistré et stocké dans le bureau (Desktop).

On lit d’abord le groupe de données avant de lire les voies. Le cluster d’erreur se transmet de VI en VI, de l’ouverture jusqu’à la fermeture du fichier. Le fait de placer le nœud de propriété avant le VI Fermer le stockage de données, permet de spécifier les limites, basse et haute, de l’axe avant de fermer le fichier.

Dans le panel, nous retrouvons bien les valeurs brutes de l’enregistrement dans le fichier

TDM.

Chapitre 11 / Les entrées/sorties sur fichier

441

X. Gestion des répertoires

La palette E/S sur fichiers possède des VIs qui permettent de gérer les répertoires.

Le VI Application Directory.vi renvoie le répertoire de l’application en cours à

savoir le répertoire Entrées/sorties sur fichiers. Dflt Data Dir.vi renvoie le répertoire des données par défaut permet d’afficher le

répertoire des données par défaut de LabVIEW, à savoir « C:\Users\mohand\Documents\LabVIEW Data ».

Partie I / Apprentissage de LabVIEW

442

Le chemin chemin VI actuel retourne le répertoire du VI actuel à savoir Gestion des répertoires.

Partie I. Chapitre 12 – Les graphiques

I. Le graphe déroulant II. Le graphe III. Personnalisation des graphes et graphes déroulants IV. Courbes de Lissajous IV.1. Graphe XY simple avec le graphe XY Express IV.2. Graphe XY simple avec le graphe XY IV.2.1. Courbe Image de la lettre α IV.2.2. Lemniscate de Bernoulli IV.3. Courbes de Lissajous dans Graphe XY multiple V. Graphe numérique VI. Graphes en 3D VI.1. Surface en 3D VI.1.1. Graphe de surface en 3D du panel VI.1.2. Palette graphisme et son du diagramme VI.2. Surface paramétrique 3D VI.3. Graphe mixte et numérique VII. Graphes spéciaux VII.1. Diagrammes à bâtons (stem) VII.2. Diagramme à barres VII.3. Diagramme en camembert VII.4. Courbes 3D VII.5. Contours

443DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _12,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

444 Partie I / Apprentissage de LabVIEW

Il existe 3 types principaux de graphes dans LabVIEW :

- le graphe déroulant qui affiche les courbes avec leurs valeurs dans le temps (point par point),

- le graphe qui affiche les courbes une fois que toutes leurs valeurs sont connues et mémorisées dans des tableaux,

- le graphe XY ou courbe paramétrique de Y en fonction de X. Ces graphes sont définis dans la face-avant ou panel d’un VI.

I. Le graphe déroulant

Pour utiliser le graphe déroulant, nous générons un signal aléatoire formé par la somme de

1000 variables aléatoires uniformes générées par la commande rand qui crée une variable aléatoire uniforme. Nous utilisons une boucle for dans un nœud MathScript. Le théorème central limites montre que la distribution de la variable ainsi formée tend vers une gaussienne.

Pour tracer l’histogramme, nous utilisons le VI Express « Créer un histogramme » de la palette « Palette probabilités et statistiques » du module Mathématiques.

Chapitre 12 / Les graphiques

445

Pour tracer l’histogramme, il suffit de positionner le pointeur de souris, sous forme de bobine, sur la sortie Signal et de choisir Créer Indicateur graphe.

Le graphe déroulant permet de tracer les valeurs instantanées du signal aléatoire.

Nous traçons, de la même façon, le signal de distribution uniforme, Histogram 2. Lorsqu’il y a erreur dans un des VIs, l’état (status) vaut 1. On sort de la boucle while

quand on appuie sur la commande stop du panel ou qu’une erreur survient dans l’un des VIs.

446 Partie I / Apprentissage de LabVIEW

Dans le panel, nous affichons les valeurs du signal uniforme dans le graphe déroulant. Les histogrammes montrent les distributions uniformes et gaussiennes.

Le cluster d’erreur montre qu’il n’y a aucune erreur dans tous les VIs.

II. Le graphe

Nous traçons dans ce graphe 3 signaux de type waveform. Pour chacun de ces signaux, nous récupérons la composante temporelle Y (signal) grâce à la fonction « Récupérer les composantes d’une waveform ».

Parmi ces signaux, nous avons un sinus cardinal, un sinus et un signal carré de rapport

cyclique de 80%. Une amplitude unité est commune aux trois signaux ainsi que la fréquence de 5 Hz. Le

sinus cardinal est généré grâce à la formule « formula » dans laquelle on applique la fonction sinc.

Le cluster d’erreur de sortie de chaque VI générateur est relié au cluster d’erreur d’entrée

du VI suivant jusqu’au cluster d’erreur de sortie du dernier VI qu’on affiche sur le panel. Le cluster d’erreur de sortie, error out, en fin de VI permet de fournir le code de

l’erreur (élément code), l’état (status ou état qui vaut 1 lorsqu’une erreur survient et 0 autrement) et le type de l’erreur (source) qui donne lequel des VIs qui est source de cette erreur.

L’état d’erreur en sortie lorsqu’il vaut 1, signifie l’existence de cette erreur. On l’utilise

alors pour arrêter le programme grâce à la fonction arrêter. Pour tracer les trois signaux, nous avons besoin de les assembler sous forme de tableau

grâce à la fonction Construire un tableau.

Chapitre 12 / Les graphiques

447

Dans le panel, nous affichons les paramètres spécifiés (fréquence, amplitude, rapport

cyclique) pour les signaux ainsi que le cluster d’erreur sortie d’erreur.

III. Personnalisation des graphes et graphes déroulants

Considérons le graphe suivant dans lequel nous traçons 2 courbes simultanément. Nous générons un signal par une formule définie dans une chaîne de caractères de

fréquence 10 Hz et un signal carré d’amplitude unité et de fréquence 5 Hz.

448 Partie I / Apprentissage de LabVIEW

Pour faire apparaître les éléments d’un graphe, on fait un clic droit sur le graphe et on

sélectionne l’option Eléments visibles. Dans cet exemple, nous sélectionnons tous les éléments qu’on peut rendre visibles pour un graphe.

La figure suivante résume quelques éléments du graphe : Dans l’exemple suivant, nous sélectionnons :

- la légende du tracé, - la légende des échelles, - la légende des curseurs, - etc.

Chapitre 12 / Les graphiques

449

Légende des tracés

La légende des tracés permet d’identifier chaque courbe du graphe.

Légende des échelles

A l’aide de la légende des échelles, nous pouvons spécifier la chaîne de caractères qui

définit les axes X et Y du graphique.

Curseurs

En cliquant droit à l’intérieur, nous pouvons créer un curseur.

450 Partie I / Apprentissage de LabVIEW

On peut créer un curseur libre qu’on peut déplacer à la souris sous forme de main ou un cureur qui suit la valeur du signal.

Dans cet exemple, nous avons créé un curseur libre et un curseur unique.

Si on sélectionne l’option Propriétés, nous obtenons la boite de dialogue suivante :

Chapitre 12 / Les graphiques

451

Nous retrouvons l’onglet Curseurs, dans lequel on peut choisir sa couleur, l’épaisseur du tracé, ses formes, la courbe auquel il appartient, etc.

Dans les autres onglets, nous résumons les propriétés qu’on peut modifier :

- Apparence : nous retrouvons les différents éléments qu’on peut afficher en cochant la case.

- Format d’affichage : choix du format, exemple virgule flottante à 4 chiffres après la virgule.

- Tracés : choix des propriétés de la ligne de chacune des courbes. - Echelles : choix de facteur d’échelle, échelle logarithmique, etc. - Documentation : édition d’un texte explicatif du tracé.

Echelles du graphique

Après un clic droit sur l’échelle des Y, si on choisit Dupliquer l’échelle, nous pouvons créer une échelle des Y propre à chaque courbe du graphique.

La courbe suivante, montre le résultat de la création de ces 2 axes.

452 Partie I / Apprentissage de LabVIEW

Si on choisit Permuter les cotés, les 2 axes Y sont placés chacun d’un coté du graphique.

IV. Courbes de Lissajous

IV.1. Graphe XY simple avec le graphe XY Express

Dans le diagramme suivant, nous générons des sinusoïdes par des VIs de la sous-palette

Génération de waveforms de Génération wfm. Les signaux de sortie sont des waveforms.

Chapitre 12 / Les graphiques

453

Le signal de type waveform ou forme d’onde est un signal de type cluster qui contient 3 éléments :

- t0, l’instant initial du signal, - dt l’intervalle de temps séparant 2 échantillons successifs du signal, - Y les valeurs du signal temporel.

Le type waveform est très important dans l’acquisition de mesures. Le VI Formula Waveform.vi génère un signal spécifié par la formule Formula. error out et error out2 sont les clusters d’erreur en sortie de ces VIs générateurs. La formule peut contenir les paramètres suivants :

f Fréquence d'entrée a Amplitude d'entrée w 2*pi*f N Nombre d'échantillons générés à l’instant courant t Nombre de secondes écoulées fé Fréquence d’échantillonnage en Hz

Pour récupérer le signal de la waveform, nous devons utiliser la fonction « Obtenir les

composantes d’une waveform » qu’on redimensionne à l’aide de la souris pour ne récupérer que la composante Y.

Lorsqu’on utilise un graphe XY Express sur le panel, le VI Express « Construire un graphe XY » apparaît automatiquement.

La composante Y est convertie en donnée dynamique par le VI « Convertir en données dynamiques ».

Dans le panel suivant, nous définissons les fréquences et les amplitudes de 2 sinusoïdes à

l’aide de glissières horizontales et verticales, traçons la courbe de Lissajous liant les 2 sinusoïdes et leurs courbes temporelles.

454 Partie I / Apprentissage de LabVIEW

IV.2. Graphe XY simple avec le graphe XY

IV.2.1. Courbe Image de la lettre α

On se propose d’utiliser le graphe XY de la palette Moderne Graphe Graphe XY. On considère les 2 courbes paramétriques suivantes :

)3cos(2)()2cos(3)(

ttyttx

avec t variant de 0 à 2 . On utilise pour cela une boucle For pour i variant de 0 à N. Pour obtenir les valeurs du

paramètre t, on utilise la relation

iN

t 2

On assemble les 2 courbes par le VI Assembler de la palette « Programmation

Cluster» avant d’appliquer la sortie au graphe XY. La boucle For de 100 itérations, est insérée dans une boucle While qu’on peut arrêter en

appuyant sur le bouton stop sur le panel. L’icône Graphe XY reçoit, sous forme d’un cluster, les 2 signaux x et y assemblés par la

fonction Assembler de la palette Classe, cluster et variant.

Chapitre 12 / Les graphiques

455

On obtient la courbe représentant la lettre grecque .

IV.2.2. Lemniscate de Bernoulli

La lemniscate de Bernoulli est définie par les expressions paramétriques suivantes :

4

3

4

12

12

tty

ttx

456 Partie I / Apprentissage de LabVIEW

Ces expressions sont spécifiées dans un tableau de chaînes de caractères formules dans le panel.

La chaîne de caractères Info contient des informations qu’on peut destiner au lecteur pour

expliquer l’intérêt et le fonctionnement d’un VI. Nous avons lié un nœud de propriétés à cette chaîne de caractères afin de la rendre visible

ou pas en utilisant la propriété Visible. Pour évaluer les chaînes de caractères du tableau formules en fonction du paramètre t,

nous avons utilisé le VI Eval X-Y(t).vi de la sous-palette Mathématiques Scripts et formules Evaluation 1D et 2D.

Ce VI évalue ces 2 chaînes pour des valeurs de t allant de la valeur start à end sur un

nombre de valeurs donné par la constante number of points. Le graphe XY est réalisé par le VI de type Express Construire un graphe XY de la

palette Graphe du panel. L’afficheur tops est le temps, en millisecondes, nécessaire pour analyser la formule et

produire le tableau des valeurs X et Y. Cette lemniscate a nécessité 374 ms.

Chapitre 12 / Les graphiques

457

IV.3. Courbes de Lissajous dans Graphe XY multiple

On se propose de tracer 2 courbes de Lissajous sur un même graphe XY. On génère 4 sinusoïdes par les VIs Sine Pattern.vi de la sous-palette

Traitement du signal Génération de signaux.

Dans le diagramme suivant, on trace les courbes de Lissajous entre la première sinusoïde et la deuxième et celle entre la troisième et la quatrième.

Les courbes X sont assemblées par le VI Assembler de la sous-palette Cluster. De même pour les courbes Y.

458 Partie I / Apprentissage de LabVIEW

Les clusters de sorties sont mis sous forme de tableau de clusters par le VI Construire

un tableau.

Les valeurs temporelles des 4 sinusoïdes sont tracées dans un même graphe. Dans le panel suivant, nous affichons les valeurs temporelles des 4 sinusoïdes ainsi que les

graphes XY de S1=f(S3) et S2=f(S4). Nous trouvons 2 ellipses différentes du fait de l’inégalité des amplitudes et les déphasages

des 4 sinusoïdes.

Chapitre 12 / Les graphiques

459

V. Graphe numérique

Ce graphe permet d’afficher des valeurs booléennes ou binaires des entiers qu’on applique en entrée.

Tableau de booléens est une représentation booléenne d’un nombre entier, ici codé

sur 8 bits. Ce tableau est obtenu en sortie du VI Nombre en tableau de booléens. Sur le panel, nous affichons ce tableau pour le 4ème chiffre du tableau d’entiers d’entrée.

Dans ce diagramme on construit une waveform en assemblant l’heure de début, l’intervalle

t et les nombres entiers que l’on désire afficher dans le graphe numérique.

460 Partie I / Apprentissage de LabVIEW

VI. Graphes en 3D

LabVIEW possède 3 types de graphes 3D :

- Surface 3D, surface dans l’espace 3D - Surface 3D paramétrique, surface complexe dans l’espace 3D - Courbe 3D, ligne dans l’espace 3D.

VI.1. Surface en 3D

VI.1.1. Graphe de surface en 3D du panel

Le VI qui permet de réaliser une surface en 3 dimensions se trouve dans la hiérarchie des sous-palettes suivantes :

Chapitre 12 / Les graphiques

461

Il apparaît ensuite le VI suivant dans le diagramme.

On se propose de tracer la surface donnée par l’expression suivante :

)sin(2 yyxz avec 55 x et 55 y .

Utilisation des VIs LabVIEW

Dans le diagramme suivant nous avons utilisé le même signal pour x et y. Nous avons utilisé une boucle for de 0 à 10. Pour faire varier les variables x et y de -5 à 5,

nous avons du enlever 5 à l’indice i de la boucle. La variable z est calculée dans une autre boucle For interne à la boucle For dans laquelle

on évalue les variables x et y. La variable z devient un tableau 1D en sortie de la boucle interne et un tableau 2D en sortie

de la boucle For principale. Comme les valeurs de la matrice z sont de type double, nous les transformons en entiers

non signés par la fonction U32 de la sous-palette Fonctions Numérique Conversion du diagramme.

462 Partie I / Apprentissage de LabVIEW

Ces 2 boucles For sont insérées dans une boucle while cadencée, avec le VI Temps d’attente, à 0.01s.

Cette boucle s’arrête quand on appuie sur le bouton stop ou l’apparition d’une erreur (le composant état ou status égal à 1 du cluster d’erreur de sortie du VI Temps d’attente. Le panel suivant représente le tracé 3D de la variable z.

Utilisation d’un nœud MathScript

Dans cet exemple, nous utilisons un nœud MathScript dans lequel nous définissons les

vecteurs x, y et la matrice Z.

Les vecteurs x et y sont des tableaux 1D, égaux et dont leurs valeurs s’étendent de -2 à 2

Chapitre 12 / Les graphiques

463

La commande meshgrid transforme le domaine défini par les vecteurs x et y en matrices X et Y qui permettent d’évaluer la matrice Z sur toutes les valeurs du domaine.

La boucle s’arrête si on appuie sur le bouton STOP ou si une erreur surgit dans le VI.

VI.1.2. Palette graphisme et son du diagramme

Avec la palette Graphisme et son avec laquelle nous pouvons tracer des graphes (surface, courbes, etc.) en 3D.

Nous disposons, sur le diagramme, de la palette graphisme et son, dans laquelle nous pouvons tracer des surfaces en 3D. Dans le diagramme suivant, le VI 3D Surface.vi trace les valeurs de la matrice Z sous forme d’une surface.

Cette matrice est définie par les valeurs du sinus spécifié en sortie du VI Sine Wave.vi sur 128 valeurs par défaut. Comme la boucle For possède 20 itérations, nous obtenons une matrice de 20 lignes et 128 colonnes.

464 Partie I / Apprentissage de LabVIEW

Dans le panel, nous obtenons la surface suivante qui varie selon le sinus jusqu’à ce qu’on

appuie sur le bouton STOP qui arrête l’exécution de la boucle While. Dans ce panel, nous affichons quelques valeurs de la matrice z ainsi que ses dimensions.

VI.2. Surface paramétrique 3D

Le bloc de surface 3D, se trouve dans la sous-palette Classique Graphe classique Par. 3D ActX.

Chapitre 12 / Les graphiques

465

Dans le diagramme et le panel, il apparaît les VIs suivants :

Ce VI permet de tracer une surface 3D paramétrique. Il accepte 3 matrices; les matrices x, y

et z qu’on veut tracer en fonction de x et y. L’entrée graphe 3D permet d’afficher la surface et de créer une référence à ce tracé. Cette référence peut être utilisée pour spécifier quelques propriétés comme le style de tracé et la transparence à l’aide Basic Properties.vi. Les propriétés de projection selon les 3 plans xz, xy et yz sont définies par le VI Projection Properties.vi. A chaque entrée, nous appliquons une commande qui affiche un bouton ON/OFF qui permet d’autoriser ou non une projection sur le plan considéré. Les grilles selon l’un de ces plans sont définies par Grid properties.vi. Ces 3 VIs utilisent la même référence 3D.

Nous avons créé 4 nœuds de propriété liés respectivement aux objets suivants :

Plot_style : style du tracé, Transparency : taux de transparence en pourcentage, xz projection : projection sur l’axe xz, 3D Parametric : nom et l’ID de classe.

466 Partie I / Apprentissage de LabVIEW

- affichage du choix fait dans le menu déroulant du mode d’affichage

- choix de la police Italique pour l’étiquette « projection xz » lorsque le bouton correspondant est visible.

Sa visibilité est commandée par le bouton Visible.

Clignotement de la partie centrale du bouton et de son afficheur numérique.

Valeurs min, max et incrément du taux de transparence.

Couleur du bouton (rouge). Cette couleur est spécifiée par la constante boite de couleur de la palette Dialogue et interface utilisateur.

- Police « Arial, gras Italique » du sous-titre

- Rend visible ou invisible, le bouton xz projection.

- nom de la classe du graphe.

- classe.

Dans le panel suivant, nous traçons la courbe avec ses projections sur les 3 plans.

Chapitre 12 / Les graphiques

467

Dans le cas du panel suivant, nous avons supprimé les grilles sur le plan xy en mettant à Off le bouton grille xy.

Grâce à la propriété Visible, nous avons rendu invisible le bouton projection xz. La présence ou non de cette projection garde la même valeur qu’avant la modification de

cette propriété. Dans le cas suivant, nous avons choisi le tracé des lignes de contours. Nous avons

uniquement la projection sur le plan xy (projection xy à ON).

VI.3. Graphe mixte et numérique

Un graphe mixte est utilisé pour tracer des signaux de différentes natures. Dans le diagramme suivant, nous traçons le signal de sortie du sous-VI sous forme d’une

matrice composée : - du signal déterminé par la formule : twtty 2sinsin)( , - d’un signal sinusoïdal, - d’un signal binaire pseudo aléatoire SBPA.

468 Partie I / Apprentissage de LabVIEW

Ce signal est tracé dans le graphe signal double. Dans la 2ème séquence déroulée, le VI Gaussian White Noise Waveform.vi

génère une waveform contenant des valeurs d’un bruit blanc gaussien d’écart-type 2. Chaque valeur de ce signal est convertie en numérique sur 8 bits grâce au convertisseur

Analog to Digital.vi de la palette waveform. Ce signal est tracé dans le graphe signal numérique.

L’afficheur Tableau de booléens est formé de bits de la 10ème valeur du signal gaussien.

Cette fois, la valeur numérique est obtenue en utilisant la fonction Nombre en tableau de booléens de la sous-palette Numérique Conversion. Cette valeur qui vaut 3 est affichée en binaire par les 2 dernières LEDs allumées (11).

Le signal numérique et le signal double sont affichés dans un graphe mixte. Les graphes,

numérique et mixte, se trouvent dans la palette Graphe du panel.

Chapitre 12 / Les graphiques

469

Dans le panel suivant, nous affichons le signal de type double dans un graphe et le signal numérique dans un graphe numérique. Ces 2 signaux de types différents sont affichés dans un graphe mixte.

VII. Graphes spéciaux

VII.1. Diagrammes à bâtons (stem)

Ce graphe appartient à la sous-palette Graphe 3D comme le montre l’arborescence suivante.

470 Partie I / Apprentissage de LabVIEW

Dans le diagramme suivant, nous traçons, sous forme de diagrammes à bâtons, les valeurs du tableau z en fonction de celles des tableaux x et y.

Le tracé se fait grâce au VI Plot Helper.vi de type Stem3. Il y a apparition des 2

blocs suivants dans le diagramme dès qu’on choisit le graphe Bâtons dans le panel :

Nous obtenons le graphe suivant dont les valeurs du tableau z sont représentées par des

bâtons aux abscisses x et y. Le graphe peut être sauvegardé dans un fichier sous forme d’une image bmp (bitmap).

Chapitre 12 / Les graphiques

471

L’icône de l’image bmp et son contenu sont représentés comme suit :

VII.2. Diagramme à barres

Les valeurs du vecteur ou matrice z définissent la hauteur des barres. Les valeurs de y définissent les coordonnées de ces barres. La longueur du tableau y doit être égale à celle de z. Dans la partie 1, les valeurs du vecteur z définissent la hauteur des barres tracées aux coordonnées donnés par le vecteur y.

Dans la partie 2, le tableau y n’est pas spécifié. Dans la partie 3, chaque ligne de la matrice

z est tracées aux indices donnés par le vecteur y.

472 Partie I / Apprentissage de LabVIEW

Dans le panel suivant, nous obtenons le tracé des barres dans les conditions définies précédemment.

VII.3. Diagramme en camembert

Dans le diagramme suivant, nous créons 10 valeurs aléatoires gaussiennes centrées d’écart-type unité. Ces valeurs sont réparties dans le graphe 3D sous forme de tranches de camembert. Les valeurs du vecteur offset définissent les valeurs du décalage de chaque tranche de camembert à partir du point central.

Chapitre 12 / Les graphiques

473

Dans ce panel, nous vérifions l’effet du décalage 5 de la 6ème tranche. Comme les valeurs sont aléatoires nous n’obtenons pas le même résultat à chaque fois.

VII.4. Courbes 3D

Dans ce diagramme, nous utilisons le VI create_plot_line.vi qui trace des lignes selon les coordonnées x, y et z en 3D.

Le panel affiche la ligne qui relie tous les points.

474 Partie I / Apprentissage de LabVIEW

En utilisant la commande plot3 du langage MathScript, les indices de z sont définies par

le vecteur dont les vecteurs sont définies linéairement entre -4 et 4 alors que celles de x et y varient sinusoïdalement entre 0 et 1.

VII.5. Contours

La fonction z(x, y) de la commande peaks du nœud ou de la fenêtre MathScript est donnée par l’expression suivante :

222253222 )1(exp31)(exp

501)1((exp)1(3 yxyxyxxyxxz

Chapitre 12 / Les graphiques

475

Nous utilisons directement cette commande dans un nœud MathScript pour lui appliquer les graphes 3D de surface, maillage et contours.

Dans le panel, nous retrouvons les graphes des surfaces, maillage et contours.

Partie II

Conception de contrôle et simulation

Partie II. Chapitre 13 - Simulation

I. La boucle de contrôle et simulation II. Signal Generation III. Signal Arithmetic IV. Lookup Tables V. Utilities VI. Graph Utilities VII. Continuous Linear Systems VII.1. Fonction de transfert et modèle d’état scalaire VII.2. Modèle d’état continu d’un double intégrateur VII.3. Modélisation d’un système masse-ressort avec frottements visqueux VIII. Discrete Linear Systems VIII.1. Régulation I avec une équation de récurrence VIII.1.1. Sous-système de simulation du modèle du processus VIII.1.2. Sauvegarde des résultats dans un fichier tableur VIII.2. Régulation PI d’un procédé décrit par un modèle d’état IX. Controllers X. Model Hierarchy – Spécification de paramètres et lecture de signaux X.1. Spécification de paramètres X.2. Lecture de signaux X.3. Spécification et lecture de paramètres XI. Estimation XI.1. Filtre de Kalman - Modèle continu du 1er ordre XI.2. Filtre de Kalman discret - Estimation d’une constante

477DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _13,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie II / Conception de contrôle et simulation

478

I. La boucle de contrôle et simulation

La boucle de simulation permet d’exécuter le diagramme de simulation jusqu’à ce que la durée spécifiée dans le nœud d’entrée (Input Node) soit atteinte ou que son arrêt soit réalisé par programmation par la fonction (Halt Simulation).

Les paramètres de simulation peuvent être spécifiés par un clic droit sur le bord de la

boucle de contrôle et simulation ou par un double clic sur le nœud d’entrée (Input Node).

Nous pouvons aussi tirer vers le bas, à la souris, le nœud d’entrée pour spécifier les

premiers paramètres. Un paramètre peut être ajouté ou supprimé.

Pour réaliser la simulation d’un système, analogique ou numérique, nous avons besoin de la

boucle de contrôle et simulation dans laquelle on insère des VIs de la palette Conception de contrôle et simulation.

Chapitre 13 / Simulation 479

Dans le nœud d’entrée, nous pouvons spécifier les paramètres de simulation : - instants, initial et final, - solveur (Runge-Kutta, Euler, …) - etc.

Dans cet exemple, nous appliquons un cluster d’erreur d’entrée (pas d’erreur), une durée

simulation de 100s et un solveur de type Runge-Kutta d’ordre 1 ou Euler.

En sortie, nous pouvons afficher le cluster d’erreur de sortie. En double cliquant sur le nœud d’entrée, nous obtenons la boite de dialogue suivante dans

laquelle nous pouvons spécifier les paramètres de simulation.

.

Partie II / Conception de contrôle et simulation

480

II. Signal Generation

Dans cette sous-palette, nous trouvons différents signaux utiles à la simulation, tels que l’impulsion, l’échelon, la rampe, le signal sinusoïdal, etc. Nous disposons également d’un générateur de signal et du temps de simulation.

Nous allons tracer plusieurs signaux que peut générer cette sous-palette dans un même

waveform graph, un signal carré, une rampe et une sinusoïde auquel on superpose un bruit.

La durée de simulation étant choisie égale à 140s, lorsque Simulation Time est plus

petit que 80s, le signal de sortie qui est affiché dans une waveform graph est une somme d’un signal carré et d’un bruit, lorsque cette condition est fausse, on fait la somme d’une rampe et d’une sinusoïde. Nous obtenons la courbe suivante.

Chapitre 13 / Simulation 481

III. Signal Arithmetic

Dans cette sous-palette, nous disposons des opérateurs arithmétiques tels que le gain, la somme, la soustraction ou le produit. Dans les systèmes de régulation, nous avons besoin de soustraire le signal de sortie du signal de consigne et peut-être d’un gain.

Dans le diagramme précédent, nous avons considéré une régulation proportionnelle, de gain égal à 2, d’un processus analogique du 1er ordre de constante de temps s1 et un gain statique unité.

Partie II / Conception de contrôle et simulation

482

IV. Lookup Tables

Dans cette sous-palette, nous trouvons des tables de correspondance.

Une table est une association de valeurs. Dans notre exemple, nous prenons le cas d’un

thermocouple qui associe des valeurs de tension thermoélectrique en mV à des valeurs de température en °C.

Nous considérons uniquement une partie de la table d’un thermocouple de type K, très utilisé dans l’industrie, correspondant à des températures allant de 0 à 100°C

Température (°C) Tension (mV) 0 0.000 10 0.397 20 0.798 30 1.203 40 1.612 50 2.023 60 2.436 70 2.851 80 3.267 90 3.682 100 4.096

En double cliquant sur le bloc Lookup Table 1D, nous remplissons le tableau des

tensions (LUT X) et celui des températures (LUT Data). Cette table permet de faire la correspondance, entre une valeur de tension et la valeur

correspondante de température, de différentes manières que l’on choisit dans le menu Method.

Lorsqu’on mesure une tension, l’équivalent température, on peut avoir la valeur :

- la valeur au-dessous de celle de la table si on choisit la méthode below, - celle au-dessus par above, - celle la plus proche (nearest), - valeur obtenue par interpolation, extrapolation par interpolate/extrapolate, - etc. La figure suivante montre les valeurs des entrées/sorties de la table, la courbe reliant la sortie à l’entrée ainsi que la méthode choisie qui est celle de l’interpolation/extrapolation.

Chapitre 13 / Simulation 483

Dans ce diagramme, nous avons étudié 3 cas ; celle où la valeur de la tension d’entrée

coïncide parfaitement à celle de la table. Dans le cas où la tension est la moyenne de 2 valeurs, la température est aussi la moyenne

des températures correspondantes. Dans le 3ème cas, nous avons spécifié une valeur de tension extérieure aux limites de la

table. Grâce à l’extrapolation, le résultat obtenu correspond à la valeur donnée par interpolation

linéaire.

Dans ce panel, nous affichons les tableaux des E/S de la table, la courbe de la table dans un

graphe XY ainsi que les valeurs, exacte, intermédiaire et par extrapolation. Nous avons utilisé des curseurs pour montrer ces différentes valeurs obtenues par la table.

Partie II / Conception de contrôle et simulation

484

V. Utilities

Dans cette sous-palette d’utilitaires, nous disposons du temps de simulation (disponible aussi dans Signal Generation), de l’utilitaire permettant l’arrêt de la simulation, l’affichage d’une erreur qui arrête la simulation, etc.

Dans ce diagramme, nous générons un signal Chirp. Lorsque le temps de simulation est

plus grand que 50 et que le signal est plus grand que 0.4, nous affichons l’erreur de code 12 qui arrête la simulation.

Chapitre 13 / Simulation 485

Le signal dépasse plusieurs fois la valeur 0.4, l’erreur n’apparaît que si le temps est aussi

plus grand que 50, soit la valeur 51 puisque le pas de temps est de 1. Le bloc Simulation Parameters permet d’afficher les paramètres de simulation. Ces paramètres ont été spécifiés soit en double cliquant sur le nœud d’entrée (Input

Node), soit en tirant vers le bas sur ce nœud.

Double clic

Tirage vers le bas

Ces paramètres sont, par exemple, le temps final, le pas de temps, le solveur utilisé (Runge-

Kutta d’ordre 1 ou Euler, RK 1), etc.

Partie II / Conception de contrôle et simulation

486

VI. Graph Utilities

Cette sous-palette comporte 2 utilitaires, graphe déroulant dans le temps et le graphe XY.

Dans l’exemple suivant, nous utilisons le waveform graphe pour tracer 2 signaux

temporels après en avoir construit un tableau par Build Array. Pour tracer le graphe XY, on assemble les 2 signaux sous forme d’un cluster par la fonction

Assembler.

Chapitre 13 / Simulation 487

Dans le graphe, on trace les 2 signaux dont le rapport des amplitudes est égal à 1.5 et celui des fréquences égal à 2. Dans le graphe XY nous obtenons une lemniscate.

VII. Continuous Linear Systems

Cette sous-palette contient les opérateurs, intégral et dérivée, la modélisation des systèmes continus par des modèles d’état, fonctions de transfert et sous la forme du gain, pôles et zéros.

Nous disposons également d’un régulateur PID, d’un observateur et filtre de Kalman continu.

Ces blocs peuvent avoir différentes représentations. On fait apparaître le menu local par un

clic droit sur le bloc et on choisit l’option Icon Style.

Partie II / Conception de contrôle et simulation

488

Nous avons 4 modes : Static, Dynamic, Text Only, Express. Le tableau suivant récapitule la forme du bloc selon chaque choix :

Static

Dynamic

Text Only

Express

Les blocs sont par défaut de type Static. Le nombre d’entrées et de sorties du bloc ne

varie pas selon sa forme. Le type Express semble être le plus complet. On tire vers le bas le bord bas de ce bloc afin de faire apparaître les libellés des différentes

entrées/sorties. Par défaut, le type Express possède cette forme :

Si on double clique sur ce bloc ou si l’on choisit l’option Configuration dans son

menu local (clic droit), on peut choisir Terminal pour Parameter source.

Dans ce cas, la fonction de transfert dans Preview ne reflète pas la fonction de transfert

ou le modèle d’état réel.

Chapitre 13 / Simulation 489

Dans ce cas, une autre entrée s’ajoute, en bas à gauche du bloc, qui permet de spécifier la

fonction de transfert ou le modèle d’état sans avoir à spécifier ses matrices A,B,C et D sa boite de dialogue. Nous allons pouvoir, à l’aide du nœud MathScript, spécifier directement la fonction de transfert ou le modèle d’état ou passer de l’un à l’autre.

Comme nous le remarquons avec ces blocs ci-dessous, la fonction de transfert ou le modèle d’état peut être spécifié à l’entrée supplémentaire :

VII.1. Fonction de transfert et modèle d’état scalaire

Dans le diagramme suivant, la fonction de transfert est spécifiée dans le nœud MathScript à l’aide de la commande tf qui a pour paramètres d’appel le numérateur et le dénominateur de la fonction de transfert. Le modèle d’état est obtenu par la commande ss qui a pour paramètres d’appel les matrices A, B, C et D du modèle d’état.

Partie II / Conception de contrôle et simulation

490

Nous avons choisi le cas d’un 2nd ordre optimal qui possède un meilleur temps de réponse et un modèle d’état du système du 1er ordre suivant :

puy

811

Ce qui donne le modèle d’état scalaire suivant :

8)(

8)()( tutxtx

Nous appliquons le même signal échelon à la fonction de transfert et au modèle d’état. Dans le panel, nous obtenons les réponses indicielles de ces 2 systèmes.

Nous pouvons également utiliser les VIs CD Construct Transfer Function Model.vi et CD Construct State-Space Model.vi.

Dans ce diagramme, nous avons considéré le même système du 1er ordre qu’on définit par sa fonction de transfert et par son modèle d’état.

Le numérateur, le dénominateur de la fonction de transfert, les matrices du modèle d’état sont définis comme des commandes et spécifiés dans le panel.

Chapitre 13 / Simulation 491

Les matrices scalaires de ce modèle du 1er ordre sont insérées dans un cluster qu’on désassemble dans le diagramme.

Nous obtenons la même courbe. Nous testons l’égalité des sorties de la fonction de transfert et du modèle d’état. Elles sont parfaitement égales puisque la LED s’allume.

Dans le diagramme suivant, nous réalisons la transformation de la fonction de transfert vers le modèle d’état et inversement.

Nous gardons les mêmes systèmes précédents.

Partie II / Conception de contrôle et simulation

492

Nous obtenons les mêmes courbes précédentes. La fonction de transfert est parfaitement la même que celle du système du 1er ordre de constante de temps s8 .

Si l’on choisit Reverse Terminals, le flux de données va de la droite vers la gauche,

ce qui facilite l’écriture des boucles de contre-réaction. Dans le cas, par exemple, d’une régulation PID d’un processus du 2nd ordre avec un capteur

qui possède une fonction de transfert du 1er ordre de constante de temps 2s et un gain statique 0.01, nous avons ceci :

VII.2. Modèle d’état continu d’un double intégrateur

Nous considérons le double intégrateur suivant qui peut représenter un volant d’inertie.

Chapitre 13 / Simulation 493

D’après ce schéma, nous pouvons écrire : )()( 1 txty )()( 21 txtx )()(2 tutx

Nous en déduisons les équations d’état et d’observation suivantes :

)()()()(10

)()(

0010

)()(

2

1

2

1 tuBtxAtxtutxtx

txtx

)()()()(

01)(2

1 txCtytxtx

ty

Dans la même sous-palette Continuous Linear systems, on trouve le bloc

Integrator, les modélisations par espace d’état et fonction de transfert d’un système continu. Nous appliquons le même générateur de signal sinusoïdal au double intégrateur, au modèle d’état et la fonction de transfert à des fins de comparer leurs sorties.

En double cliquant sur le bloc State-Space, nous obtenons la fenêtre de dialogue suivante dans lquelle nous pouvons spécifier les valeurs des différentes matrices d’état A, de commande B, d’observation C et de liaison directe D.

Nous précisons aussi la valeur de l’état initial.

Partie II / Conception de contrôle et simulation

494

En double cliquant sur le bloc Transfer Function, nous remplissons les polynômes en p du numérateur et du dénominateur par puissances ascendantes.

La prévusialisation de cette fonction de transfert se fait dans le cadre bas à gauche de cette

boite de dialogue. Nous appliquons, à l’entrée, un signal sinusoïdal de 1 Hz. Nous comparons, tout d’abord, le

signal de la suite des 2 intégrateurs et du modèle d’état, le résultat de cette comparsion est envoyé à la LED x=y ? qui s’allume lorsqu’il y a égalité.

La même comparaison se fait entre la sortie de Transfert Function et State

Space. Ensuite, nous prenons le ET logique ces résultats 2 à 2. La LED booléen se présente sous forme rectangulaire dans le panel. En exécutant ce VI, les 2 LEDs s’allument, démontrant que les sorties de ces 3

modélisations sont parfaitement équivalentes. Nous créons un nœud de propriété lié à l’oscilloscope qui suit les 2 intégrateurs dans lequel

nous définissons les valeurs, minimale, maximale et incrément des valeurs de l’échelle X. Nous relions ces valeurs à leurs propriétés équivalentes, appliquées au nœud d’entrée de la

boucle de contrôle et simulation.

Chapitre 13 / Simulation 495

Dans ce panel, nous affichons les 2 LEDs, le signal sinusoïdal d’entrée ainsi que la sortie des 2 intégrateurs. Nous constatons de lègères variations de même fréquence que la sinusoïde avec une tendance ascendante.

VII.3. Modélisation d’un système masse - ressort avec frottements visqueux

On considère un système mécanique constitué d’une masse M suspendue à un ressort de constante de raideur k soumis à un couple de frottement visqueux de coefficient f.

Nous considérons les valeurs numériques suivantes :

k=105 N m-1, M=10 kg, f=50 N/(m/s) Le principe fondamental de la dynamique donne :

)()()()(2

2

txkdt

xdftFdt

xdM

Avec les conditions initiales nulles, nous pouvons écrire :

)()()()(2 pXkpXpfpFpXpM

Partie II / Conception de contrôle et simulation

496

Nous pouvons ainsi obtenir la fonction de transfert, liant le déplacement x(t) à la force F(t) :

1

/1)()(

2 pkfp

kM

kpFpX

Nous modélisons ce système par une fonction de transfert continue, Tranfer

Function de la sous-palette Continuous Linear Systems.

Nous pouvons modéliser ce même système en utilisant le bloc intégrateur, integrator,

de la sous-palette Continuous Linear Systems et le gain, Gain, de Signal Arithmetic.

On peut aussi schématiser le système par un modèle d’état. Les variables d’état sont les

sorties des intégrateurs, comme suit :

Nous obtenons ainsi le modèle, à 2 variables d’état, suivant :

Les matrices d’état sont les suivantes :

Mf

MkA

10,

MB

/10

, 01C , 0D

Nous allons montrer que les 3 modélisations précédentes donnent le même résultat pour un

même signal de commande qui est la force appliquée au système. Le style de la fonction de transfert est choisi de type Express.

FM

txMftx

Mktx

txtx1)()()(

)()(

212

21

Chapitre 13 / Simulation 497

Les 3 modélisations donnent parfaitement les mêmes résultats.

VIII. Discrete Linear Systems

Dans cette sous-palette, nous trouvons l’équivalent discret de la sous-palette Continuous Linear Systems, à savoir les fonctions de transfert en z, le filtre de Kalman discret, l’intégrateur discret, le filtre discret, etc.

Partie II / Conception de contrôle et simulation

498

VIII.1. Régulation I avec une équation de récurrence

VIII.1.1. Sous-système de simulation du modèle du processus

Nous allons utiliser l’intégrateur discret et un gain pour réaliser la régulation. Le processus à réguler sera défini par une équation de récurrence qu’on déduit de sa

fonction de transfert en z. La fonction de transfert du processus à réguler est du 1er ordre suivant :

1

11

11

121

11

8.01)5.01(

1)()(

zzz

zazbbzzH

L’entrée et la sortie sont liées par l’équation de récurrence suivante :

)2(5.0)1()1(8.0)( kukukyky

Cette équation de récurrence est programmée en utilisant des retards et des gains.

On sélectionne l’ensemble de ces blocs et on crée un système de simulation par le menu

Edition créer un sous-système de simulation. On copie ce sous-système dans le VI de régulation et on lui donne le style Express par Icon style du menu local.

Le régulateur utilisé est un intégrateur pur discret. Nous avons inséré un gain de 0.2 pour régler la dynamique de poursuite.

Chapitre 13 / Simulation 499

Dans le panel, nous traçons, dans le même waveform Graph, les signaux de consigne et de sortie du processus. La sortie suit parfaitement la consigne, en régime permanent, du fait de la présence d’une intégration dans le régulateur.

VIII.1.2. Sauvegarde des résultats dans un fichier tableur

Dans le diagramme suivant, nous utilisons une structure séquence déroulée à 2 étapes. La première contient une boule de contrôle et simulation dans laquelle on reproduit le VI de la régulation par intégrateur discret, sans le waveform graph.

Nous sortons de cette boucle les signaux de consigne et de sortie du sous-système de simulation représentant le processus. Ces signaux sont accompagnés des valeurs du temps de simulation grâce au bloc Collector.

En dehors de cette boucle, nous désassemblons les clusters de sorties de ces blocs Collector pour récupérer les 2 signaux avec le temps de simulation.

Nous assemblons les signaux et le temps de simulation que nous appliquons au VI Write To Spreadsheet File.vi dans le répertoire spécifié par chemin.

On décide de ne pas transposer le tableau, ni d’ajouter les données dans un autre fichier de même nom.

Dans la 2ème étape, Nous lisons le fichier indiqué par le chemin chemin et nous affichons les valeurs dans le tableau 2D All Rows.

Nous indexons ce tableau pour récupérer la 1ère, 2ème et 3ème colonne. Nous traçons ces données dans un graphe XY.

Partie II / Conception de contrôle et simulation

500

Dans ce panel, nous trouvons la commande chemin, quelques lignes du tableau 2D et les mêmes courbes précédentes de consigne et de sortie du processus.

VIII.2. Régulation PI d’un procédé décrit par un modèle d’état

Dans ce cas, nous réalisons une régulation proportionnelle et intégrale PI d’un processus qu’on modélise par son modèle d’état discret.

En posant )()(1 kykx dans l’équation de récurrence définissant le processus et en faisant une avance d’un pas d’échantillonnage, nous obtenons :

)1(5.0)()(8.0)1( 11 kukukxkx

On pose )1(5.0)(2 kukx , soit après une avance : )(5.0)1(2 kukx . Nous avons alors le modèle d’état suivant :

)(5.0)1()()()(8.0)1(

2

211

kukxkukxkxkx

Les matrices d’état sont alors :

0018.0

A , 5.0

1B , 01C

On vérifie bien les valeurs propres de cette matrice qui sont les pôles du processus :

Chapitre 13 / Simulation 501

Nous allons faire la régulation PI discrète en utilisant ce modèle d’état pour représenter le processus.

Nous avons utilisé le modèle d’état stochastique discret mais les bruits de mesure et de

modélisation sont considérés de moyenne et variance nulles. Le régulateur PI, qui utilise les blocs Gain, Summation (sommateur) et Discrete

Integrator (intégrateur discret), possède l’expression suivante :

)1

11(4.0)(z

zD

Nous traçons, dans un même waveform graph, les signaux de consigne et de sortie du

processus. Dans un autre graphe, nous traçons les 2 variables d’état dont l’une d’elles, x1, correspond parfaitement à la sortie du processus et l’autre, x2, la moitié du signal de commande inversé. Les bruits de mesure et de modélisation sont de moyenne et de variance nulle.

Partie II / Conception de contrôle et simulation

502

Le panel représente les signaux de consigne et de sortie ainsi que les 2 variables d’état. Le signal de sortie coïncide parfaitement à la consigne, en régime permanent, après 3

oscillations en régime transitoire.

Nous allons comparer les réponses d’un modèle d’état, fonction de transfert et équation de

récurrence représentant le même processus. Nous considérons les 3 représentations suivantes du même processus.

- fonction de transfert :

)8.0(5.0

8.01)5.01()( 1

111

zzz

zzzzH

- modèle d’état :

0018.0

A , 5.0

1B , 01C

- équation de récurrence :

)2(5.0)1()1(8.0)( kukukyky

Chapitre 13 / Simulation 503

Nous appliquons à ces différentes modélisations le même signal sinusoïdal et nous retrouvons des signaux de sortie qui se superposent dans un même waveform graph.

IX. Controllers

Dans cette sous-palette, nous trouvons le bloc PID classique et le bloc SISO

Controller. Dans la boite de dialogue de ce régulateur, nous devons spécifier une valeur constante de la consigne, le gain, les pôles et les zéros de son modèle (fonction de transfert).

Partie II / Conception de contrôle et simulation

504

Nous avons imposé une consigne échelon de valeur 5, un pôle nul correspondant à l’intégration pure et un autre pôle égal à -10. Le gain a été choisi égal à 0.4 afin de limiter le nombre d’oscillations. Avec un gain de 1, nous obtenons 3 oscillations autour de la consigne mais un temps de réponse plus faible. Avec ce contrôleur, nous pouvons choisir n’importe quelle fonction de transfert, comme par exemple les régulateurs à avance de phase, retard de phase, etc.

En régime statique, l’erreur est nulle grâce à l’intégration. En boucle fermée, le système se comporte, approximativement, comme un circuit du 2nd ordre d’amortissement optimal.

X. Model Hierarchy – Spécification de paramètres et lecture de signaux

A l’aide du nœud Access Model Hierarchy, nous pouvons spécifier certains paramètres des blocs d’un système de simulation.

Considérons le modèle suivant d’une régulation d’un processus analogique par un

contrôleur PID analogique de la sous-palette Continuous Linear Systems.

Chapitre 13 / Simulation 505

Le processus est un système analogique du 1er ordre de constante de temps de 20s et de gain statique 0.5.

Le régulateur est un PID de type académique dont les paramètres sont choisis à Kc=1 et

Ti=10. La boucle de retour constitue la fonction de transfert du capteur. La consigne est un signal carré de la sous-palette Signal Generation.

Le panel suivant représente la courbe du signal de sortie du processus et la consigne. La sortie rejoint la consigne avec un seul dépassement.

On est amené à modifier les paramètres du régulateur pour régler le temps de réponse en

agissant sur les paramètres du PID. La poursuite de la consigne se fait avec un seul dépassement comme un second ordre de

coefficient d’amortissement optimal de 2/2

Partie II / Conception de contrôle et simulation

506

X.1. Spécification de paramètres

Nous pouvons modifier les paramètres du régulateur directement à partir du panel à l’aide du bloc Model Hierarchy.

En double cliquant sur ce bloc, on choisit les paramètres de la boucle de simulation que

l’on souhaite modifier à partir du panel. Chaque paramètre, désigné par accessor peut être, soit spécifié (set) ou lu (get). Nous allons modifier à partir du panel :

- le gain proportionnel Kc du PID, - la constante de temps Ti (gain intégral), - la période du générateur Pulse Signal.

Après avoir double cliqué sur le bloc Access Model Hierarchy, on obtient la boite de dialogue suivante :

Pour sélectionner le gain Kc du régulateur, nous choisissons le bloc PID dans Select a

function or subsystem. Ensuite, on choisit le paramètre Proportional Gain (Kc) auquel on donne la valeur par défaut de 1. On ajoute un paramètre en cliquant sur ‘+’.

Chapitre 13 / Simulation 507

Si on n’applique aucune valeur constante, le paramètre prendra la valeur par défaut qu’on a choisie dans la boite de dialogue. Dans notre cas, nous choisissons d’appliquer des commandes afin de régler les paramètres à partir du panel.

En choisissant un gain Kc=0.5 et une période du signal carré de 600s, nous obtenons n’avons pas de dépassement au détriment du temps de réponse.

Si l’on veut rajouter un paramètre, comme la fonction de transfert du processus, on tire vers

le bloc Access Hierarchy. On obtient l’apparition du 4ème paramètre Accessor 4.

En choisissant l’option Properties dans le menu local, nous ouvrons de nouveau la

boite de dialogue.

Partie II / Conception de contrôle et simulation

508

Nous choisissons Transfert Function avec sa valeur par défaut dans Parameter Value.

En modifiant la constante de temps du processus, le gain Kc du PID, nous obtenons les

résultats suivants :

X.2. Lecture de signaux

En choisissant l’option Properties du nœud de sortie de la boucle de simulation, nous obtenons une autre boite de dialogue comme celle du bloc Model Hierarchy.

Chapitre 13 / Simulation 509

Nous voulons tracer le signal de commande issu du régulateur PID et le signal d’erreur

(différence entre la consigne et la sortie du processus). L’erreur est calculée comme la différence entre le signal de sortie de la fonction Pulse Signal et la sortie de la fonction de transfert Transfert Function 2.

Pour récupérer le signal de commande, nous choisissons Open Subsystem dans le menu

local du bloc PID afin de visualiser les VIs qui le composent. Ainsi le signal de sortie du régulateur est la sortie du gain Proportional Gain (Kc) soit Gain.output.

Le diagramme général qui permet le choix des paramètres et la lecture des signaux est le

suivant.

Nous traçons ainsi, dans le même graphe, les signaux de commande et d’erreur.

Partie II / Conception de contrôle et simulation

510

X.3. Spécification et lecture de paramètres

Dans l’exemple suivant, nous allons spécifier les paramètres d’un régulateur PID et la période du signal carré de consigne.

Le paramètre proportionnel Kp sera lu par le même bloc Model Hierarchy avec lequel

les paramètres du PID ont été spécifiés. Nous considérons le régulateur PID suivant :

Nous désirons régler ces paramètres à partir du bloc Model Hierarchy. Pour modifier

les paramètres de ce régulateur, nous devons supprimer les connections sur les blocs.

Comme dans les exemples précédents, nous retrouvons les blocs Td, Ti et Kp dans la boite

de dialogue lorsqu’on choisit l’option Properties dans le menu local du bloc Model Hierarchy.

Chapitre 13 / Simulation 511

Nous voulons faire une recopie de la valeur du gain Kp. Pour cela, nous choisissons encore une fois ce même paramètre dans cette boite de dialogue mais en lecture (Get).

Pour pouvoir modifier la période du signal carré de consigne, nous choisissons le paramètre

period de Pulse Signal. Dans cet exemple, nous appliquons des valeurs constantes 1 et 0, respectivement pour Ti et

Td. Le gain Kp sera spécifié dans le panel. Ce même paramètre sera lu (Get) pour faire sa recopie.

Dans ce panel, nous vérifions que le même paramètre Kp spécifié et lu par le même bloc

Model Hierarchy.

Partie II / Conception de contrôle et simulation

512

Avec N=200, Kp=0,17 et une période de 150 du signal carré, nous obtenons les résultats

suivants avec un dépassement plus faible mais un temps de réponse plus élevé.

XI. Estimation

Dans cette sous-palette, nous trouvons le filtre de Kalman discret, déterministe ou stochastique, un observateur discret ou continu, etc.

Chapitre 13 / Simulation 513

XI.1. Filtre de Kalman - Modèle continu du 1er ordre

On considère le système continu du 1er ordre suivant :

)()(

1)( 0

tuty

pH

pH

Nous en déduisons l’équation différentielle qui relie la sortie à l’entrée :

uH

tyty 0)(1)(

En posant )()( txty , nous obtenons le modèle d’état continu suivant :

uH

txtx 0)(1)(

Si on considère un bruit de modélisation w et un bruit de mesure v , le modèle d’état

stochastique est alors :

vtxty

wuH

txtx

)()(

)(1)( 0

d’où les matrices 1A , 0HB , 1C et 0D , qui se réduisent à des scalaires.

On appliquera un signal carré à la commande u . On considère 10H et 10 s. Le modèle d’état continu est défini par le bloc Continuous Kalman Filter qu’on

affiche sous le style de type Express par le menu local de Icon Style et le choix Express.

On simule les valeurs de sortie bruitées par la sortie du modèle du premier ordre continu de

gain statique unité et de constante de temps s10 auquel on superpose un bruit gaussien centré et d’écart-type unité défini dans le panel.

Nous affichons ces mesures dans le waveform graph Mesures. Les entrées sont les sorties

du générateur Pulse Signal qu’on a appliquées au modèle du 1er ordre. Le modèle d’état est défini par le VI CD Construct Stochastic Model.vi dont

les matrices A, B, C, D, G et H sont spécifiées dans le panel. Les matrices G et H sont, respectivement, les matrices qui spécifient les bruits sur le modèle et sur la mesure.

)()()()()()()()()(

tvtwHtuDtxCtytwGtuBtxAtx

Les matrices de covariance de ces bruits sont données par les matrices Q et R spécifiées

dans le cluster constant Second-Order Statistics Noise Model.

Partie II / Conception de contrôle et simulation

514

Dans le panel, nous affichons la sortie bruitée et la sortie estimée par le filtre de Kalman.

Nous retrouvons, en sortie du filtre, des montées et descentes en exponentielles qui sont le régime transitoire du modèle du 1er ordre.

Le filtrage consiste à mettre à jour l’estimation de la sortie en ajoutant l’innovation qui est la différence entre la vraie mesure et celle estimée par le modèle d’état. Cette innovation est multipliée par le gain de Kalman. Ce gain de Kalman diminue avec le temps.

XI.2. Filtre de Kalman discret - Estimation d’une constante

Une grandeur, réputée constante, x est mesurée au moyen d’un capteur bruité. Le modèle d'état correspondant est alors

x(k)1)x(k

)v(kx(k)Cy(k) avec 1C .

Le bruit v est considéré blanc, gaussien et centré. Il n’y a pas de bruit de modélisation w .

4

0

R(k)Tvv(k)E

v(k)E

Chapitre 13 / Simulation 515

Nous utilisons le VI Discrete Kalman Filter.vi que nous transformons sous la forme Express avec Icon Style dans le menu local. Nous simulons les mesures en ajoutant un bruit gaussien à une valeur constante 5 que nous devrons approcher par le filtre de Kalman discret.

Dans le panel, nous affichons les mesures bruitées et la sortie estimée par le filtre de

Kalman. Nous avons, volontairement choisi les mêmes limites de l’axe Y pour des besoins de comparaison.

Le gain de Kalman chute brutalement pour se stabiliser à la valeur 0.0049. Nous obtenons

5.03 pour la valeur estimée de la constante 5.

Partie II. Chapitre 14 - Control Design

I. Model Construction (construction de modèle) I.1. Construction de fonctions de transfert I.2. Moteur à courant continu I.2.1. Réponse indicielle de la vitesse et du courant d’induit I.2.2. Régulation PI avec pondération de la consigne I.2.3. Filtre de Kalman – Estimation du courant d’induit et de la vitesse angulaire II. Model Information (information sur les modèles) II.1. Fonction de transfert constante, vérification et spécification de propriétés II.2. Modèle d’état constant III. Model Conversion (conversion de modèle) III.1. Conversion d’une fonction de transfert en modèle d’état III.2. Conversion modèle d’état discret en fonction de transfert III.3. Modèle d’état, fonction de transfert, pôles, zéros, réponse indicielle IV. Model Interconnection (Interconnexion des modèles) IV.1. Ajout de fonctions de transfert IV.2. Bouclage négatif (contre-réaction) V. Time Response (réponse temporelle) V.1. Fonction de transfert constante dans le diagramme V.2. Fonction de transfert définie dans un nœud MathScript VI. Frequency Response (réponse fréquentielle) VII. Dynamic Characteristics (caractéristiques dynamiques) VIII. State-Space Model Analysis (analyse dans l’espace d’état) VIII.1. Contrôlabilité et observabilité VIII.2. Modèles d’états similaires VIII.2.1. Similarité de 2 modèles d’état d’un système du 1er ordre VIII.2.2. Circuit RLC IX. Implementation IX.1. Réponse indicielle d’un processus discret du 1er ordre IX.2. Filtre de Kalman discret IX.3. Commande par retour d’état IX.3.1. Régulation autour de l’origine IX.3.2. Régulation autour d’une référence non nulle

517DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _14,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie II / Conception de contrôle et simulation

518

Ces blocs sont utiles dans le domaine du contrôle.

- retour d’état, - PID, - etc.

I. Model Construction (construction de modèle)

Dans cette sous-palette, nous trouvons des blocs permettant de construire:

- une fonction de transfert à partir de son numérateur et dénominateur, - un modèle d’état à partir de ses matrices A, B, C et D, - un régulateur PID, - un système du 2nd ordre avec spécification du coefficient d’amortissement, pulsation

propre et gain statique, - etc.

Nous pouvons également sauvegarder et lire un modèle à partir d’un fichier.

Ces différents blocs seront étudiés dans les applications qui vont suivre.

Chapitre 14 - Control Design

519

Les blocs de type CD Draw permettent d’afficher : - des fonctions de transfert sous forme d’un numérateur et dénominateur, ou sous forme

Zéro-Pôle-Gain, discrètes ou continues, - des modèles d’état continus ou discrets.

I.1. Construction de fonctions de transfert

Dans ce diagramme, nous construisons une fonction de transfert avec le VI CD Construct Transfer Function Model.vi à partir de son numérateur et son dénominateur. Le VI CD Draw Transfer Function Equation.vi permet d’écrire l’équation de cette fonction de transfert en utilisant l’opérateur p de Laplace.

Le VI CD Construct Special TF Model.vi permet de construire une fonction

de transfert du 1er ordre connaissant le gain statique et la constante de temps, ou celle du 2nd ordre à partir du gain statique, du coefficient d’amortissement et de la pulsation propre.

Nous définissons la fonction de transfert du 1er ordre sous forme du cluster Transfer

Function Model. Le VI Step Response.vi permet de tracer la réponse indicielle du système défini par cette fonction de transfert.

La fonction de transfert du 2nd ordre est construite à partir de son gain statique unité, du coefficient d’amortissement optimal (meilleur temps de réponse) et de sa pulsation propre w0=1 rad/s.

Dans le panel, nous spécifions et affichons le numérateur et le dénominateur de la fonction

de transfert du 1er ordre, de gain statique unité et de constante de temps s10 . Nous traçons sa réponse indicielle et nous constatons qu’il y a un seul dépassement autour

de la valeur statique 1. Nous affichons également l’équation de cette fonction de transfert du 2nd ordre optimal.

Partie II / Conception de contrôle et simulation

520

I.2. Moteur à courant continu

On considère moteur à courant continu schématisé par sa partie électrique de l’induit et mécanique du rotor.

Les parties, électrique et mécanique, sont régies par les équations suivantes :

wfdtdwJe

dtdiLiRu ,

La force électromotrice e et le couple sont, respectivement proportionnels à la vitesse de

rotation w et au courant d’induit i avec le même coefficient K .

wKe iK

Les variables d’état sont le courant d’induit et la vitesse de rotation dont les équations

d’état sont les suivantes. La commande est la tension u appliquée à l’induit.

uL

w

i

Jf

JK

LK

LR

dtdw

dtdi

0

1

Nous considérons les valeurs numériques suivantes :

K=0.0050 N.m/A R= 1 Ohm, L=0.120 H, f= 0.02 N.m/(rad/s), J=0.001 kg.m2

I.2.1. Réponse indicielle de la vitesse et du courant d’induit

Nous appliquons un échelon de 5V à l’instant t=0. Pour cela, un échelon unité, multiplié par 5 grâce à un nœud d’expression, est appliqué au

modèle d’état déterministe qui permet de ressortir, à la fois le courant d’induit et la vitesse de rotation, par l’état.

Les paramètres électromécaniques sont définis dans le panel sous forme de clusters sauf pour le paramètre K.

Chapitre 14 - Control Design

521

Dans le diagramme, nous utilisons un nœud MathScript, dans lequel, nous définissons les matrices d’état A, B, C et D et utilisons la commande ss (pour state-space), pour définir le modèle d’état.

Afin de disposer de l’entrée State-Space comme 2ème entrée du bloc State-Space de

la sous-palette Continuous Linear Systems, nous double cliquons sur ce bloc et choisissons Terminal dans Parameter source.

Dans ce panel, nous affichons la réponse indicielle de la vitesse de rotation et du courant

d’induit.

Partie II / Conception de contrôle et simulation

522

I.2.2. Régulation PI avec pondération de la consigne

Nous utilisons le modèle d’état que nous avons précédemment obtenu pour un moteur DC pour servir de processus physique que nous voulons identifier. Pour cela, nous appliquons à ce processus un échelon pour analyser sa réponse indicielle.

Dans le diagramme suivant, nous traçons l’échelon et la réponse du processus dans un

graphe XY en utilisant le bloc Simulation Time, de la sous-palette Signal Generation pour donner le temps de simulation.

Dans ce même graphe XY, nous traçons, en même temps, la sortie et l’échelon d’entrée

grâce aux fonctions Assembler et Construire un tableau.

Dans ce panel, nous avons les courbes de l’échelon d’entrée et de la réponse du processus.

Chapitre 14 - Control Design

523

Nous allons modéliser le processus par un système du 1er ordre de gain statique 0H et de constante de temps .

Le gain statique est le rapport de la valeur statique de la sortie, 111 sur celle de l’entrée 10,

soit VsradH //1.110 et .8.8 s

ppH

pH8.811.11

1)( 0

Nous allons étudier une régulation proportionnelle et intégrale PI où la partie

proportionnelle ne reçoit pas totalement la valeur de la consigne. Le diagramme suivant montre que le régulateur PI fait intervenir 2 erreurs, l’erreur de la

partie proportionnelle est une fraction de la consigne comparée à la sortie du processus.

La commande issue de ce régulateur est donnée par :

)()()()( tytrp

KtrKtu i

pr

Kpr pour pondération de la référence ou consigne. Connaissant la fonction transfert du 1er ordre du processus, la fonction de transfert en

boucle fermée est, tous calculs faits, la suivante :

2

00

0

0

11)()(

pKH

pKH

KpKKH

Htrty

ii

ipr

i

En boucle fermée, le système se comporte comme un 2ème ordre de pulsation propre

iKHw 00 et de coefficient d’amortissementiKH 0

121 .

Le gain statique est égal à 1 grâce à la présence d’une intégration dans le régulateur. Les 2 panels suivants montrent les résultats pour 2 valeurs différentes du gain Kpr.

Nous remarquons que quelque soit cette valeur, le gain statique reste égal à 1. Le temps de

réponse augmente lorsque Kpr diminue.

Partie II / Conception de contrôle et simulation

524

I.2.3. Filtre de Kalman – Estimation du courant d’induit et de la vitesse angulaire

On suppose que le moteur est dans un milieu hostile et qu’on ne dispose que de la mesure bruitée de la vitesse, de rotation de l’arbre moteur.

Dans cet exemple, nous considérons les valeurs suivantes des paramètres électromécaniques du moteur :

K=0.050 N.m/A R= 2 ohms, L=0.120 H, f= 0.001 N.m/(rad/s), J=0.02 kg.m2

Le modèle d’état stochastique du moteur est alors le suivant :

05.05.24167.06667.16

A , 0

3333.8B , 10C , 0D

La sortie bruitée est la somme de la sortie du processus modélisé par son modèle d’état

déterministe et d’un bruit gaussien centré, d’écart-type unité.

Chapitre 14 - Control Design

525

Nous traçons cette sortie bruitée, la sortie estimée par filtre de Kalman, l’estimation de l’état qui permet la récupération de la vitesse de rotation et du courant d’induit.

Dans ce panel, nous affichons la sortie ou vitesse bruitée ainsi que celle estimée par le filtre

de Kalman. Nous affichons également l’état estimé qui est la sortie ou vitesse déjà affichée et le courant d’induit. Le gain de Kalman diminue pour se stabiliser à la valeur 0.049.

II. Model Information (information sur les modèles)

Ces blocs permettent de vérifier certaines propriétés de modèles, les récupérer ou les spécifier.

Partie II / Conception de contrôle et simulation

526

II.1. Fonction de transfert constante, vérification et spécification de propriétés

Dans cet exemple, nous spécifions un cluster définissant une fonction de transfert. Ce cluster contient un autre cluster pour les propriétés et un autre cluster dans lequel on spécifie le numérateur et le dénominateur de la fonction de transfert et le retard.

Nous avons défini la fonction de transfert suivante :

Le modèle a pour nom « Système thermique », l’entrée c’est « Commande de chauffe » et la sortie « Température du four ».

Le VI CD Verify if Discrete.vi vérifie si la fonction de transfert est discrète ou

non. La LED de sortie, éteinte, montre qu’elle est continue. La vérification du type par CD Verify Model Type.vi indique que le modèle est de

type SISO (Single Input Single Output), soit une entrée et une sortie. Le VI CD Verify MIMO Properties.vi permet de déterminer le nombre d’entrées

et de sorties ainsi que la fonction de transfert. Lorsqu’on désassemble le cluster de la fonction de transfert constante, nous obtenons les 2

clusters properties et transfer functions(s). Après des indexations, nous récupérons le numérateur et le dénominateur de la fonction de

transfert. Avec CD Construct Special TF Model.vi nous redéfinissons une fonction de transfert du 1er ordre.

Avec CD Draw Transfer Function Equation.vi nous affichons l’équation de la fonction de transfert. CD Construct Zero-Pole-Gain Model.vi permet de transformer la fonction de

transfert sous forme d’un cluster composé du gain, zéros et pôles du modèle.

ppH

2011)(

Chapitre 14 - Control Design

527

II.2. Modèle d’état constant

Dans cet exemple, nous partons d’un cluster définissant un modèle d’état constant. En le désassemblant, nous pouvons vérifier ses composantes que sont :

- le cluster properties (propriétés), - les matrices A, B, C et D du modèle d’état, - le cluster StateNames que sont les noms des variables d’état, - le retard.

Le VI CD Get Names from Model.vi permet de récupérer le nom de l’entrée, de la

sortie et des états. Le VI CD Set Names to Model.vi permet de spécifier donc de modifier certaines propriétés d’un modèle d’état.

Partie II / Conception de contrôle et simulation

528

Le panel affiche les résultats des opérations décrites précédemment.

III. Model Conversion (conversion de modèle)

Les VIs de cette sous-palette permettent de changer le type de modèle. On peut passer d’une fonction de transfert à un modèle d’état et inversement, discrétiser un

modèle continu ou re-discrétiser un modèle discret.

III.1. Conversion d’une fonction de transfert en modèle d’état

Dans cet exemple, nous faisons la transformation d’une fonction de transfert en modèle d’état que l’on discrétise ensuite à une période d’échantillonnage de 5s.

Chapitre 14 - Control Design

529

Par un clic droit sur l’entrée Transfer Function Model du VI CD Convert to State-Space Model.vi, on spécifie l’option Créer Constante. On obtient ainsi la fonction de transfert vide suivante, sous forme de clusters.

En faisant apparaître les étiquettes de chaque élément comme c’est le cas du cluster properties et le réel double Sampling Time.

De la fonction de transfert qui relie l’entrée u(t) à la sortie y(t) :

ppH

2011)( ,

Partie II / Conception de contrôle et simulation

530

nous obtenons l’équation différentielle suivante :

)(05.0)(05.0)( tutyty En posant )()( tytx , nous obtenons l’équation d’état suivante :

)(05.0)(05.0)( tutxtx

Les matrices d’état sont alors :

05.0A , 05.0B , 1C , 0D Dans le diagramme suivant, nous transformons la fonction de transfert continue en modèle

d’état continu que nous discrétisons à une période d’échantillonnage de 5s, à l’aide du VI CD Convert Continuous to Discrete.vi.

Nous définissons de même le modèle d’état théorique sous forme d’un modèle d’état constante. Nous ne spécifions que la cadence d’échantillonnage nulle et ses matrices d’état A, B, C et D.

Nous calculons et traçons simultanément dans un graphe XY, les 2 réponses indicielles des 2 modèles d’état, celui obtenu par discrétisation et celui obtenu théoriquement.

Avec le VI CD Similar State-Space Models.vi, nous pouvons définir l’égalité

et la similitude de ces 2 modèles d’état. Ceci est obtenu sur les 2 LEDs connectées aux 2 sorties correspondantes.

Dans le panel, nous affichons la fonction de transfert continue, son modèle d’état

équivalent ainsi que le modèle d’état discret obtenu par discrétisation du modèle d’état continu.

La matrice A est la même que celle calculée précédemment car elle correspond au pôle du

système.

Chapitre 14 - Control Design

531

Dans ce panel, nous affichons le modèle d’état théorique continu ainsi que sa version discrétisée. Les réponses indicielles du modèle d’état obtenu par discrétisation et celle du modèle d’état théorique discret sont parfaitement confondues. Les 2 modèles d’état ne sont pas égaux mais sont similaires.

III.2. Conversion modèle d’état discret en fonction de transfert

Nous partons du modèle d’état continu suivant :

)()()()(10

)()(

0010

)()(

2

1

2

1 tuBtxAtxtutxtx

txtx

)()()()()(

01)(2

1 tuDtxCtytxtx

ty avec D=0

On désire obtenir le modèle d’état discret équivalent avec une période d’échantillonanage

Ts=0.1s. Nous utilisons le VI CD Convert Continuous to discrete.vi pour obtenir le modèle d’état discret avec bloqueur d’ordre 0.

Nous obtenons le modèle discret suivant :

)(0)()(

01)(

)(1.0

005.0)()(

101.01

)1()1(

2

1

2

1

2

1

kukxkx

ky

kukxkx

kxkx

Avec le VI CD Convert to Transfert fonction Model.vi, nous obtenons le numérateur et le dénominateur de la fonction de transfert, soit :

12005.0005.0)( 2 zz

zzF

Partie II / Conception de contrôle et simulation

532

A partir du modèle d’état continu d’origine, en utilisant le VI CD Convert Discrete to Continous.vi nous avons besoin du numérateur et du dénominateur de la fonction de transfert, et en utilisant ensuite le VI CD Draw Transfert Equation.vi, nous obtenons l’équation de cette fonction de transfert, soit :

12132 1010.11038.11)(pp

pF

Ce système est proche d’un double intégrateur. Le VI CD Step response.vi permet

de tracer la réponse indicielle. Ces réponses, continue et discrete, sont toutes des paraboles à cause du type double

intégrateur du système.

Le panel représente les résultats obtenus.

Chapitre 14 - Control Design

533

III.3. Modèle d’état, fonction de transfert, pôles, zéros, réponse indicielle

On considère un système du 2nd ordre possédant 2 pôles qu’on choisit comme suit :

5.01z et 8.02z Le dénominateur de cette fonction de transfert est alors :

4.03.1)( 22121

2 zzzzzzzz

En cliquant droit sur l’entrée Transfer Function Model du VI CD Convert to State Space Model.vi on crée, dans le diagramme, une fonction de transfert constante, soit un cluster constant. Ce VI permet de convertir une fonction de transfert en un modèle d’état. On fait apparaître les étiquettes de tous ses éléments afin de faciliter la specification de tous les éléments. Les noms de l’entrée et de sortie sont, respectivement les chaînes de caractères correspondant à Tension d’induit et vitesse de rotation, moteur DC. Le nom du modèle est Régulation de vitesse.

L’entrée et la sortie ne possèdent pas de retards (delays). La période d’échantillonnage est choisie à Ts=0.01s. Ce cluster principal contient un autre cluster qui contient lui-même des tableaux 1D correspondant au numérateur et au dénominateur de cette fonction de transfert.

21

1

2 4.03.114.03.1)()()(

zzz

zzz

kukyzH

)(ku et )(ky sont les échantillons, à l’instant courant k, de l’entrée et de la sortie du

processus défini par cette fonction de transfert. En remplaçant z par 1, on obtient le gain statique suivant:

1013.14.0

1)1(H

Partie II / Conception de contrôle et simulation

534

Le VI CD Convert to State Space Model.vi permet de convertir une fonction de transfert en modèle d’état.

Cette fonction de transfert permet d’aboutir à l’équation de récurrence liant les échantillons

y(k) à u(k) : )1()2(4.0)1(3.1)( kukykyky

En posant )()(1 kykx , nous obtenons après une avance d’un pas :

)()(4.0)1()()(3.1)1(

12

211

kukxkxkxkxkx

Nous avons ainsi le système d’état suivant :

)(*0)()(

01)(

)(10

)()(

04.013.1

)1()1(

2

1

2

1

2

1

kukxkx

ky

kukxkx

kxkx

Nous ne trouvons pas ces mêmes matrices avec LabVIEW. En effet, il n’existe pas un

modèle d’état unique pour modéliser un processus. La seule condition est qu’on doit trouver les mêmes valeurs propres de la matrice d’état A

qui doivent correspondre aux pôles du processus. Dans le VI suivant, on calcule les valeurs propres de ces 2 matrices. Le VI Eigenvalues ans Vectors.vi, de la sous-palette Mathématiques

Algèbre Linéaire, permet de déterminer les valeurs et vecteurs propres d’une matrice. Nous testons l’égalité des 2 résultats et nous affichons un résultat de ces valeurs propres,

qui correspondent parfaitement aux valeurs des pôles 0.5 et 0.8.

Dans ce panel, nous affichons les valeurs des 2 matrices d’état du même système.

Chapitre 14 - Control Design

535

Les valeurs propres correspondent parfaitement aux pôles et les 2 résultats sont parfaitement égaux du fait que les 2 LEDS s’allument en vert.

Dans le diagramme suivant, le modèle d’état obtenu par transformation de cette fonction de

transfert est affiché dans le cluster State-Space Model. Dans Equation, nous affichons l’équation de cette fonction de transfert grâce au VI CD Draw Transfer Function Equation.vi. Les VIs Step Response Graph.vi et Impulse Response Graph.vi permettent de tracer les réponses, indicielle et impulsionnelle, dans le domaine temporel allant de 0 à 1 par pas de 0.01 qu’on spécife dans le cluster appliqué à l’entrée Time Range. Le lieu des pôles et zéros, le gain statique et la forme Zéro-Pôle-Gain peuvent être aussi obtenus par des VIs qu’on a utilisés dans ce diagramme.

Dans le panel, nous trouvons le courbes des réponses, indicielle et impulsionnelle, les 2 pôles réels de la fonction de transfert, ainsi que son équation.

Nous affichons également le gain statique, les pôles et la forme Zéro-Pole-Gain dans le cluster Zero-Pole-Gain Model.

Partie II / Conception de contrôle et simulation

536

IV. Model Interconnection (Interconnexion de modèles)

Les VIs de cette sous-palette permettent d’ajouter, soustraire, multiplier, diviser des fonctions de transfert, les connecter en série, parallèle, etc.

IV.1. Ajout de fonctions de transfert

Dans le diagramme suivant, nous ajoutons 2 fonctions de transfert continues du 1er ordre. La 1ère fonction de transfert est définie dans le diagramme en appliquant une constante du VI CD Add Models.vi, la 2ème est définie dans le panel avec créer une commande.

Dans le diagramme, le cluster définissant la fonction de transfert contient aussi le cluster de propriétés qu’on laisse vide dans cet exemple. Dans le panel, ce cluster contient uniquement le nom du modèle et la période d’échantillonnage en plus de la fonction de transfert.

Nous ajoutons les fonctions de transfert suivantes :

ppH

2011)(1 et

ppH

1011)(2

Chapitre 14 - Control Design

537

Nous utilisons une fonction de transfert constante définie dans le diagramme et une autre dans le panel et nous faisons leur somme à l’aide du VI CD Add Models.vi.

Nous obtenons bien :

2100251155,1

515.0

2011

ppp

pp

IV.2. Bouclage négatif (contre-réaction)

Le VI CD Feedback.vi permet de calculer la fonction de transfert en boucle fermée à partir de la boucle ouverte H1 et du retour H2.

21

1

1 HHHH

Partie II / Conception de contrôle et simulation

538

Dans le diagramme suivant, la fonction de transfert direct H1 est déterminée par le cluster Model 1. La fonction de transfert H2 du retour est spécifiée dans le panel.

On choisit un retour négatif dans Feedback Connections.

V. Time Response (temps de réponse)

Les VIs de cette sous-palette permettent de déterminer la réponse indicielle, impulsionnelle, etc.

Chapitre 14 - Control Design

539

V.1. Fonction de transfert constante dans le diagramme

Dans l’exemple suivant, nous avons utilisé la même fonction de transfert du premier ordre suivante :

ppH

1011)(1

On trace les réponses, indicielle avec CD Step Response.vi et impulsionnelle avec CD Impulse Response.vi. Le VI CD Linear Simulation.vi permet de tracer la réponse d’un système défini par une fonction de transfert, un modèle d’état, etc., à un stimulus déterminé par l’entrée Inputs.

Le panel suivant affiche les réponses, indicielle et impulsionnelle, ainsi que la réponse à quelques points donnés dans le tableau Inputs.

Partie II / Conception de contrôle et simulation

540

V.2. Fonction de transfert définie dans un nœud MathScript

On considère la fonction de transfert d’un second ordre optimal, i.e. qui possède un

coefficient d’amortissement 22 . Nous choisissons la pulsation propre 10w .

22

00

211

21

1)()()(

ppwp

wppU

pYpH

L’équation différentielle qui relie l’entrée u(t) à la sortie y(t) est alors :

utytyty )()(2)( C’est une équation différentielle du 2nd ordre, le système sera défini par 2 variables d’état. On pose )()(1 tytx ,

utxtxtx )(2)()( 111 Avec )()( 21 txtx , nous avons :

)(10

)()(

2110

)()(

2

1

2

1 tutxtx

txtx

Nous voulons trouver la réponse indicielle du système représenté par ce modèle d’état.

Pour cela, nous allons utiliser le nœud MathScript pour définir ce modèle d’état avec la commande ss. La variable de sortie du nœud représente le modèle d’état qu’on applique au VI CD Step Response.vi pour avoir le graphe de la réponse indicielle. A sa sortie, il suffit de spécifier Créer un indicateur pour obtenir le graphe de cette réponse indicielle. L’entrée Time Range est un cluster content l’instant initial t0, le pas de temps dt et l’instant final tf pour lesquels on veut obtenir le tracé.

Chapitre 14 - Control Design

541

Le VI CD Parametric Response Time Response.vi permet d’obtenir des paramètres temporels de la réponse impulsionnelle tels :

- le dépassement (Overshoot) en %, - la valeur du pic (Peak Value), - le temps de montée (Rise Time), - le temps de stabilisation (Settling Time), etc.

VI. Frequency Response (réponse fréquentielle)

Les VIs de cette sous-palette permettent de tracer les réponses fréquentielles d’un système défini par sa fonction de transfert, modèle d’état, forme Zéro-Pole-Gain.

Dans le diagramme suivant, nous considérons la même fonction de transfert du 1er ordre précédente.

Les VIs CD Bode.vi et CD Nyquist.vi permettent de tracer les diagrammes de Bode et de Nyquist.

Le système peut être aussi défini par son modèle d’état ou la forme Zéro-Pôle-Gain.

Partie II / Conception de contrôle et simulation

542

Nous retrouvons bien le diagramme asymptotique de 0 dB puis -20 dB/décade à partir de la

fréquence de coupure wc=0.1 rad/s. Le VI CD Bandwith.vi donne la bande passante soit la bande entre 0 dB et -3 dB.

VII. Dynamic Characteristics (caractéristiques dynamiques)

Les VIs de cette sous-palette permettent de déterminer le lieu des pôles, zéros, gain statique, etc.

On considère la fonction de transfert du 2nd ordre suivant :

244.1151)(

ppppH

Chapitre 14 - Control Design

543

L’équation caractéristique ou dénominateur peut être représentée par le coefficient d’amortissement et la pulsation propre w0 :

200

221wpp

w

Nous avons 707.0 et 10w . Le choix de cette valeur de l’amortissement permet d’avoir une réponse indicielle avec un

seul dépassement pour la fonction de transfert :

200

221

1

wpp

w

Dans ce diagramme, nous créons la fonction de transfert du 2nd ordre précédente sous forme

du cluster constant Model 1. Le VI CD Root Locus.vi et CD Pole-Zero Map.vi permettent de tracer le lieu

d’Evans et la carte des pôles et des zéros. CD Damping Ratio and Natural Frequency.vi donne bien le coefficient

d’amortissement =0.7 et une pulsation propre w0=1. CD Stability.vi indique si le système est stable et donne les valeurs des pôles. Le

gain statique est donné par le VI CD DC Gain.vi.

Dans ce panel, nous retrouvons les 2 pôles complexes conjugués, le zéro de -0.2 et le gain

statique unité. Le coefficient d’amortissement proche de 0.7 comme nous l’avons spécifié et la pulsation

propre unité. La réponse indicielle possède un temps de réponse optimal dans le cas où le numérateur est

égal à 1 (pas de zéro) et un amortissement de 22 proche de celui qu’on a utilisé dans cette

fonction de transfert.

Partie II / Conception de contrôle et simulation

544

VIII. State-Space Model Analysis (analyse dans l’espace d’état)

Les VIs de cette sous-palette permettent d’analyser un système dans l’espace d’état et de déterminer si le système est commandable, observable, etc.

Un système d’ordre n dans l’espace d’état, de matrices d’état A, de commande B, est dit

commandable si le rang de la matrice

BABAABB n 12 ... est égal à n. C’est le critère de Kalman pour la commandabilité ou contrôlabilité. Un système est dit observable si la connaissance de ses entrées-sorties, à un instant t,

permet de déterminer l’instant initial. Le critère de Kalman pour l’observabilité indique que le système est observable si :

n

AC

ACC

rang

n 1

...

Chapitre 14 - Control Design

545

Le rang d’une matrice est le nombre maximal de vecteurs lignes (ou colonnes) linéairement indépendants. Considérons le circuit RLC série suivant :

En appliquant la loi des mailles, nous obtenons :

VdtdiLu

La loi au nœud nous donne :

RVi

dtdVC

Nous choisissons i et V comme variables d’état. Le modèle d’état est alors :

RCV

Ci

dtdV

LV

Lu

dtdi

soit :

uL

V

i

CRC

L

dtdV

dtdi

0

1

11

10

On s’intéresse au courant i , soit V

iiy 01

Les matrices A, B, C et D sont alors :

CRC

LA 11

10,

0

1LB , 01C et 0D

Partie II / Conception de contrôle et simulation

546

On considère les valeurs numériques suivantes :

mHLFC

KR

11

1

VIII.1. Contrôlabilité et observabilité

Les matrices A, B, C et D sont définies dans le panel par des matrices réelles avec Tableau, matrice et cluster Matrice réelle.

Les VIs CD Controllability Matrix.vi et CD Observability.vi

permettent de déterminer les matrices de contrôlabilité et d’observabilité. Le rang de ces matrices est calculé par le VI Matrix Rank.vi de la sous-palette

Mathématiques Algèbre linéaire. Ce rang est comparé au nombre de colonnes (ou de lignes) de la matrice A obtenue par désassemblage du cluster qui définit le modèle d’état. Ce cluster est défini par le VI CD Construct State-Space Model.vi qui reçoit les matrices A, B, C et D.

Chapitre 14 - Control Design

547

VIII.2. Modèles d’états similaires

VIII.2.1. Similarité de 2 modèles d’état d’un système du 1er ordre

Nous considérons les 2 modèles d’état, théorique et celui obtenu par le VI model conversion.vi du paragraphe Model Conversion. La fonction de transfert du 1er

ordre suivante : p

pH2011)( , permet d’aboutir aux 2 modèles d’état scalaires de matrices

A, B, C et D suivantes : 05.0A , 05.0B , 1C , 0D et A=-0.05, B=1, C=0.05, D=0 Nous appliquons ces 2 modèles d’état au VI CD Similar State-Space

Models.vi pour savoir s’ils sont similaires.

La LED Similar est allumée mais ces 2 modèles ne sont pas égaux. Ils sont similaires

car ils représentent, tous les deux, le même processus.

VIII.2.2. Circuit RLC

Nous allons étudier le circuit RLC suivant, pour lequel nous allons calculer le modèle d’état théorique et obtenir un modèle d’état par transformation de sa fonction de transfert.

Partie II / Conception de contrôle et simulation

548

La fonction de transfert est, tous calculs faits, la suivante :

2

21

1

21

21

2

21

1

1)(

pCLRR

RpRR

CRRLpCR

RRRpH

Nous choisissons les valeurs numériques suivantes :

HLFC

KRR

11

121

La fonction de transfert est alors :

263

3

105.010110

21)(

ppppH

Les variables d’état sont choisies comme le courant dans une bobine ou la tension aux

bornes d’un condensateur. Pour ce circuit, nous choisissons v(t) et i(t) comme variables d’état. Soit iR1, le courant qui circule dans la résistance R1. D’après les lois des mailles et des noeuds, nous avons :

iidt

tdvC

iRdt

tdiLtiR

iRtvtu

R

R

1

112

11

)(

)()(

)()(

Pour obtenir les équations d’état, nous devons éliminer le courant iR1.

)(1)()(1)(

)(1)(1)(1)(

2

11

tuL

tiLRtv

Ldttdi

tuRC

tiC

tvRCdt

tdv

Nous avons alors les matrices d’état suivantes :

LR

L

CRCA2

11

11

,

L

RCB1

1

1

Comme y(t) = R2 i(t), alors 20 RC et 0D . En utilisant, un nœud MathScript, nous

allons calculer les matrices A, B, C et D d’un modèle d’état équivalent à cette fonction de transfert. A l’aide de la commande tf2ss, nous transformons la fonction de transfert en modèle d’état. La commande roots permet de calculer les pôles ou les racines du dénominateur de la fonction de transfert. En sortie de ce nœud, nous avons également les matrices d’état obtenues par calcul.

Chapitre 14 - Control Design

549

Dans ce panel, nous pouvons vérifier que les 2 modèles d’état obtenus, par la commande

tf2ss et par calcul théorique, ne sont pas les mêmes. Par contre, les valeurs propres sont égales aux valeurs complexes conjuguées iz 100010002,1 .

Dans le diagramme suivant, nous allons obtenir un 3ème modèle d’état par transformation

de la même fonction de transfert avec le VI CD Convert to State-Space Model.vi.

Ce modèle d’état est également différent des 2 autres. Sachant que ces 3 modèles d’état ne sont pas égaux, nous allons montrer qu’ils sont

similaires en utilisant le VI CD Similar State-Space Models.vi. A l’aide de CD Draw State-Space Equation.vi, nous affichons l’équation des 3

modèles d’état.

Partie II / Conception de contrôle et simulation

550

Ces 3 modèles d’état sont définis en tant que constants dans ce diagramme.

Dans le panel suivant, les 2 LEDs s’allument, ce qui démontre que les 3 modèles d’état sont

similaires. Les valeurs propres de la matrice A de ce 3ème modèle d’état sont égales aux 2 premières.

Ces 3 modèles d’état ne sont pas égaux mais similaires car représentant le même système.

IX. Implementation

Dans cette sous-palette, nous trouvons plusieurs façons de modéliser un système discret : par fonction de transfert en z, modèle d’état discret, modèle Zéro-Pôles-Gain, etc.

Elle contient également un filtre de Kalman discret.

Chapitre 14 - Control Design

551

IX.1. Réponse indicielle d’un processus discret du 1er ordre

On considère le processus discret de modèle suivant :

1

121

11

1)()(

zazbbzzH avec 5.0,1,8.0 21 bba .

Cette fonction de transfert peut être mise sous la forme )(zH du bloc Discrete Transfer Function de la sous-palette Implementation.

)8.01(5.0)(

zzzzH

On choisit le style Express par Icon Style dans le menu local obtenu par un clic droit.

Les coefficients du numérateur et du dénominateur sont spécifiés après un double clic sur

ce bloc.

Partie II / Conception de contrôle et simulation

552

Dans ce diagramme, nous appliquons à ce processus un signal carré. En tirant vers le bas le nœud d’entrée de la boucle de contrôle et simulation, nous spécifions une durée de 20s et un échantillonnage de 5s.

Nous traçons dans le même waveform graph, les signaux d’entrée et de sortie.

Nous vérifions bien un gain statique de 2.5 dans ces courbes et en remplaçant z par 1 dans

la fonction de transfert discrète.

IX.2. Filtre de Kalman discret

Nous considérons le même processus du 1er ordre précédent.

1

121

11

1)()(

zazbbzzH

Le processus est alors défini par l’équation de récurrence suivante :

)2()1()1()( 211 kubkubkyaky

Chapitre 14 - Control Design

553

En posant )()(1 kykx , nous obtenons, après une avance d’un pas d’échantillonnage:

)1()()()1( 21111 kubkubkxakx On définit une 2ème variable d’état x2 tel que :

)()()()1( 21111 kxkubkxakx , soit )1()( 22 kubkx On aboutit au modèle d’état discret suivant :

)()1()()()()1(

22

12111

kubkxkubkxkxakx

Les matrices d’état sont alors :

0,01,,001

2

11 DCbb

Ba

A

Nous allons vérifier que les valeurs propres de la matrice A sont les pôles de la fonction de

transfert et que nous obtenons la même réponse indicielle que précédemment. Nous allons utiliser la fenêtre MathScript pour calculer les valeurs propres de la matrice A.

Nous vérifions bien que les valeurs propres de la matrice d’évolution A sont les pôles de la fonction de transfert.

La commande tf renvoie l’équation de la fonction discrète. Nous allons utiliser le modèle d’état pour tracer la réponse indicielle. Dans ce diagramme, nous appliquons le même signal carré que pour la fonction de transfert

discrète précédente. En utilisant le bloc Discrete State-Space nous pouvons récupérer le vecteur d’état,

en plus de la sortie du processus.

Partie II / Conception de contrôle et simulation

554

Nous obtenons la même réponse pour la description du processus par sa fonction de

transfert. Dans le 2ème graphe, nous traçons les variables d’état x1 et x2. Nous remarquons bien que x1 est identique au signal de sortie et que x2 est la moitié du

signal de commande avec changement de signe.

Dans le diagramme suivant, le bloc Discrete Kalman Filter permet de réaliser un

filtre de Kalman discret pour estimer la sortie du processus précédent lorsqu’elle est mesurée par un capteur bruité.

Le modèle d’état stochastique est défini par :

)()()()()()()()1(

kvkuDkxCkykwkuBkxAkx

)(kw et )(kv sont les bruits de modélisation et de mesure.

Pour la théorie du modèle d’état, on se référera au chapitre sur le filtre de Kalman du

chapitre « Filtrage de signal aléatoire ». Dans le diagramme suivant, la sortie bruitée du processus est définie comme la sortie de la

fonction de transfert à laquelle on ajoute un bruit gaussien centré d’écart-type unité. Le signal d’entrée est un signal carré de période 100s. On applique au bloc Discrete

Kalman Filter, le signal d’entrée et la sortie bruitée pour obtenir l’estimation de la sortie et du vecteur d’état.

Chapitre 14 - Control Design

555

La 1ère courbe affiche le signal de commande et la sortie bruitée. Nous affichons, dans le

même waveform graph, le vecteur d’état et la sortie estimée. Nous vérifions bien que la 1ère composante d’état se confond à la sortie estimée et la 2ème composante est opposée au signal d’entrée avec un rapport de ½, soit b2 u(t)=-0.5 u(t).

Le gain de Kalman diminue rapidement et se stabilise à la valeur 0.17.

IX.3. Commande par retour d’état

IX.3.1. Régulation autour de l’origine

La commande par retour d’état consiste à appliquer au processus une commande u(t) définie par :

)()( txKtu )(tx : vecteur d’état

K : coefficients du retour d’état Comme le modèle d’état est donné :

)()()( tuBtxAtx

Partie II / Conception de contrôle et simulation

556

En boucle fermée, nous obtenons, en remplaçant la commande u(t) par sa valeur ci-dessus :

)()( txKBAtx Cette expression impose la dynamique du retour à 0 de l’état autour de zéro. En régime

permanent, la dérivée de l’état s’annule. Nous avons alors :

0)(xKBA Ainsi l’état en régime statique est nul. Avec x0 la valeur initiale du vecteur d’état, nous avons cette fonction de transfert en boucle

fermée :

01)( XKBAIppX

Lorsqu’on veut réguler le système autour d’une consigne ou référence r(t), nous devons

spécifier la commande par retour d’état suivante :

)()()( txKtrFtu La commande par retour consiste à calculer les valeurs K et F. Les valeurs des coefficients

du retour d’état K consistent à imposer les pôles ou valeurs propres de la boule fermée.

)()()( trFBtxKBAtx Avec )()( txCty , nous avons la relation suivante qui lie la sortie y(t) à la référence r(t) :

)()( 1 trFBKBAIpCty

Le gain statique en boucle fermée est alors :

FBKBAC 1 En effet, en régime permanent, nous avons :

)()(0 rFBxKBA Ainsi :

)()( 1 rFBKBAx , d’où

)()( 1 rFBKBACy

Si l’on veut avoir un gain statique unité, F est donné par : 11 BAKBCF

Le VI CD State Feedback Controller.vi ne fait que la régulation autour de

l’origine. La dynamique de régulation autour de l’origine est donnée par :

Chapitre 14 - Control Design

557

1

215.01

0018.0

00

01 kkp

p

L’inverse d’une matrice carrée 2x2 :

DCBA

M

est donnée par :

CBDAACBD

MACBD

Mdet

1

Pour k1=1 et k2=0, nous obtenons les résultats suivants :

Le panel affiche l’évolution vers l’origine de la commande, du vecteur d’état et de la sortie.

Partie II / Conception de contrôle et simulation

558

IX.3.2. Régulation autour d’une référence non nulle

A l’aide de la fenêtre MathScript, nous calculons le coefficient F qui intervient dans la commande par retour d’état pour une régulation autour d’une référence non nulle r(t) :

)()()( txKtrFtu

Pour avoir un gain unité, F doit être égal à :

11 BAKBCF

Dans ce diagramme, la commande de retour d’état est ajoutée au signal de référence

puisque F est égal à 1.

Le panel affiche le signal de commande, le vecteur d’état ainsi que les signaux de sortie et

de référence sinusoïdale.

Nous vérifions bien que la 1ère composante d’état, x1, est identique à la sortie du processus et que la 2nde composante, x2, est la moitié du signal de commande avec opposition de phase, x2=b2 u(t)=-0.5 u(t).

Partie II. Chapitre 15 - Identification

I. Identification paramétrique I.1. Identification d’une fonction de transfert discrète I.2. Identification d’un modèle d’état discret I.3. Identification d’une fonction de transfert par un VI de type Express I.4. Identification d’un modèle linéaire général I.5. Identification des modèles ARX et ARMAX I.6. Identification du modèle AR (AutoRégréessif) II. Identification par métodes récursives – Modèle de Box-Jenkins III. Identification par Grey-Box IV. Nonparametric Model Estimation (estimation non paramétrique) V. Model Management (gestion des modèles) V.1. Exemple 1 – Management V.2. Exemple 2 – Management VI. Dataprocessing (traitement des données) VII. Model Validation VIII. Model Conversion VIII.1. Exemple 1-Model Conversion VIII.2. Exemple 2-Model Conversion IX. Model Analysis X. Utilities (Utilitaires)

559DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _15,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie II / Conception de contrôle et simulation

560

L’identification consiste à trouver un modèle mathématique qui définit la dynamique d’un système, (fonction de transfert ou modèle d’état) qui relie les échantillons temporells de la sortie à ceux de l’entrée. LabVIEW System Identification Toolkit fournit une bibliothèque de VIs,

pour identifier des systèmes linéaires mono-entrée mono-sortie (SISO : Single Input Single Output.) et à entrées multiples et sorties multiples (MIMO : Multiple-Input Multiple-Output).

Le stimulus doit être un signal riche en fréquences qui puisse stimuler tous les modes du

processus à identifier. C’est le cas d’un signal aléatoire gaussien centré dont l’autocorrélation est une impulsion de Dirac.

I. Identification paramétrique

L’identificaton paramétrique consiste à estimer les coefficients d’un système défini par une fonction de transfert, modèle d’état, etc.

Chapitre 15 / Identification 561

L’outil LabVIEW System Identification Toolkit permet d’identifier 2 catégories de modèles paramétriques :

Les modèles polynomiaux incluent les modèles

- AR (AutoRégressif), - ARX (AutoRégressif avec modèle de bruit, eXtended), - ARMAX (AutoRégressif Moyenne Ajustée avec entrée étendue), - Box-Jenkins BJ, - General linear model (Modèle linéaire général), - Etc.

Le modèle ARMA correspond à un modèle possèdant un numéateur (partie MA, Moyenne

Ajustée) et d’un dénominateur qui constitue la partie AR (Auto Régressive). Considérons la fonction de transfert suivante :

11

121

1

1

11

1)(

)()()(

zazbbz

zAzBzH

La sortie y(k) et l’entrée u(k), de l’instant courant k, sont liées par l’équation récurrente

suivante : )2()1()1()( 211 kubkubkyaky

Les grandeurs :

)2(,)1(),1( kukuky sont les valeurs antérieures à l’instant k. La quantité suivante est la somme pondérée de )1(ku et )2(ku :

21

21 )1()1(bb

kubkub

Pour celà, le numérateur )( 1zB qui relie l’entrée à la sortie est appelée MA ou moyenne

ajustée. Elle signifie « Moving Average », la moyenne glissante ou mobile dans la littérature

anglosaxonne. La partie AR ou AutoRégressive est celle liant la sortie )(ky à ses valeurs antérieures.

C’est la partie qui contient les pôles, donc qui définit la stabilité d’un système discret donc régit le régime transitoire et la réponse impulsionnelle.

Dans le cas de cet exemple du 1er ordre, le pôle 1a doit être inférieur à 1 pour que le

système soit stable. Cette partie est dite « Auto » car il s’agit du même signal y et « Régressive » car la valeur

des échantillons y(k) doit régresser dans le temps pour que le système soit stable.

Partie II / Conception de contrôle et simulation

562

I.1. Identification d’une fonction de transfert discrète

Nous nous intéressons à l’identification paramétrique des systèmes continus ou discrets par une fonction de transfert.

Le but est d’estimer les paramètres d’un processus défini par sa fonction de transfert. On

dispose du stimulus appliqué au système à identifier ainsi que de la sortie de ce système. On applique ces 2 signaux au VI SI Estimate Transfer Function Model.vi.

Le cluster orders contient 2 entiers correspondant à l’ordre du numérateur et du dénominateur.

En sortie, nous récupérons les coefficients ainsi que l’équation du modèle estimé. Le VI SI Remove Trend.vi permet de supprimer la valeur moyenne des signaux

(stimulus et sortie) ainsi que les valeurs statiques pour ne laisser que la partie dynamique. Dans le diagramme suivant, nous voulons estimer les coefficients de la fonction de transfert

suivante :

8.05.0

8.015.01)( 1

1

zz

zzzH

que nous spécifions par une fonction de transfert constante. Nous appliquons à ce système un stimulus sous forme d’un bruit gaussien centré d’écart-

type unité. Nous ajoutons un bruit uniforme d’écart-type 0.5 à ce stimulus avant d’être appliqué au

système qu’on veut identifier. Nous utilisons 1028 échantillons du stimulus.

Chapitre 15 / Identification 563

En sortie du bloc Collector nous disposons d’un cluster que nous désassemblons pour récupérer les signaux du stimulus et de la sortie que nous appliquons au VI RemoveTrend.vi.

Dans le panel, nous affichons les 2 signaux du stimulus et de la sortie ainsi quelques unes

de leurs valeurs. Nous affichons également la fonction de transfert à estimer ainsi que les valeurs des coefficients de la fonction de transfert obtenue par identification.

I.2. Identification d’un modèle d’état discret

Dans le diagramme suivant, nous nous intéressons à l’identification d’un modèle d’état discret. Le stimulus gaussien est appliqué au modèle d’état suivant :

)()(

01)(

)(5.0

1)()(

0018.0

)1()1(

2

1

2

1

2

1

kxkx

ky

kukxkx

kxkx

Ce modèle d’état est obtenu à partir de la fonction de transfert suivante :

)8.0(5.0

8.01)5.01()( 1

111

zzz

zzzzH

Dans le diagramme suivant, le modèle d’état à identifier est défini par la commande ss

dans un nœud MathScript. La sortie sys permet de transmettre la définition de ce modèle au bloc Discrete

State-Space pour lequel on a spécifié l’option Terminal dans Parameter source après un double clic.

Partie II / Conception de contrôle et simulation

564

A ce bloc, nous appliquons un signal stimulus sous forme d’un bruit gaussien d’écart-type unité auquel nous ajoutons un bruit uniforme d’amplitude 0.05. Avec le VI Remove Trend.vi nous supprimons, du stimulus et de la sortie, leur partie statique pour ne garder que la partie riche en dynamique.

L’identification du modèle d’état se fait par le VI SI Estimate State-Space Model.vi.

Ce VI reçoit les signaux du stimulus et de la sortie pour identilier le modèle d’état qui les relie.

Il sort également le cluster des coefficients du modèle d’état identifié que sont les matrices d’état A, B, C et D.

Nous utilisons un autre nœud MathScipt pour calculer les pôles par les valeurs propres de la matrice A. Nous transformons ces coefficients en modèle d’état grâce à la commande ss à laquelle on transmet ces coefficients après le désassemblage du cluster qui les contient.

La valeur « -1 » de la cadence d’échantillonnage, sampling Time, permet de spécifier la nature discrète de ce modèle d’état, la cadence d’échantillonnage étant inconnue.

Le modèle d’état contenu dans la variable sys est appliqué au VI CD Draw State-Space Equation.vi pour obtenir l’équation du modèle d’état obtenu par identification.

Dans le 1er nœud MathScript, nous sortons les coefficients du modèle d’origine que nous assemblons en cluster afin de tracer le diagramme de Bode.

Le VI SI Set Coefficients to System Model.vi permet de créer un modèle d’état qui permet de tracer le diagramme de Bode.

Le VI SI Pole-Zero Plot.vi permet de tracer les pôles et les zéros du modèle estimé. Le gain en dB dans le plan de Bode est effectué par le VI SI Bode Plot.vi.

En choisissant juste « Créer un indicateur », nous obtenons le graphe dans lequel on trace le gain en dB. Ce graphe est rendu invisible dans le panel grâce au nœud de propriété dans lequel on applique la valeur False (F) à la propriété Visible.

Ce graphe sert juste pour que nous puissions créer la variable locale Bode Magnitude plot qu’on utilisera pour afficher, à la fois, les diagrammes du modèle d’origine et celui obtenu par l’identification.

Chapitre 15 / Identification 565

Dans le panel, nous affichons les coefficients du modèle identifié, quelques valeurs des signaux du stimulus et de la sortie du modèle à identifier.

Nous avons également les équations de ces 2 modèles d’état ainsi que les 4 pôles du

modèle du 4ème ordre obtenu. Dans le lieu des pôles et zéros, nous remarquons que les 2 pôles complexes conjugués sont

compensés par des zéros. Le zéro et les 2 pôles réels correspondent à ceux du modèle d’origine.

Les 2 diagrammes de Bode, modèle à identifier et modèle identifié, sont quasiment

confondus, ce qui valide la qualité de l’identification.

I.3. Identification d’une fonction de transfert par un VI de type Express

Le VI SI Transfer Function Estimation Express.vi opère de façon similaire au VI SI Estimate Transfer Function Model.vi.

Nous allons étudier la propriété de validation de la qualité de l’identification. Nous avons utilisé une fonction de transfert constante identique à celle qui équivaut au

modèle d’état que nous avons identifié précédemment. Comme pour les modèles d’état, le fait de mettre « -1 » pour Sampling Time, consiste à

déclarer la fonction de transfert comme discrète. A l’aide du VI CD Draw Transfer Function Equation.vi, nous affichons

l’équation de la fonction de transfert à identifier. Le stimulus est le même que pour l’exemple précédent de l’identificaton d’un modèle d’état

discret. Après le VI Remove Trend.vi qui supprime la partie statique des siganux du stimulus

et de sortie, nous trouvons le VI Split Signal.vi qui permet de diviser les signaux en 2 parties, une qui sera utilisée pour l’identification et une autre pour la validation de celle-ci..

Partie II / Conception de contrôle et simulation

566

La 1ère partie du stimulus et de sortie, est appliquée, comme précédemment, au VI d’identification, ici le VI de type Express, Direct Discrete TF Estimation.

Le VI SI Draw Model.vi permet d’afficher l’équation du modèle identifié. Le VI Model Simulation.vi reçoit la 2ème partie du stimulus en même temps que le

modèle identifié, réalise la simulation et produit une signal qu’on compare à la 2ème partie du signal de sortie.

Dans le panel, nous affichons les 50 premières valeurs des signaux stimulus et sortie du

modèle à identifier. response signal 2 et Y sont respectivement quelques premières valeurs des signaux

de réponse et ceux de validation (sortie du VI SI Model Simulation.vi) de la 2ème partie, utilisée pour valider l’identification.

Nous constatons que ces signaux sont quasiment égaux. Le modèle de simulation renvoie un signal de type waveform dont nous retirons le signal Y

pour être comparé à la sortie du modèle identifié. Dans Graphe, nous traçons ces 2 signaux sur 100 échantillons et nous remarquons leur

quasi similitude. De même, on peut faire cette même remarque on observant les équations de la fonction de

transfert d’origine et celle qu’on a identifiée. Un moyen quantitatif pour valider l’identification consiste à calculer l’autocorrélation du

résidu qui s’approche d’une impulsion de Dirac qui est l’autocorrélation d’un bruit blanc.

Chapitre 15 / Identification 567

Le modèle obtenu est très proche du modèle à identifier, leurs paramètres sont très proches.

La moyenne et la variance de l’erreur, -0,00002721 et 0,00086977 sont très faibles. Le VI Express possède toujours une boite de dialogue (double clic) dans laquelle il est

possible de le paramètrer, comme ici, on spécifie l’ordre du numérateur et du dénominateur de la fonction de transfert à identifier ainsi que sa nature continue ou discrète.

I.4. Identification d’un modèle linéaire général

De façon générale, nous pouvons décrire la relation entrées/sorties d’un système par l’équation linéaire suivante où e(k) est un bruit blanc centré qui représente la perturbation.

)()()()()( 11 neqHnuqGqny k

Cette expression est connue sous le nom de modèle linéare général. Le système est ainsi

composé d’une partie déterministe et d’une partie stochastique.

Partie II / Conception de contrôle et simulation

568

G(q-1) et H(q-1) sont les fonctions de transfert, respectivement, de la partie déterministe et de la partie stochastique.

q-1 est l’opérateur retard : q-1 x(k) =x(k-1). Nous avons :

)()()()1( 11

1

qFqAqBqG

)()()()1( 11

1

qDqAqCqH

Ainsi le modèle est représenté par le schéma-bloc suivant :

Nous considérons la même fonction de transfert discrète précédente. Comme dans l’exemple précédent, nous supprimons les valeurs statiques par Remove

Trend et divisons les signaux d’E/S en 2 parties pour l’identification et la validation du modèle par les blocs Splite et Simulation.

L’identification du modèle linéaire GL est fait par le VI SI Estimate General

Linear Model.vi. L’ordre des différents polynômes est spécifié dans le cluster orders of GL model. Le bruit e(k) après identification peut être récupéré dans la sortie noise. Le VI Draw Model.vi permet d’afficher le modèle qui lie l’entrée u(k) et la sortie y(k)

en tenant compte du bruit e(k). Pour valider cette identification, ce bruit doit se rapprocher d’un bruit blanc. Nous traçons la fonction d’autocorrélation, le module de la transformée de Fourier et

calculons la moyenne et la variance de ce bruit.

Chapitre 15 / Identification 569

Dans ce panel, nous constatons que la fonction d’autocorrélation est une impulsion de

Dirac, ce qui montre que le système est bien modélisé. La fonction d’autocorrélation du bruit après identification est calculée par le VI

AutoCorrelation.vi qui se trouve dans la sous-palette Opérations sur les signaux de la palette Traitement du signal.

Le module de la transformée de Fourier est une fonction constante, ce qui valide encore que

le bruit e(k) n’est pas coloré. Le VI FFT.vi se trouve dans la sous-palette Transformées de Traitement du

signal. Nous avons tracé, dans le même graphe, les signaux de sortie du modèle d’origine ainsi que

celui obtenu par identification par le modèle linéaire général dont nous constatons la bonne similitude.

Nous avons choisi le modèle suivant :

)()(

1)()()()( 111 ke

qDkuqBkyqA

avec : 4

43

32

21

11 1)( qaqaqaqaqA

110

1)( qbbqB 5

54

43

32

21

11 1)( qdqdqdqdqdqD

L’ordre de F et celui de C sont égaux à 0, ces polynômes sont égaux à 1 :

1)( 1qF 1)( 1qC

Partie II / Conception de contrôle et simulation

570

Nous avons ainsi le schéma suivant :

Dans le panel suivant, nous affichons les signaux du stimulus et la sortie du modèle à

identifier. La fonction d’autocorrélation du résidu montre que celui-ci est un bruit blanc, ce qui valide

l’identification. Cette validation est confirmée par la FFT du bruit constante. Dans un autre graphe, nous traçons les sorties des modèles, identifié et à identifier, courbes

qui sont quasiment confondues. Dans model 2, nous affichons l’équation du modèle identifié, à savoir le modèle GL,

linéaire général.

Chapitre 15 / Identification 571

I.5. Identification des modèles ARX et ARMAX

Le modèle ARX, AutoRégressif avec modèle du bruit, correspond au modèle linéaire général lorsque 1)()()( 111 qFqDqC .

Nous avons alors le diagramme suivant :

qui correspond à l’équation suivante :

)()()()()()()()( 111 neknuqBnenuqBqnyqA k L’identification d’un modèle ARX se fait selon la méthode des moindres carrés. Le VI suivant permet d’identifier les modèles ARX et ARMAX, le choix se fait dans le

panel avec des 2 onglets. Nous utilisons, pour cela, une structure condition avec 2 choix qu’on peut sélectionner avec

le menu Commande onglets.

Nous calculons toujours l’autocorrélation du résidu de l’identification ainsi que le module

de sa transformée de Fourier. De plus, dans cet exemple, nous calculons et traçons la densité spectrale de puissance, à

l’aide du VI Auto Power Spectrum.vi qui est la transformée de Fourier de la fonction d’autocorrélation. Nous ajoutons un bruit uniforme d’amplitude 0.05 à la sortie du système, dans la boucle de simulation.

Dans le diagramme suivant, nous identifions les modèles ARX et ARMAX grâce à une

structure condition dont le sélecteur de condition est commandé par une commande d’onglets spécifiés sur le panel.

Partie II / Conception de contrôle et simulation

572

Le modèle à identifier est une fonction de transfert discrète de la sous-palette Discrète Linear Systems à laquelle nous appliquons la fonction de transfert constante :

)8.0(5.0)(

zzzzH

Pour créer cette entrée, Transfer Function, nous devons choisir Terminal pour Parameter source après un double clic sur ce bloc.

Le stimulus ou entrée de cette fonction de transfert est un bruit gaussien discret point par

point de la sous-palette Traitement du signal point par point Génération de signaux PPP.

A la sortie de cette fonction de transfert, nous ajoutons un bruit de distribution uniforme d’amplitude 0.05.

L’identification des modèles ARX et ARMAX se fait, respectivement, par les VIs SI Estimate ARX Model.vi et SI Estimate ARMAX Model.vi.

Pour valider l’identification, nous calculons et traçons la fonction d’autocorrélation du

résidu par le VI AutoCorrélation.vi de la sous-palette Traitement du signal

Opérations sur les signaux Autocorrélation. Le VI SI Model Simulation.vi, de la sous-palette Model Validation permet

de simuler le modèle identifié en recevant le même stimulus. La sortie de ce VI est tracée dans le même graphe que la sortie du modèle à identifier pour comparaison.

Dans le panel, nous choisissons les ordres des polynômes A, B et le retard k. La sortie du

modèle ARX identifié coïncide parfaitement à celle du système à identifier. La fonction d’autorrélation du résidu de l’identification est celle d’un bruit blanc

(impulsion de Dirac).

Chapitre 15 / Identification 573

La moyenne et la variance du résidu sont négligeables.

Nous retrouvons le pôle 0.8 du système ainsi que le zéro 0.5 avec le retard unité.

I.6. Identification du modèle AR (AutoRégréessif)

Le filtre AR sert à modéliser un signal, pour un processus dont le modèle ne possède pas le polynôme B(z-1) qui relie l’entrée à la sortie.

Ceci revient à filtrer l’entrée x par un filtre IIR dont le nombre de coefficients est égal au

degré du polynôme A avec a0=1.

)()()( 1 kykxzA

Dans le VI suivant, nous utilisons un signal numérique, entre 0 et 1, dit pseudo aléatoire sous forme de séquences.

Nous utilisons une séquence de longueur 63. Le modèle AR à identifier est représenté par un filtre IIR, grâce au VI IIR Filter.vi

de la sous-palette Traitement du signal Filters. Après suppression de la partie statique par Remove Trend, nous appliquons la sortie du

modèle AR à identifier à l’entrée response signal du VI Estimate AR Model.vi qui permet l’identification du modèle AR.

Partie II / Conception de contrôle et simulation

574

Les coefficients du modèle identifié peuvent être récupérés à la sortie coefficients of AR Model. Dans cet exemple, nous les avons obtenus par désassemblage du cluster system model out.

De même, pour valider l’identification par comparaison des sorties des modèles (à

identifier et identifié), nous n’avons pas utilisé le VI SI Model Simulation.vi. Nous récupérons le polynôme A en désassemblant le cluster coefficients. Comme nous les récupérons sous la forme d’une matrice, nous avons utilisé la fonction

Redimmensionner un tableau. Nous avons spécifié un tableau de 5 éléments. A l’aide de la fonction Construire de la palette Tableaux, nous traçons dans un

graphe la sortie du modèle AR à identifier et celle du modèle qui a été identifié. La sortie du modèle identifié est obtenue par la sortie d’un filtre IIR dont le polynôme est

celui qu’on a identifié. Dans le panel, nous affichons les polynômes A du modèle à identifier et celui qu’on obtient après identification. Nous constatons qu’ils sont quasiment identiques. Les sorties de ces modèles se confondent et la fonction d’autocorrélation est proche d’une impulsion de Dirac, comme celle d’un bruit blanc.

Tous ces résultats valident l’identification du modèle AR.

Chapitre 15 / Identification 575

Nous obtenons les mêmes résultats quant à la validation de l’identification du modèle ARMAX.

II. Identification par métodes récursives – Modèle de Box-Jenkins

Les VIs de l’identification par les méthodes récursives se trouvent dans la sous-palette Recursive Model Estimation.

Nous allons identifier le modèle BJ (Box-Jenkins) à partir de la sortie de la fonction de

transfert constante utilisée précédemment. L’équation suivante représente la forme du modèle de Box-Jenkins :

)()()()(

)()()( ke

zDzCku

zFzBqky n

C’est le modèle linéaire général dans lequel .1)(zA En utilisant l’opérateur retard 1z , les polynômes B, F, C et D sont définis comme suit.

)1(1

10 ...)( nbnb zbzbbzB

nfnf zfzfzF ...1)( 1

1 nc

nc zCzczC ...1)( 11

ndnd zDzdzD ...1)( 1

1 Le modèle de Box-Jenkins peut être déduit du modèle linéaire général si on pose A(q-1)=1.

On obtient le diagramme suivant :

:

Partie II / Conception de contrôle et simulation

576

:)(ku entrée du système, :)(ky sortie du système, :)(ke perturbation.

A l’aide des variables auxiliaires w(k) et v(k), nous pouvons établir les équations qui

définissent le modèle de Box-Jenkins dans le domaine temporel :

)()()( kvkwky )1(...)1()()(...)1()( 101 nbnbnf knkubnkubnkubnfkwfkwfkw

)(...)1()()(...)1()( 11 ncncnd kkeckeckendkvdkvdkv

Le modèle de Box-Jenkins est estimé par le VI SI Recursively Estimate BJ Model.vi.

Ce VI reçoit, en entrée, le stimulus et la réponse du système à identifier qui est défini par

un modèle d’état discret. En sortie, nous récupérons le modèle identifié et la sortie prédite. A cette sortie, nous

enlevons celle du système à identifier pour calculer le résidu de l’identification. L’équation du modèle identifié est affichée grâce au VI SI Draw Model.vi. Les matrices d’état sont représentées par un cluster constant en dehors de la boucle de

contrôle et simulation. Les valeurs des matrices A, B, C et D sont spécifiées dans le cluster vide obtenu en

choisissant Créer constante sur la 2ème entrée du bloc Discrete State-Space. L’entrée de ce bloc ou stimulus est un bruit gaussien centré d’écart-type 1. A la sortie de ce

système, on ajoute un bruit uniforme d’amplitude 0.05. A la sortie de la boucle, on obtient un cluster qu’on désassemble pour récupérer les signaux

stimulus et sortie du système à identifier. Le VI Remove Trend.vi permet de supprimer les valeurs moyennes et statiques de

ces signaux. Le VI Split Signal.vi coupe ces signaux en 2 parties : une qui sert à l’identification du système et une autre pour la validation de cette identification.

Le VI SI Model Simulation.vi permet de simuler le modèle identifié en utilisant le

même signal stimulus et le cluster définissant le modèle identifié. La sortie de ce VI est une waveform dont on récupère le signal Y qu’on trace en même

temps que la sortie du modèle à identifier. Un autre moyen de valider la qualité de l’identification est de tracer la fonction

d’autocorrélation du résidu de l’identification. Si cette autocorrélation est une impulsion de Dirac, cela veut dire que le résidu est un bruit

blanc, auquel cas l’identification est validée.

Chapitre 15 / Identification 577

L’équation du modèle à identfier est obtenue après la construction du modèle d’état grâce

au VI CD Construct State-Space.vi qui construit le modèle d’état à partir des matrices A, B, C et D. La valeur « -1 » de l’entrée Sampling Time signifie que le système est discret. Les matrices sont obtenues par désassemblage du cluster qui définit le cluster constant du modèle d’état à identifier. L’équation de ce modèle d’état est obtenue par le VI CD Draw State-Space Equation.vi.

Dans le panel suivant, nous affichons l’équation du modèle d’état définissant le modèle à identifier. Dans l’oscilloscope Sorties, nous affichons à la fois la sortie du modèle à identier et celle du modèle identifié. Ces 2 signaux sont quasiment confondus, la fonction d’autocorrélation est une impulsion de Dirac, ce qui valide l’identification. Les coefficients du modèle identifié sont affichés dans le cluster Coefficients of BJ Model et dans l’équation Model BJ. Les ordres des polynômes B, F, C et D ainsi que le retard delay sont spécifiés dans le cluster Orders of BJ Model.

Partie II / Conception de contrôle et simulation

578

III. Identification par Grey-Box

Ce type d’identification permet de compléter la modélisation d’un système partiellement connu. Pour ceci, nous avons besoin de créer la boite noire sous forme d’une fonction de transfert ou de modèle d’état.

L’identification se fait grâce au VI Estimate State-Space Model ou Transfer Function.

Dans le VI suivant, nous générons la réponse indicielle d’une fonction de transfert, qui

représente celle d’un processus réel, en ajoutant à sa sortie un bruit gaussien. La lettre C qui s’affiche sur l’icône de ce VI signifie qu’il génère un signal continu. Pour le

désigner ainsi, nous choisissons Continuous dans l’option Configuration du nœud du sous-VI… dans le menu local.

Nous pouvons également le choisir discret par Discrete.

Chapitre 15 / Identification 579

La réponse indicielle est la sortie de ce système en lui appliquant un signal carré point par point grâce au VI Square Wave PtByPt.vi.

Nous décidons d’approximer le système selon un 1er ordre dont nous estimons, de façon approximative, la constante de temps par la régle des 63% et le gain statique.

Pour filtrer le bruit, nous utilisons un filtre de Butterworth passe-bas d’ordre 2, grâce au VI Butterworth Filter.vi.

Le panel suivant montre la sortie brute du système ainsi que sa forme filtrée sur des graphes

XY. Nous constatons que le filtre a pour inconvénient d’augmenter la constante de temps du

processus qu’on estime être de type du 1er ordre. Comme c’est un filtre passe-bas, il ne modifie pas le gain statique. La mesure de la constante de temps se fait grâce à l’utilisation des curseurs.

Partie II / Conception de contrôle et simulation

580

Dans le VI suivant, nous identifions un modèle du 1er ordre pour ce processus. Le VI SI Create Partially Known Continuous Transfer Function

Model.vi permet de créer un modèle de fonction de transfert du 1er ordre partiellement connu dont la constante de temps et le gain statique sont connus entre 2 valeurs limites, haute Uper limit et basse Lower limit.

L’identification du modèle de fonction de transfert continu se fait par le VI SI

Estimate Partially Known Continuous Transfer Function Model.vi. En sortie de ce VI, nous trouvons le cluster définissant le modèle identifié ainsi que le

cluster de ses coefficients. Afin de tracer la réponse indicielle et le diagramme de Bode, nous avons calculé le modèle

de la fonction de transfert. Nous avons tracé les diagrammes de Bode et les réponses indicielles du modèle identifié et

celui à identifier, grâce aux VIs CD Bode.vi et CD Step Response.vi des sous-palettes Control Design Frequency Response et Control Design Time Response.

Le panel suivant affiche les clusters des valeurs, basse et haute, du gain statique et de la

constante de temps ainsi que les tracés de la réponse indicielle et du diagramme de Bode. Les courbes du modèle à identifier et et celles du modèle identifié sont quasiment

confondues.

Chapitre 15 / Identification 581

IV. Nonparametric Model Estimation (estimation non paramétrique)

L’identification non paramétrique consiste à chercher les réponses, impulsionnelle et fréquentielle, du modèle à identifier.

On ne cherche pas, dans ce cas, des modèles paramètriques, comme les modèles AR, ARX

ou Box-Jenkins, etc.

Dans le VI suivant, nous avons utilisé un filtre passe-bande à 32 coefficients dont le

stimulus est signal aléatoire gaussien. Dans la 1ère étape de la structure séquence déroulée, nous sauvegardons le tableau formé du

stimulus et de la sortie du filtre dans un fichier tableur dans un chemin défini par la constante chemin chemin du fichier.

Dans la 2ème étape, nous lisons ce fichier par le VI SI Read From File.vi de la sous-palette Utilities.

Le type du fichier à lire, fichier tableur ou spreadsheet text file est spécifié par le menu file type de type Ring.

Le VI Estimate Frequency Response.vi permet d’obtenir la réponse en

fréquences du système dont l’entrée et la sortie sont, respectivement, stimulus signal et response signal.

Partie II / Conception de contrôle et simulation

582

En sortie de ce VI, nous récupérons l’amplitude et la phase de la réponse en fréquences.

Le VI, de type Express, SI Transfer Function Estimation, permet d’obtenir

l’estimation de la fonction de transfert reliant le même signal stimulus au même signal de sortie.

Dans le panel suivant, nous retrouvons bien les mêmes fréquences de la bande passante du

filtre, 200 et 400 Hz. Dans model, nous affichons l’équation de la fonction de transfert identifiée par le VI

Express SI Transfer function Estimation.

Chapitre 15 / Identification 583

V. Model Management (gestion des modèles)

La gestion des modèles consiste à les créer (Create Model), les vérifier (Check Model), les sauvegarder/charger (Save/Load Model), leur adjoindre du bruit (Get/Set Noise Covariance), les échantillonner (Set Sampling Rate), spécifier leur gain statique (Get Static Gain), etc.

D’autres VIs permettent de récupérer leurs ordres (Get Orders), leurs coefficients (Get

Coeffs), la covariance du bruit associé (Get Noise Cov), récupérer leur période d’échantillonnage (Get Sampling Rate), etc.

V.1. Exemple 1 – Management

Dans le diagramme suivant, nous allons utiliser des VIs dédiés à la validation de

l’identification des modèles ARX et ARMAX. Le modèle à identifier est défini par une fonction de transfert discrète (sous-palette Discrete

Linear Systems) dont Parameter source est défini comme Terminal. Ceci nous permet d’avoir l’entrée supplémentaire Transfer Function à laquelle nous

avons appliqué la fonction de transfert constante suivante :

)8.0(5.0)(

zzzzH

Cette fonction de transfert est spécifiée dans le cluster constant Analog Transfer

Function Model dans lequel nous n’avons pas défini les propriétés (noms des entrées, des sorties, notes, etc.).

Nous avons seulement spécifié la valeur 1 de la cadence d’échantillonnage (Sampling Time).

Le stimulus est un signal aléatoire gaussien d’écart-type unité. A la sortie du système, nous

avons ajouté un bruit uniforme d’amplitude 0.05.

Partie II / Conception de contrôle et simulation

584

Le choix de l’un de ces modèles, se fait à l’aide d’une structure condition commandée à l’aide des onglets définis dans le panel par la commande Commande onglets.

La variance du résidu de l’identification est calculée par le VI SI Get Noise Covariance for System Model.vi.

Le modèle est validé par le VI SI Check System Model.vi dont la sortie est une

valeur logique (1, Vrai, Valide/0, Faux, Modèle non valide). Nous avons utilisé une structure séquence déroulée dont la 1ère étape sert à enregistrer le

modèle identifié sur le bureau sous le nom sauve_modèle_ARX. Cet enregistrement se fait par le VI SI Save System Model to File.vi. Nous n’avons rien spécifié dans la constante chemin file path afin d’avoir à le choisir

dans les répertoires du disque. Dans la 2ème étape, on lit ce modèle en choisissant le même nom du fichier .sim dans le

répertoire choisi. Une fois ce fichier lu par le VI SI Load System Model from File.vi nous

avons tracé la fonction d’autocorrélation du résidu de l’identification, de crosscorrélation entre ce résidu et le stimulus ainsi que l’erreur de prédiction.

En-dessous de cette structure séquence déroulée, nous avons utilisé des VIs spécifiques afin

d’obtenir les coefficients du modèle identifié (SI Get Coefficients from System Model.vi) ainsi que ses dimensions (SI Get Dimensions of System Model.vi).

Chapitre 15 / Identification 585

Dans le panel, nous affichons les fonctions d’autocorrélation du résidu de l’identification, crosscorrélation entre ce résidu et le signal stimulus ainsi que l’erreur de prédiction.

L’autocorrélation, sous forme d’impulsion de Dirac, signifie que le résidu de

l’identification est un bruit blanc, ce qui valide l’identification. Ce résidu est affiché dans la courbe de l’erreur de prédiction. La corrélation entre le stimulus et le résidu de l’identification. Ceci signifie qu’il n’y a

aucune information qui lie ces 2 signaux, ce qui valide, encore une fois, cette identification. Les dimensions recherchées sont le nombre des entrées et des sorties. Ce système à une

entrée et une sortie est dit SISO (Single Input Single Output). Nous affichons également les coefficients du modèle identifié dans le cluster

coefficients of ARX model. L’équation de ce model ARX est affichée dans model. Ce modèle est validé par

l’allumage de la LED Valid. Le VI SI Get Type of System Model.vi donne le type du modèle identifié, ici

ARX (SISO), soit un modèle ARX à une entrée et une sortie. Le VI SI Get Dimensions of System Model.vi permet de déterminer le

nombre d’entrées et de sorties du modèle identifié.

Partie II / Conception de contrôle et simulation

586

V.2. Exemple 2 – Management

Dans le VI suivant, nous construisons un modèle d’état de type SISO grâce au VI SI Create System Model.vi.

Nous devons, pour cela, spécifier le type de modèle que nous voulons créer, ici un modèle

d’état, SISO, à une entrée et une sortie. Pour spécifier ses coefficients nous utilisons le VI SI Set Coefficients to

System Model.vi. A l’entrée coefficients of state-space model, nous appliquons le cluster

constant définissant le modèle d’état suivant :

)(01)(

)(5.0

1)(

0018.0

)1(

kxky

kukxkx

En sortie, nous obtenons le modèle pour lequel nous appliquons les VIs de la sous-palette

Management. Avec les VIs SI Set Names et SI Set Notes to Systems Model, nous pouvons

créer des noms pour les entrées/sorties et des notes pour le système. Le VI SI Get Type of System Model.vi, nous donne accès au type du système.

La validité du système s’obtient par le VI SI Check System Model.vi, la sortie est de type logique (Vrai/Faux ou 0/1).

D’autres VIs permettent de tester la validité du système et d’obtenir leurs dimensions

(nombre d’entrées/sorties). Le modèle identifié est un cluster qui contient beaucoup d’éléments qui définissent le

système. Dans ce VI, nous affichons quelques uns de ces éléments :

- les attributs (le type de modèle, les noms des entrées, les notes),

- les coefficients du modèle (matrices d’état),

- la fréquence d’échantillonnage,

- les zéros et les pôles qui sont vides dans le cas d’un modèle d’état,

- le retard, vide aussi parce que le système n’en a pas à l’origine. Tous ces éléments sont regroupés dans le cluster cluster de sortie 2.

Chapitre 15 / Identification 587

Le cluster cluster de sortie 2, contient le cluster attributes, le cluster

coefficients, la fréquence d’échantillonnage, un cluster contenant les zéros, les pôles et le délai.

Le type du modèle State-Space (SISO) est un modèle d’état à une entrée et une sortie. Nous retrouvons les mêmes chaînes de caractères définissant l’entrée (input names) et la sortie du système (output names) ainsi que les notes définissant le système.

Nous retrouvons également les matrices A, B, C et D du modèle d’état qui prennent la place des polynômes A, B, C et D du polynôme linéaire général. Comme il n’y a pas d’élément noté F, ce dernier est vide. Le cluster zeros-poles est également vide car il s’agit d’un modèle d’état. La LED valid est allumée, signifiant que le modèle d’état est valide.

Partie II / Conception de contrôle et simulation

588

VI. Dataprocessing (traitement des données)

Le traitement des données consiste à supprimer les valeurs statiques d’un signal (Remove Trend), leur passage par un filtre passe-bas (Lowpass Filter), passe-bande (Bandepass Filter), diviser un signal en deux parties (Split Signal), etc.

Dans la partie gauche du VI suivant, nous traçons l’histogramme d’un signal x gaussien

centré (moyenne nulle), réduit (écart-type unité) ainsi que celui du signal (2x+5). Ces histogrammes sont obtenus grâce au VI Express Créer un histogramme. Le VI SI Remove Trend.vi permet de supprimer la valeur moyenne et les parties

statique d’un signal. Nous avons utilisé ce VI pour le signal (2x+5). Le centrage et la réduction d’un signal ou normalisation se fait grâce au VI SI

Normalize.vi. Dans la boucle de contrôle et simulation, nous avons utilisé une fonction de transfert

continue du 1er ordre dans une boucle fermée et une boucle ouverte. L’entrée de ces boucles est un signal gaussien continu.

Les signaux d’entrée et de sortie forment le stimulus et le signal de sortie qu’on applique au

VI SI Detect Feeback.vi pour détecter la présence d’une boucle entre ces deux signaux.

Chapitre 15 / Identification 589

Théoriquement, la moyenne de ce signal est 5 et sa variance de 4, proches des valeurs obtenues dans le panel. La distribution gaussienne ne change pas par cette relation linéaire.

En utilisant le VI Remove Trend, la variance ne change pas, par contre, le signal est débarassé de sa composante continue.

La LED feedback exists ? est bien allumée, indiquant la présence d’une boucle

alors que la LED feedback exists ?2 est éteinte dans le cas de la boucle ouverte. Le signal normalisé par le VI SI Normalise.vi, est bien centré (moyenne nulle) et

réduit (écart-type unité).

VII. Model Validation

La sous-palette Model Validation contient des outils permettant de valider une identification. On trouve des VIs qui permettent de simuler le signal de sortie avec le même stimulus que celui utilisé lors de l’identification et en utilisant le modèle identifié.

Ce VI peut utiliser des tableaux (Array) ou des waveforms. On peut simuler des systèmes

SISO, MISO ou MIMO. Nous pouvons également tester l’erreur résiduelle afin de calculer ses paramètres

statistiques (moyenne, variance, auto et crosscorrélation).

Partie II / Conception de contrôle et simulation

590

Dans le VI suivant, nous avons appliqué un signal gaussien discret à un modèle d’état discret dont les matrices d’état A, B, C et D sont spécifiées dans un cluster constant.

Pour avoir l’entrée supplémentaire State-Space, nous devons choisir Terminal pour Parameter source après un double clic.

Dans ce VI, nous avons identifié un modèle de Box-Jenkins en utilisant le modèle d’état discret précédent. Après avoir supprimé la partie statique par Remove Trend.vi et tansformé les signaux du stimulus et de la sortie en 2 parties (une pour l’identification et une autre pour la validation) par Split Signal, nous avons réalisé l’identification avec le VI Recursively Estimate BJ Model.vi. En utilisant le même stimulus et avec le modèle identifié, nous simulons des valeurs que nous comparons avec celles du modèle à identifier en les traçant dans le même graphe. Le VI SI Model Prediction.vi permet de calculer la valeur prédite par le modèle identifié qu’on trace dans un même graphe.

La sortie MSE correspond à l’erreur quadratique moyenne. Le résidu de l’identification est obtenu grâce au VI SI Model Residual

Analysis.vi. En sortie, nous avons ses valeurs, son autocorrélation et sa crosscorrélation avec le stimulus.

Chapitre 15 / Identification 591

Les valeurs du résidu de l’identification sont très faibles, son autocorrélation est une impulsion de Dirac, la courbe de la crosscorrélation entre ce résidu et le stimulus sont négligeables.

Le signal prédit par le modèle identifié et la réponse du modèle d’état sont quasiment confondus.

VIII. Model Conversion

La sous-palette Model Conversion contient des VIs qui permettent de convertir un système continu à un système discret et inversement, un modèle d’état en fonction de transfert et inversement, etc.

VIII.1. Exemple 1 - Model Conversion

Dans la partie 1 du VI suivant, nous avons créé un système à partir du VI Create System Model.vi pour lequel on précise que c’est une fonction de transfert en indiquant Transfer Function (SISO) dans le menu de l’entrée Model Type.

Les valeurs de la fonction de transfert sont spécifiées grâce au VI SI Set

Coefficients to System Model.vi. Le VI SI Set Sampling Rate to System Model.vi permet de spécifier la

fréquence d’échantillonnage, dans notre cas nous avons transformé le système discret en système continu.

Le VI Convert Continuous to Discrete Model.vi permet de convertir un système continu en un système discret dont on spécifie la valeur de la fréquence d’échantillonnage.

La discrétisation de la fonction de transfert :

pH

pH1

)( 0

donne le système discret suivant :

11

11

1)(

zabzH

Partie II / Conception de contrôle et simulation

592

avec /1

Tea et 11 1 ab Nous retrouvons les mêmes valeurs suivantes sur le panel.

La récupération de la fréquence d’échantillonnage se fait grâce au VI SI Get

Sampling Rate from Model System.vi. Nous retrouvons bien la valeur 0. Dans la partie 2, nous transformons la fonction de transfert en modèle d’état grâce au VI

Model Conversion.vi en spécifiant que la conversion se fait en une fonction de transfert.

Nous vérifions la validité de cette conversion en calculant le modèle d’état correspondant à

la fonction de transfert obtenue par cette conversion. A partir de la fonction de transfert :

)8.01(5.0

8.01)5.01(

)()()( 1

11

zzz

zzz

kukyzH

la sortie y(k) est liée à l’entrée u(k) par l’expression suivante:

)2(5.0)1()1(8.0)( kukukyky En écrivant

)()(1 kykx

nous obtenons : )1(5.0)()(8.0)1( 11 kukukxkx

On choisit : )()()(8.0)1( 211 kukxkxkx

avec )(5.0)1(2 kukx Nous obtenons alors le modèle d’état suivant :

)(5.0

1)()(

0018.0

)1()1(

2

1

2

1 kukxkx

kxkx

et )()(

01)(2

1

kxkx

ky

Nous trouvons bien ce même modèle avec la conversion. Dans la partie 3, nous transformons le modèle d’état discret en modèle d’état continu grâce

au VI SI Convert Discrete to Continous Model.vi.

Chapitre 15 / Identification 593

Sur le panel suivant, nous affichons la fonction de transfert continue du 1er ordre et la

fréquence d’échantillonnage. Equation discrète correspond à l’équation de la fonction de transfert discrète obtenue par échantillonnage à 1s. A droite, nous affichons le modèle d’état discret et la fonction de transfert obtenue par conversion du modèle d’état en fonction de transfert.

Partie II / Conception de contrôle et simulation

594

VIII.2. Exemple 2 - Model Conversion

Dans le diagramme suivant, nous avons défini la fonction de transfert suivante dans un cluster constant :

ppH

2011)(

Pour montrer qu’il s’agit d’une fonction de transfert continue, nous avons spécifié la valeur 0 pour la période d’échantillonnage (Sampling Time).

Nous avons, également, défini les propriétés du système, à savoir les noms des entrées/sorties (Input names et Output names) ainsi que le nom du modèle (Model name) et les notes (Notes). Cette fonction de transfert est convertie en modèle d’état. La sortie et l’entrée sont liées par l’équation différentielle suivante :

)()(20)( tutyty soit :

20)(

20)()( tutyty

En notant ),()(1 tytx nous obtenons : )(05.0)(05.0)( 11 tutxtx

Les matrices d’état, scalaires, sont les suivantes :

0,1,05.0,05.0 DCBA

Dans le diagramme suivant, nous avons réalisé la conversion de la fonction de transfert continue vers un modèle d’état discret, échantillonné à 1s. La discrétisation se fait en utilisant un bloqueur d’ordre 0. Avec le VI CD Draw, nous affichons l’équation du modèle d’état. Nous avons aussi tracé la réponse indicielle de ce modèle d’état et celle du modèle d’état théorique. Nous les avons tracées dans le même graphe XY.

Le modèle d’état théorique est spécifié dans un cluster constant obtenu en sélectionnant l’option Créer Constante en pointant l’entrée State-Space Model du VI CD Step Response.vi à l’aide de la souris sous forme de bobine.

Chapitre 15 / Identification 595

Sur le panel, nous affichons l’équation de la fonction de transfert du 1er ordre continue ainsi que celle du modèle d’état équivalent.

Nous avons également affiché le modèle d’état discret obtenu par discrétisation de cette fonction de transfert continue.

Comme nous n’avons pas trouvé le même modèle d’état théorique, nous avons tracé, pour comparaison, les réponses indicielles du modèle d’état discret obtenu par discrétisation et du modèle d’état théorique précédent. Comme le modèle d’état n’est pas unique, à l’aide du VI CD Similar State-Space Models.vi, nous pouvons tester si deux modèles d’état sont égaux ou simplement similaires. Deux modèles d’état ne peuvent être similaires que s’ils possèdent, au moins, la même matrice d’état A car elle contient les pôles du système dans ses valeurs propres.

La LED similar ? est allumée tandis que la LED equal ? est éteinte, signifiant que les 2 modèles d’état ne sont pas égaux, juste similaires. Lorsque deux modèles d’état sont similaires, ils possèdent les mêmes réponses temporelles et fréquentielles.

IX. Model Analysis

La sous-palette Model Analysis permet d’analyser le modèle par le tracé du diagramme de Bode, le lieu des pôles et zéros et le diagramme de Nyquist.

Partie II / Conception de contrôle et simulation

596

Dans le diagramme suivant, nous avons créé une fonction de transfert grâce au VI SI Create System Model.vi pour lequel on choisit l’option Transfer Function (SISO) pour l’entrée model type.

Les coefficients de cette fonction de transfert sont spécifiés par un cluster constant à

l’entrée coefficients of transfer function model du VI SI Set Coefficients to System Model.vi.

Nous obtenons le modèle de fonction de transfert pour laquelle nous traçons le diagramme

de Bode (amplitude et phase). Nous avons également tracé le diagramme de Nyquist, lieu des pôles et des zéros ainsi que

le diagramme de Bode en utilisant le VI SI Bode Plot.vi. Nous avons ensuite tracé la réponse indicielle en utilisant le VI CD Step

Response.vi. Ce VI a besoin de la fonction de transfert qu’on définit par un cluster constant, obtenu par

le choix Créer Constante lorsqu’on pointe la souris sous la forme de bobine sur l’entrée Transfer Function Model.

Ce cluster contient les propriétés, la valeur de la période d’échantillonnage (Sampling

Time) qu’on définit égale à « -1 » pour signifier une fonction de transfert discrète dont la fréquence d’échantillonnage est inconnue.

L’intervalle de temps sur lequel nous traçons la réponse indicielle est spécifié dans un

cluster constant.

Sur le panel, nous affichons le diagramme de Bode (amplitude et phase), le diagramme de

Nyquist, le lieu des pôles et des zéros ainsi que la réponse indicielle. L’afficheur Equation correspond à l’équation de la fonction de transfert discrète.

Chapitre 15 / Identification 597

X. Utilities (Utilitaires)

Dans cette sous-palette Utilities, nous trouvons quelques VIs utiles pour l’identification des systèmes.

Nous trouvons :

- le VI Draw Model pour l’affichage de l’équation du modèle (fonction de tansfert ou modèle d’état),

- le générateur de séquences binaires pseudo aléatoires (PRBS : Pseudo Random Binary Sequence) qui approche un signal aléatoire, riche en fréquences afin d’exciter tous les modes du process à identifier,

- Le VI de lecture du modèle à partir d’un fichier.

Partie II / Conception de contrôle et simulation

598

Si nous spécifions une valeur de tps_error plus petite que la durée de simulation (paramètre Final Time de la boucle de contrôle et simulation), nous obtenons le message d’erreur suivant.

Ainsi, lorsqu’on atteint cet instant, le bloc Report Simulation Error affiche le

message d’erreur suivant. Ce message correspond à l’élément source du cluster d’erreur. Ce cluster se trouve dans la

condition vraie de la structure condition. Le sélecteur de condition reçoit une valeur vraie (1 logique) lorsque la valeur du signal

Chirp devient plus grand que 0.4 et que le temps de simulation (obtenue en sortie du bloc Simulation Time) et supérieure à cette valeur tps_error.

Tant que cet instant limite n’est pas atteint, la structure condition reçoit une valeur fausse (0

logique), ce qui envoie un message d’erreur faux, ce qui n’arrête pas la simulation et qui n’affiche aucun message.

Le bloc Collector permet de collecter le temps de simulation et les valeurs

correspondantes du signal Chirp. Le bloc Halt Simulation permet d’arrêter la simulation lorsqu’il reçoit un 1 logique

ou lorsqu’on appuie sur le bouton Halt ?. Le bloc Simulation Parameters permet de récupérer les paramètres de simulation.

Nous les affichons dans le cluster Simulation Parametres 2. Nous y trouvons la durée de simulation (Final Time=128), le solveur (Solver

Method=Runge Kutta), le temps de simulation (128 après l’arrêt de la simulation), etc.

Chapitre 15 / Identification 599

Sur le panel, nous trouvons le cluster des paramètres de simulation, le temps de simulation, le bouton d’arrêt et la courbe du signal Chirp.

Dans le diagramme suivant, nous allons étudier quelques autres utilitaires d’identification. Le modèle à identifier est symbolisé par la fonction de transfert discrète du 1er ordre suivante :

1

11

11

121

11

8.01)5.01(

1)()(

zzz

zazbbzzH

Le système est défini par une fonction de transfert constante Transfer Function Model. Nous avons spécifié uniquement le numérateur et le dénominateur ci-dessus. La valeur ‘-1’ signifie que la fonction de transfert est discrète avec une période d’échantillonnage inconnue. Le même stimulus, un signal gaussien centré d’écart-type unité est appliqué à cette fonction de transfert et aux VIs ARX ou ARMAX que l’on choisit dans le panel par Commande onglets.

Partie II / Conception de contrôle et simulation

600

Nous avons étudié précédemment l’identification par les modèles ARX et ARMAX. Dans cet exemple, les VIs SI Get Noise Covariance et SI Check System permettent, respectivement, de calculer la covariance (ici la variance) du résidu de l’identification et de tester la validité du modèle identifié. Le modèle peut être sauvegardé ou lu sous forme de fichier *.sim.

Dans cet exemple,, nous obtenons une variance très petitte de l’erreur d’idntification. Cette erreur est nulle, son autocorrélation est celle d’un bruit blanc sous forme d’une impulsion de Dirac. La LED valid est allumée signifiant que le modèle identifié est valide. La crosscorrélation entre le stimulus et l’erreur d’identification est aussi nulle, signifiant que cette erreur est un bruit blanc.

Partie II. Chapitre 16 - PID

I. PID classique et processus du second ordre I.1. PID analogique I.2. PID discret II. Régulation PID de type académique III. Advanced PID IV. Sous-système de simulation d’un PID parallèle V. Applications V.1. Régulation PI analogique V.2. Régulation PID V.3. Discrétisation d’un régulateur PI analogique par la méthode de Tustin V.4. Régulateur PI discret sous sa forme parallèle V.5. Régulateur PID discret parallèle VI. Régulation de position – Moteur à courant continu VI.1. Réponse indicielle de vitesse et de position VI.2. Régulation de la vitesse angulaire par placement de pôles VI.2.1. Compensation de pôles, placement de pôles avec action intégrale VI.2.2. Placement de pôles dans l’espace d’état VI.2.3. Régulation PID de la position VII. Modélisation d’un système multivariable VII.1. Simulation et contrôle d’un système multivariable VII.2. Fonction de transfert multivariable VII.3. Réponses indicielles du système multivariable VII.4. Régulation PID du système multivariable

601DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _16,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie II / Conception de contrôle et simulation

602

La sous-palette PID contient beaucoup de structures de ce régulateur.

L’implémentation du régulateur se fait selon l’expression suivante de la commande u(t) :

t

dttdTddtt

TitKptu

0

)()(1)()(

Ainsi, les 3 actions (proportionnelle, intégrale et dérivée) de ce régulateur, sont

représentées par les commandes uP(t), uI(t) et uD(t) suivantes :

)()( tKptuP dttTiKptu

t

I 0)()(

dttdTdKptuD)()(

L’erreur )(t est la différence entre la consigne ou référence )(tr et la sortie du processus :

)()()( tytrt

L’intégration est calculée selon la méthode trapézoïdale :

tieieTiKpku

k

iI

1 2)1()()(

A cause des changements abrupts dans la consigne, la dérivée est appliquée uniquement sur la sortie et non pas sur l’erreur )(t , c’est ce qu’on appelle l’action dérivée partielle.

Cette action dérivée partielle est représentée par l’expression suivante :

))1()(()( kykyt

TdkpkuD

I. PID classique et processus du second ordre

Ce VI implémente un simple algorithme PID. Ses entrées sont la consigne (setpoint), la sortie du processus (process variable)

et les gains (proportionnel, intégral et dérivée). La sortie outpout correspond à la commande qui sera appliquée au processus.

Chapitre 16 / PID

603

I.1. PID analogique

On se propose de réguler un système du second ordre dont la fonction de transfert est

obtenue par Transfer Function dans la sous-palette Continuous Linear Systems.

En cliquant droit sur cette fonction de transfert on choisit le style Dynamic dans le menu

local.

En double cliquant sur cette fonction de transfert, on obtient la boite de dialogue dans

laquelle on spécifie les coefficients de son numérateur et dénominateur.

Par un clic droit sur le VI PID.vi, on fait apparaître le menu local dans lequel on choisit

l’option Configuration du nœud du sous-VI … .

Partie II / Conception de contrôle et simulation

604

On coche la case Continuous pour spécifier la nature continue de ce régulateur.

La lettre C apparaît alors sur le bloc PID. On choisit une consigne échelon dans la sous-

palette Signal Generation. On affiche dans un même Waveform Graph le signal de sortie en même que la consigne

ainsi que le signal d’erreur et la commande dans un autre waveform Graph. Un cluster d’entrée constant est appliqué au nœud d’entrée de la boucle de contrôle et

simulation. On affiche un cluster d’erreur de sortie par le nœud de sortie de la boucle.

Dans le panel les coefficients du PID sont spécifiés dans un cluster sous forme de bouton

rotatif et de glissières. Le signal de sortie oscille avant de se stabiliser sur la consigne en régime permanent. Le

signal de commande accuse aussi le même nombre d’oscillations.

Chapitre 16 / PID

605

I.2. PID discret

En cliquant droit sur ce VI, on choisit l’option « Configuration du nœud du sous-VI… ».

On coche la case Discrete pour spécifier un PID discret et une période d’échantillonnage de 1s.

L’apparition de la lettre D sur le VI PID.vi montre que ce PID est un régulateur discret.

L’entrée PID Gains est reliée au cluster PID Gains dans lequel on spécifie les gains

des actions, proportionnelle, intégrale et dérivée. Ce cluster est créé dans le panel. L’entrée dt est reliée à la même valeur appliquée à l’entrée t du nœud d’entrée de la boucle de

Partie II / Conception de contrôle et simulation

606

contrôle et simulation. Le processus est spécifié par sa fonction de transfert discrète de la sous-palette Discrete Linear Systems.

On choisit le style Express dans le menu local avec Icon Style.

A l’instant t=50, on crée une perturbation sur la sortie en lui ajoutant la valeur 10. Ceci est

effectué grâce à la structure condition qui agit sur la condition t==50, le temps étant donné par Simulation Time.

Le panel affiche la sortie du processus et la consigne ainsi que l’erreur et le signal de

commande.

Chapitre 16 / PID

607

Nous avons également tracé la même courbe de la sortie du processus et de la consigne dans un graphe XY en dehors de la boucle grâce au bloc Collector qui permet d’associer le signal au temps de simulation.

Lorsqu’on ajoute un terme « dérivée », le dépassement diminue. L’inconvénient de la

dérivée a lieu lors de grandes variations de la consigne. Il n’y a aucun effet en régime permanent pour lequel nous retrouvons les mêmes valeurs en

régime permanent dans tous les exemples de ce PID discret.

Lorsqu’on augmente le terme « intégrale », le temps de réponse diminue, le nombre

d’oscillations augmente au rejet des perturbations, comme celle qui a lieu au temps t=50.

Partie II / Conception de contrôle et simulation

608

II. Régulation PID de type académique

Dans ce diagramme, nous utilisons le VI PID Structure Conversion.vi qui permet de convertir les paramètres du PID académique en ceux des PID de type parallèle ou série. Dans cet exemple, nous avons choisi le type académique, ce qui ne modifie pas les valeurs des paramètres d’origine.

Nous avons également utilisé le PID avancé que nous utilisons avec ses paramètres par

défaut. Le VI PID Setpoint Profile.vi permet d’établir un profil de consigne, à savoir un tableau qui associe le temps à un tableau de valeurs de la consigne.

Les paramètres du PID sont spécifiés dans un cluster sur le panel. Ce cluster est

désassemblé pour fournir ces coefficients au VI PID Structure Conversion.vi.

Dans ce diagramme, nous régulons, par ce type standard du PID, un système discret du 1er

ordre défini par son équation de récurrence :

)2()1()1()( 211 kubkubkyaky Les paramètres a1, b1 et b2 sont des entrées de la boite de calcul, obtenus par désassemblage

du cluster process parameters. Les paramètres du régulateur PID sont aussi issus du désassemblage du cluster PID

Gains. Ces 2 clusters sont définis dans le panel. A partir des gains du PID du type académique nous pouvons obtenir ceux des PID de type

parallèle et série. Cette conversion se fait grâce au VI Structure Conversion.vi. Dans notre cas, comme nous sommes restés dans le même type académique, les paramètres

en sortie de ce VI sont les mêmes que ceux que nous avons spécifiés dans le panel. Le PID académique est défini par la fonction de transfert suivante :

Chapitre 16 / PID

609

)1

11()()(

pTpT

pTK

ppU

f

d

ip

La dérivée est filtrée par le filtre du 1er ordre :

11pTf

.

La fonction de transfert du PID parallèle est la somme des 3 actions, proportionnelle, intégrale et dérivée :

11

)()(

pTpT

pTK

ppU

f

d

ip

Le PID de type série est la mise en cascade de ces 3 actions :

11

)11()()(

pTpT

pTK

ppU

f

d

ip

Tous ces régulateurs possèdent l’action intégrale qui permet d’annuler l’erreur en régime

permanent. Dans le panel suivant, nous affichons les clusters de paramètres et des coefficients du PID

ainsi que les courbes de la consigne et du signal de sortie du processus ainsi que l’erreur et le signal de commande.

A chaque saut de consigne, on observe des oscillations puis le signal de sortie rejoint

parfaitement la consigne, en régime permanent.

III. Advanced PID

Le PID avancé possède 3 paramètres, supplémentaires par rapport au PID classique, Alpha, Beta et Gamma.

Le paramètre Alpha spécifie la constante de temps du filtre de la dérivée. Sa valeur est

comprise entre 0 et 1 ou NaN (Not a Number) ; ce qui correspond au cas où aucun filtre n’est appliqué à la dérivée.

Partie II / Conception de contrôle et simulation

610

Beta est comprise entre 0 et 1. Ce paramètre spécifie la dynamique de rejet des perturbations. Gamma pondère l’erreur appliquée à l’action dérivée. Ceci permet d’éviter l’augmentation

de l’effet de cette action au changement brusque de la consigne. Linéarité spécifie la linéarité de la réponse de l'erreur. Ce paramètre est aussi compris

entre 0 et 1. La valeur 1 signifie une réponse linéaire de cette erreur, tandis qu’une valeur proche de 0 signifie une réponse sous forme d’une parabole.

Ce VI se présente, comme suit avec ses entrées-sorties :

Dans ce VI, nous considérons les valeurs suivantes :

Gamma = 0.8 ; Alpha = 0.5, Linéarité = 1, Beta = 1

Chapitre 16 / PID

611

Dans ce panel, nous affichons les courbes de la consigne et la sortie du processus ainsi que la commande et l’erreur.

Nous avons spécifié l’intervalle [45 65] pour la consigne. Nous avons considéré 3 valeurs

différentes du paramètre L (linéarité).

Pour L=0.8, nous constatons une augmentation du nombre et des amplitudes des oscillations et une instabilité au rejet de la perturbation. Pour L=1.1, le nombre d’oscillations et leurs amplitudes sont plus faibles, il est ainsi de même pour le rejet de la perturbation. Par contre le temps de réponse est plus élevé.

Partie II / Conception de contrôle et simulation

612

Le bloc PID Advanced réalise une régulation avec des options avancées. Le VI PID Gain Schedule.vi permet de modifier les valeurs des paramètres selon le domaine de fonctionnement, les valeurs de la sortie, de la consigne, etc. Il comprend les caractéristiques de l’algorithme PID ainsi que le mode manuel, l’action intégrale non linéaire.

IV. Sous-système de simulation d’un PID parallèle

On crée le PID parallèle d’expression suivante : )()()( ppKdp

KiKppU

A l’aide des opérateurs intégration et dérivation de la sous-palette Continuous Linear Systems, ainsi que les opérateurs sommation et gain de la sous-palette Signal Arithmetic, nous créons le diagramme suivant du PID parallèle.

Nous sélectionnons l’ensemble du diagramme et par le menu Edition, nous choisissons l’option Créer un sous-système de simulation.

Nous obtenons le sous-système de simulation suivant : Ce sous-système reçoit comme entrées, les paramètres Kp, Ki, Kd ainsi que l’erreur entre la

consigne et la sortie du processus. On insère ce sous-système dans le diagramme suivant dans lequel on régule un système analogique du 1er ordre. On affiche la consigne et la sortie du processus dans le Waveform Graph ainsi que l’erreur et le signal de commande.

Chapitre 16 / PID

613

Le signal de commande est un signal carré compris entre 0.5 et 1.5.

Le signal de sortie poursuit le signal de consigne avec un seul léger dépassement et se

stabilise ensuite en régime permanent.

V. Applications

V.1. Régulation PI analogique

Dans ce diagramme nous réalisons une régulation de type proportionnelle et intégrale PI. En utilisant les blocs de l’intégrateur, les outils Somme et Gain, nous avons réalisé cette

forme de régulateur parallèle, au seul paramètre K, suivant : )11()(p

KpC . Le processus à

réguler est un second ordre de gain statique unité. Le signal du générateur de la consigne, étant compris entre -1 et 1, nous l’avons déplacé

dans l’intervalle 0 et 1 grâce à l’expression (x+1)/2 par un nœud d’expression.

Partie II / Conception de contrôle et simulation

614

Nous avons affiché simultanément les signaux de consigne et de sortie du processus. Grâce au bloc Collector, nous affichons, dans un cluster le temps et le signal d’entrée de ce bloc.

Nous affichons également le temps de simulation. Dans le nœud d’entrée de la boucle, nous appliquons le cluster d’erreur d’entrée (pas d’erreur), la valeur limite N=100 et le pas de temps dt=0.001.

Dans le panel, nous affichons la sortie du processus qui oscille 3 fois avant de se stabiliser sur la consigne. Nous affichons également le cluster de l’historique du signal de sortie du processus.

En double cliquant sur le nœud d’entrée de la boucle Control & Simulation Loop, nous obtenons la boite de dialogue suivante.

Chapitre 16 / PID

615

Dans cette fenêtre, nous pouvons choisir le Solver d’équations différentielles tel Runge-Kutta d’ordre 1, 2, 3, 4, etc., les temps, initial et final ainsi que le pas de temps Step Size, ici de 0.001.

Nous pouvons configurer ces paramètres, aussi, après clic droit sur un bord de la boucle. Dans le menu local obtenu, on choisit « configurer les paramètres de

simulation ». Nous obtenons la même boite de dialogue que précédemment.

V.2. Régulation PID

Dans ce VI, nous réalisons une régulation PID avec le bloc PID de la sous-palette Continuous Linear Systems. Le signal de consigne est un échelon Step Signal de la sous-palette Signal Generation. La fonction de transfert continu, du processus à réguler est un 1er ordre de gain statique unité et de constante de temps de 20s. On la trouve dans la même sous-palette Continuous Linear Systems que le bloc PID.

Dans le graphe waveform Consigne et sortie du processus, nous traçons

simultanément le signal de consigne et le signal de sortie du processus.

Partie II / Conception de contrôle et simulation

616

De même, dans la partie basse de la boucle, nous traçons à la fois, le signal de consigne et la sortie processus en boucle ouverte. La simulation s’arrête lorsqu’on appuie sur le bouton STOP du panel, ce qui envoie un 1 logique au bouton Halt Simulation. Ce bouton se trouve dans la sous-palette Utilities. Dans ce diagramme, nous avons créé 2 nœuds de propriété qu’on lie aux 2 waveform graphs, afin de fixer les valeurs, minimale et maximale de l’axe X ainsi que l’incrément. Nous avons choisi 0 et 100 pour ces limites et un incrément de 20, comme on le remarque sur le panel. En double cliquant sur le bouton PID, nous pouvons spécifier ses paramètres. Nous devons d’abord choisir le type de PID, Academic, Parallel ou series.

Nous avons choisis Kp=1, Ki=0.1 et Kd=0.01. Dans le panel, nous constatons que le signal de consigne suit parfaitement la consigne après

un transitoire d’un second ordre d’amortissement optimal avec un seul dépassement. Sur la deuxième courbe, nous affichons le même signal de consigne échelon et la sortie du

processus en boucle ouverte, nous reconnaissons la réponse exponentielle d’un premier ordre. Nous avons appliqué, au nœud d’entrée de la boucle de contrôle et simulation, un cluster

d’erreur d’entrée et à son nœud de sortie nous affichons un cluster d’erreur en sortie.

V.3. Discrétisation d’un régulateur PI analogique par la méthode de Tustin

Nous allons modéliser le régulateur PI discret en remplaçant l’intégrateur p1 par la

formule de Tustin, 11

2 zzT , dans l’expression analogique suivante du régulateur PI :

Chapitre 16 / PID

617

)11()(pT

KpCi

p

L’expression 11

2 zzT correspond à l’intégration par la méthode des trapèzes.

Nous obtenons l’expression suivante du régulateur PI discret.

1

1

1

1

1

1

1

)1()1()(

zz

z

zTT

TTK

zC iip

Ce régulateur est programmé sous forme d’une fonction de transfert en z.

La poursuite se fait selon un système de 2nd ordre de gain statique unité (erreur statique

nulle) avec un seul dépassement.

V.4. Régulateur PI discret sous sa forme parallèle

Comme pour le PID analogique, nous utilisons un régulateur PI discret sous sa forme parallèle en utilisant les VIs de l’intégrateur, Discrete Integrator de la sous-palette Discrete Linear Systems.

Le dérivateur (1-z-1) est défini par la fonction de transfert Discrete Transfer Function de cette sous-palette. Nous avons rajouté un bloqueur d’ordre 0 afin d’attaquer un processus continu par un contrôleur discret.

Partie II / Conception de contrôle et simulation

618

La régulation se fait sans aucun dépassement et l’erreur statique est toujours nulle grâce à la

présence de l’intégration dans l’intégrateur.

V.5. Régulateur PID discret parallèle

La forme parallèle est la somme des 3 actions, proportionnelle, intégrale et dérivée. La dérivée discrète est représentée par la différence de 2 échantillons successifs, soit :

zzz 11 1

L’intégrale discrète est symbolisée par :

111

1 zz

z.

Le diagramme suivant représente le sous-système de simulation PID discret parallèle.

Chapitre 16 / PID

619

Ce sous-système est obtenu, après sélection par la souris de l’ensemble des blocs, par

Edition Créer un sous-système de simulation. Pour retrouver le contenu du sous-système créé, il faut choisir Open Subsystem dans le menu local (clic droit sur le sous-système). Le diagramme suivant représente l’utilisation de ce sous-système pour réguler le processus continu du 1er ordre :

ppH

2011)(

Ce processus est échantillonné à Ts=5s grâce au VI CD Convert Continuous to Discrete.vi auquel on fournit la fonction de transfert continue et la période d’échantillonnage Ts. Les paramètres du PID proviennent du désassemblage du cluster PID spécifié dans le panel. L’erreur est stockée dans la variable locale err afin d’être lue et appliquée au sous-système.

La consigne est un échelon de hauteur 7 à partir de la valeur 18, ce qui peut être la

température habitacle lors de la régulation de la climatisation. A l’instant t=200, nous créons une perturbation sur la sortie par la modification de sa valeur en lui ajoutant 10. Le test t==200 est réalisé par la structure condition.

Lorsque cette condition est fausse, on fait juste rentrer et sortir le même signal de sortie du processus sans aucune modification.

Partie II / Conception de contrôle et simulation

620

Le VI CD Draw Transfer Function Equation.vi permet d’afficher l’équation de transfert avec reconnaissance automatique du type continu ou discret.

Dans ce panel, les paramètres sont spécifiés par une jauge, glissière horizontale et tank de la palette Argent. Les paramètres Kp, Ki et Kd sont ajustés pour avoir moins d’oscillations aux changements abrupts de la consigne tout en ayant un temps de réponse optimal avec un léger et unique dépassement. La perturbation est rejetée sans aucune influence sur le signal de sortie tout en observant un changement dans le signal de commande.

Chapitre 16 / PID

621

VI. Régulation de position – Moteur à courant continu

Nous considérons le même moteur que nous avons vu précédemment. A partir des

équations, électrique et mécanique, nous pouvons écrire :

)()()()( pKpILpRpU )()()( pfpIKppJ

De cette dernière équation, nous avons :

)()( pK

fpJpI

En remplaçant )( pI par cette expression, dans l’équation électrique, nous obtenons la

fonction de transfert donnant la vitesse de rotation en fonction de la tension appliquée à l’induit :

2)()()()(

KJpfLpRK

pUp

Son schéma-bloc est le suivant :

La tension )()( pKpU est appliquée au circuit RL de l’induit et produit le courant

)( pI qui fournit le couple )( p appliqué au circuit mécanique des frottements et d’inertie. Le système est du 2nd ordre suivant :

20

2

0

0

222

2

211)(

wpp

w

H

pKfR

LJpKfR

fLRJKfR

K

pH

avec :

20 KfRKH : gain statique

Partie II / Conception de contrôle et simulation

622

LJKfRw

2

0 : pulsation propre

)(21

2KfRLJfLRJ : coefficient d’amortissement

VI.1. Réponse indicielle de vitesse et de position

Nous utilisons les valeurs suivantes des paramètres du moteur :

K=0.050 N.m/A R= 2 ohms, L=0.120 H, f= 0.001 N.m/(rad/s), J=0.02 kg.m2

Pour définir le moteur, nous utilisons sa fonction de transfert par le bloc Transfer

Function de la sous-palette Continuous Linear Systems. Pour définir l’entrée supplémentaire Transfer Function , en bas à gauche, de ce bloc,

nous double cliquons sur ce bloc pour choisir Terminal pour Parameter source.

Les paramètres électromécaniques du moteur sont définis dans le panel sous forme de

clusters, sauf le paramètre K. Dans le diagramme, nous désassemblons ce cluster pour récupérer ces paramètres afin de servir d’entrées à un nœud MathScript.

Ce nœud MathScript permet de définir la fonction de transfert grâce à la commande tf à laquelle on transmet le numérateur et le dénominateur de cette fonction de transfert.

Cette fonction de transfert est définie par la variable de retour sys qui sera une sortie du

nœud MathScript qui traverse les 2 boucles de simulation et de contrôle pour être appliquée à l’entrée supplémentaire Transfert Function du bloc Transfer Function.

Un échelon unité est appliqué à cette fonction de transfert. Pour obtenir la position angulaire de l’ardre du moteur, nous utilisons un bloc intégrateur.

Pour afficher, à la fois, la vitesse et la position de l’arbre moteur, nous assemblons les 2 signaux dans un tableau grâce à la fonction Construire un tableau de la palette Tableau. Le bloc Collector permet d’associer le temps de simulation aux valeurs du signal qu’on veut tracer dans un graphe déroulant ou un graphe XY.

Nous calculons le coefficient d’amortissement et le gain statique de la fonction de transfert, grâce à la commande roots qui recherche les solutions du dénominateur et la commande dcgain. La boite de calcul permet de déterminer les valeurs théoriques des pôles :

)1( 2

02,1 wp On vérifie qu’ils ont les mêmes valeurs que ceux donnés par la commande roots.

Chapitre 16 / PID

623

Dans le panel, nous définissons et affichons les clusters RL, fJ ainsi que la commande K et affichons le graphe XY donnant la courbe des réponses indicielles de la vitesse et de la position angulaire.

VI.2. Régulation de la vitesse angulaire par placement de pôles

VI.2.1. Compensation de pôles, placement de pôles avec action intégrale

Cette méthode consiste à compenser les pôles du système par les zéros du régulateur et à

imposer la dynamique souhaitée de la boucle fermée tout en ajoutant une action intégrale.

Partie II / Conception de contrôle et simulation

624

Pour faire apparaître les pôles et conserver le même gain statique, la fonction de transfert du processus peût être mise sous la forme suivante :

)()()(

21

210

ppppppHpH

Pour transformer cette fonction de transfert du 2nd ordre en une autre du 1er ordre de

constante de temps et de gain statique unité avec action intégrale nous devons avoir l’expression suivante du régulateur :

)1(1*)()(

210

21212

ppppHpppppppC

Le paramètre permet de régler le régulateur pour que le système en boucle fermé soit

stable. Avec ce régulateur, la fonction de transfert en boucle ouverte est donnée par :

)1(1)(

pppFTBO

Ainsi la fonction de transfert en boucle fermée a pour expression :

211

1)1(1)(

pppppFTBF

C’est un système du 2nd ordre de gain statique unité, de coefficient d’amortissement

21 et de pulsation propre 1

0w .

On voit bien que le paramètre permet de régler le coefficient d’amortissement et la

pulsation propre du système bouclé. Dans le diagramme suivant, nous avons utilisé un nœud MathScript dans lequel nous avons

déterminé la fonction de transfert par la commande tf. La commande roots calcule les racines du dénominateur qui sont les pôles de la fonction

de transfert. Les pôles sont calculés selon leur expression théorique. Dans ce nœud MathScript, nous avons défini le régulateur et le système par leurs fonctions

de transfert. Dans la boucle de contrôle et simulation, l’icône du régulateur est défini comme Text

Only dans Icon Style du menu local obtenu par un clic droit. Le style de l’icône du processus est choisi comme Dynamic. Nous avons utilisé une variable locale pour la consigne afin de la transmettre à la fonction

Construire un tableau pour la tracer dans le même graphe XY que la sortie du processus.

Chapitre 16 / PID

625

Dans ce cas, l’amortissement est plus petit donc nous avons un système sous amorti avec un gain statique unité grâce à la présence de l’intégration dans le régulateur.

VI.2.2. Placement de pôles dans l’espace d’état

Dans le paragraphe « Commande par retour d’état », nous avons montré que pour réguler un processus par retour d’état autour d’une consigne non nulle r, il suffit d’appliquer la commande de type :

)()()( txKtrFtu Le coefficient F est donné par :

11 BAKBCF

Partie II / Conception de contrôle et simulation

626

Pour fixer la dynamique de régulation autour de cette consigne, il suffit de calculer le coefficient de retour K qui permet de fixer les pôles du système bouclé :

)()()()()()( trFBtxKBAtxKtFrBtxAtx

La dynamique du système bouclé est alors fixée par det[pI-A+B K], appelée équation caratéristique.

On se propose de faire une régulation de ce type de la vitesse et de la position du moteur.

Pour cela, nous devons d’abord chercher un autre modèle d’état pour la vitesse et la position.

Modèle d’état pour la vitesse

On considère la fonction de transfert, donnant la vitesse de rotation en fonction de la tension appliquée à l’induit.

222

2

2221

1

/

)()()()()()()(

pKRf

LJpKRfLfRJ

KRfK

pLJpLfRJKRfK

KJpfLpRK

pUppH

Appelons :

210 KRfKH , 2KRf

LfRJ et 2KRfLJ , soit 2

011 1)(

)()(pp

HpUppH

Nous obtenons l’équation différentielle suivante :

)()(1)()( 01 tuH

ttt

En faisant intervenir l’opérateur intégralp1 , et sachant qu’il y autant de variables d’état que

d’intégrateurs et que chacune de ces variables est une sortie d’intégrateur, le diagramme suivant permet de déterminer très simplement le modèle d’état.

Chapitre 16 / PID

627

Nous avons : )()( 21 txtx

)()()(1)( 10212 tuHtxtxtx

y(t)= [1 0] )(0)()(

2

1 tutxtx

Les matrices d’état sont les suivantes :

110

A , 10

0

HB , 01C et 0D .

On choisit un polynôme caractéristique qui comporte les pôles de la dynamique du système

en boucle fermée. Si l’on choisit les 2 pôles p1=-.5 et p2=-0.8, pour la dynamique du système en boucle

fermée, nous avons : )()( 21 pppp = KBAIpdet ,

La mise en place d’un tel correcteur correspond à calculer le coefficient du retour d’état K

afin d’avoir l’égalité de ces 2 expressions. Le processus ayant 2 variables d’état, il suffit de calculer les coefficients k1 et k2 tels que :

)

0

110

00

(det)( 2110

21212 kkHp

ppppppp

10110222121

2 1)()(Hk

pHk

ppppppp

Nous avons alors le système de 2 équations suivantes :

10221 )(

Hkpp

10121

1 Hkpp

Nous obtenons :

)1( 2110

1 ppH

k

)( 2110

2 ppH

k

Partie II / Conception de contrôle et simulation

628

La régulation par retour d’état est modélisée par le schéma-bloc suivant :

Dans le nœud MathScript, nous avons programmé le numérateur et le dénominateur de la

fonction de transfert que nous obtenons par la commande tf. Nous avons calculé les pôles du système grâce à la commande roots qui calcule les

racines du dénominateur de la fonction de transfert. Nous avons spécifié une dynamique selon un pôle double de p1=p2=-0.85. Les éléments

k1 et k2 sont transmis à un autre nœud MathScript qui calcule la matrice F et les matrices d’état. Nous avons calculé, pour comparaison, les pôles du système par les valeurs propres (commande eig) de la matrice A.

Sur le panel, nous vérifions que les pôles, calculés par ces 2 différentes façons, sont

parfaitement les mêmes.

Chapitre 16 / PID

629

Nous vérifions que le signal de sortie suit le signal de consigne selon la dynamique spécifiée par le pôle double -0.85 et qu’en statique l’erreur est nulle.

Les pôles du système, calculés par la fonction de transfert et le modèle d’état, sont parfaitement les mêmes.

Modèle d’état pour la position

Pour obtenir la position, il suffit de placer un 3ème intégrateur qui fait intervenir une 3ème variable d’état.

Dans ce cas, nous avons :

)()( 21 txtx )()( 32 txtx

)()()(1)( 10323 tuHtxtxtx

y(t)= [1 0 0] )(0)()()(

3

2

1

tutxtxtx

Le modèle d’état est alors :

uHx

xx

xxx

103

2

1

3

2

1

00

10100010

Nous allons vérifier ce modèle d’état en traçant les réponses indicielles (vitesse et position).

Partie II / Conception de contrôle et simulation

630

Dans le nœud MathScript, nous calculons les variables , et .10H puis les matrices d’état. A l’aide de la commande ss, la sortie sys permet de transmettre le modèle d’état au processus. A l’aide de l’option Icon Style du menu local nous avons choisi Text Only.

Dans le nœud MathScript, nous avons aussi calculé les pôles du système qui correspondent aux valeurs propres obtenues par la commande eig(A). La vitesse est obtenue comme étant la 2ème variable d’état qu’on récupère par indexation de la sortie state x(k).

Dans le panel, nous traçons les réponses indicielles de la position et de la vitesse. Nous

affichons le modèle d’état ainsi que la fonction de transfert correspondante. Les pôles sont les mêmes que ceux que nous avons obtenus précédemment.

Chapitre 16 / PID

631

VI.2.3. Régulation PID de la position

Nous avons utilisé le bloc PID de la palette PID. Ses coefficients sont déterminés dans un cluster sur le panel.

Les matrices A, B, C et D du modèle d’état sont définies dans le nœud MathScript. L’icône du processus est choisi comme Text Only dans le menu local par Icon Style. La vitesse est récupérée par la sortie state x(k) par indexation.

Dans le panel, nous affichons la position dans un graphe XY ainsi que la vitesse dans un

autre graphe.

Partie II / Conception de contrôle et simulation

632

VII. Modélisation d’un système multivariable

VII.1. Simulation et contrôle d’un système multivariable

On considère un processus aérothermique qui possède 3 entrées et 2 sorties. Les 3 entrées sont :

- Commande u1 du moteur M1 du ventilateur qui souffle l’air chauffé au passage par la résistance,

- Commande u2 du moteur M2 qui souffle de l’air froid (température ambiante), - Commande u3 qui fait varier la puissance de chauffe en commandant la résistance à

travers un circuit à thyristors. Les 2 sorties sont :

- la tension y1 proportionnelle à la température à l’extrémité du conduit, - la tension y2 proportionnelle au débit d’air à l’extrémité du conduit.

On ne considère que les entrées u1, u2 et les sorties y1, y2. D’autre part, la commande de

chauffe u1 n’a pas d’effet sur le débit d’air y2. La modélisation du processus peut se faire sous la forme suivante :

Chapitre 16 / PID

633

Après identification de ces fonctions de transfert partielles, nous trouvons :

1

11

111

1211111

111

11 8.01)5.01(

1)(

1)(

zzz

zazbbz

uyzH

1

11

112

1212112

1

2

1112 5.01

)4.01(1

)()(

zzz

zazbbz

uyzH

1

11

112

1212112

1

2

2122 2.01

)4.01(1

)()(

zzz

zazbbz

uyzH

La fonction de transfert qui donne le vecteur 2

1

yy

en fonction de 2

1

uu

est donné par :

2

1

22

1211

2

1

0 uu

HHH

yy

VII.2. Fonction de transfert multivariable

Nous allons modéliser ce système multivariable avec des fonctions de transfert discrètes. Avec l’opérateur z, la matrice de transfert discrète est donnée par :

)2.0(4.00

)5.0(4.0

)8.0(5.0

0 22

1211

zzz

zzz

zzz

HHH

En double cliquant sur le bloc de la fonction de transfert discrète, on ouvre sa boite de

dialogue dans laquelle on spécifie les choix suivants :

- MIMO (Multi Input Multi Output) dans Polymorphic instance, pour spécifier que c’est un système à plusieurs entrées et plusieurs sorties,

- Configuration Dialog Box (boite de dialogue) au lieu de Terminal

dans Parameter source. On indique aussi qu’il y a 2 entrées (Inputs) et 2 sorties (Outputs). On écrit chaque fonction de transfert de la matrice séparément. Celle qu’on spécifie est symbolisée par un point dans la matrice de Input-Output

Model. L’entrée et la sortie correspondantes liées à cette fonction de transfert sont indiquées dans

Current Input (entrée courante) et Current Output (sortie courante).

Partie II / Conception de contrôle et simulation

634

Le numérateur et le dénominateur de la fonction de transfert sont spécifiés selon les puissances croissantes de z.

Dans le cas de ce processus bivariable, la matrice de transfert est représentée dans la boite

de dialogue suivante : On a choisi le style Dynamic pour Icon Style dans le menu local obtenu par un clic

droit.

Dans le diagramme suivant, la fonction de transfert est spécifiée dans un cluster constant

dans le panel. Avec le VI CD verify MIMO Properties permet d’obtenir le nombre d’entrées et

de sorties. Nous obtenons bien 2 entrées et 2 sorties. Il ressort le modèle avec lequel nous affichons son équation grâce au VI CD Draw

Transfer Function Equation.vi.

Chapitre 16 / PID

635

Avec le VI CD Set Names to Model.vi nous pouvons créer des propriétés comme les noms des entrées et des sorties et le nom du modèle. Ces mêmes noms d’entrées et de sorties peuvent être récupérés par le VI CD Get Names from Model.vi. Les réponses indicielles sont réalisées grâce au VI CD Step Response.vi.

Lorsque le système est multivariable, le VI applique des échelons à toutes les entrées.

Dans le panel suivant, nous affichons le cluster qui définit la fonction de transfert

constante. Dans Model Out, nous affichons la fonction de transfert avec le nom du modèle, soit Processus aérothermique que nous avons spécifié grâce au VI Set Names to Model.vi. Dans Input Names et Output Names, nous affichons les noms des entrées et des sorties. Les réponses du débit et de la température sont des variations autour d’un point de fonctionnement.

Partie II / Conception de contrôle et simulation

636

VII.3. Réponses indicielles du système multivariable

Dans le diagramme suivant, nous appliquons deux échelons aux deux entrées u1 et u2 du processus multivariable, grâce aux blocs Step Signal de la sous-palette Signal Generation. L’icône du processus, défini par la fonction de transfert discrète est choisi de type Express par l’option Icon Style du menu local (clic droit).

L’échelon de l’entrée u1 est appliqué à l’instant t=0.2 et celui de la commande du moteur de débit d’air froid à t=0.6.

Les 2 sorties sont affichées, à l’extérieur de la boucle de simulation, dans un graphe XY qui

reçoit, à la fois le temps de simulation, et leurs valeurs grâce au bloc Collector. Nous affichons également les échelons des commandes u1 et u2. Dans le panel suivant,

nous observons qu’à l’arrivée de l’échelon sur le moteur d’air froid, le débit d’air augmente avec un léger dépassement, ce qui provoque une diminution de la sortie y1 de 4.5 à 3.5.

Chapitre 16 / PID

637

VII.4. Régulation PID du système multivariable

Dans le diagramme suivant, nous réalisons la régulation des sorties températures et débit à l’aide de 2 régulateurs PID. Les paramètres de ces PID sont spécifiés dans des clusters.

Les deux consignes sont, un signal carré pour la température et un échelon pour le débit. Les deux signaux sont assemblés dans un tableau. La sortie débit a été modifiée en lui ajoutant 10 entre les instants 75 et 80, grâce à l’utilisation d’une structure condition.

Les PID sont réalisés dans le sous-système de simulation qu’on obtient par Open

Subsystem du menu local (clic droit sur le bloc du sous-système). Ils sont de la structure

parallèle. L’intégrale est réalisée par la fonction de transfert discrète 111z

et la dérivée par

11 z . Les gains sont dans la sous-palette Signal Arithmetic. On choisit Terminal pour Parameter source après un double clic afin de faire apparaître l’entrée gain.

Partie II / Conception de contrôle et simulation

638

Les deux commandes sont assemblées dans un tableau avant d’être appliquées au système défini par la fonction de transfert multivariable.

Dans le panel, nous affichons les sorties y1 de température et y2 de débit ainsi que les

commandes de chauffe u1 et de débit u2. Nous constatons que la perturbation sur le débit possède un effet sur la température. En

effet, si le débit augmente, la température diminue. Cette perturbation est rejetée sans oscillations ni sur la température ni sur le débit. Pour calculer les erreurs de température et de débit, nous devons indexer les vecteurs des

sorties et des consignes avec l’indice 0 pour la température et 1 pour le débit. Nous affichons également les clusters des paramètres des deux PID ainsi que les valeurs

instantannées des vecteurs de sorties et de consignes.

Partie II. Chapitre 17 - Contrôle par logique floue

I. Principe fondamental du contrôle flou I.1. Définition d’un système flou I.2. Variables linguistiques I.3. Fonctions d’appartenance I.4. Règles floues II. Etapes de mise en œuvre d’un contrôleur flou II.1. Etape de fuzzification II.2. Etape d’inférence II.3. Etape de défuzzification III. Création, modification et sauvegarde d’un système flou III.1. Fonctions d’appartenance des variables d’entrée et sortie III.2. Edition des règles floues III.3. Description, rapport HTML du système flou IV. Modification d’un système existant IV1. Modification d’une fonction d’appartenance IV.2. Modification des règles V. Création d’un système flou par des VIs VI. Régulateur flou VI.1. Sans intégration VI.2. Avec intégration VII. Régulation floue de l’angle d’un pendule inversé VII.1. Modèle du pendule VII.2. Sous-système du pendule VII.3. Réponse impulsionnelle du pendule VII.4. Test du contrôleur flou VII.5. Régulation floue de l’angle du pendule

639DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _17,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

640 Partie II / Conception de contrôle et simulation

640

I. Principe fondamental du contrôle flou

I.1. Définition d’un système flou

Un système flou est basé sur un ensemble de variables associées par une logique floue. Un contrôleur flou utilise des règles floues pour contrôler la sortie du système selon les valeurs courantes des entrées. Dans LabVIEW, un système flou est défini dans Outils Control Design and Simulation Fuzzy System Designer ….

Ce système peut être ensuite modifié à l’aide des VIs de la sous-palette Conception de

contrôle et simulation Fuzzy Logic.

Chapitre 17 / Contrôle par logique floue

641

Un système flou est constitué de 3 parties : Variables linguistiques, fonctions

d’appartenance et les règles floues.

I.2. Variables linguistiques

Une variable linguistique est une variable définie sous forme littérale qui représente l’une des variables d’entrée et de sortie du système flou. Considérons le cas d’un contrôleur du pendule inversé pour lequel le but est de le maintenir à la verticale, soit l’angle =0 en appliquant une force f au chariot pour le maintenir dans cette position. Le système flou du contrôleur aura 2 variables d’entrée : la variable et sa variation et une sortie qui est la force à appliquer au chariot.

Nous pouvons alors définir ce système par les variables linguistiques de l’entrée teta et

teta_point et de sortie f. Ces variables sont définies, chacune dans un domaine de variations appelé univers de

discours. L’intervalle de variation de l’angle peut être estimé par [-20°, 20°] car on estime qu’en dehors de cet intervalle, le pendule n’est pas récupérable, soit qu’il tombe d’un coté ou de l’autre quelle que soit la force appliquée au chariot.

La variable f dans l’intervalle [-10 10] en Newtons.

I.3. Fonctions d’appartenance

La fonction d’appartenance d’une de ces variables, d’entrée ou de sortie, représente une catégorie selon leurs valeurs. Ces fonctions d’appartenance sont aussi représentées par des termes linguistiques.

La notion d’ensemble flou permet de définir une appartenance graduelle d’un élément à une classe, c’est-à-dire appartenir plus ou moins fortement à cette classe. L’appartenance d’un objet à une classe est ainsi définie par un degré d’appartenance entre 0 et 1.

Pour la variable floue f, nous pouvons diviser l’univers de discours en 5 ensembles qu’on appelle Très_Négative, Négative, Nulle, Positive et Très_Positive.

On peut choisir des formes triangulaires pour ces fonctions d’appartenance.

642 Partie II / Conception de contrôle et simulation

642

Pour la variable d’entrée teta, nous définissons également l’univers de discours en 3 ensembles flous ou 3 fonctions d’appartenance triangulaires: Nég, Zéro et Pos.

Les fonctions d’appartenance sont des fonctions numériques qui correspondent aux

variables linguistiques. Elles représentent des degrés d’appartenance des variables linguistiques.

Le degré d’appartenance possède des valeurs continues entre 0 et 1, correspondant à 0% et 100% d’appartenance de la variable linguistique à l’ensemble flou défini par la fonction d’appartenance.

La valeur 0 N de la variable f appartient à 100% à l’ensemble flou Nulle et 0% aux

ensembles Très_Négative, Négative, Positive et Très_Positive. La valeur 2.5 N de cette variable, appartient à 50% à l’ensemble flou Nulle, 50% à

l’ensemble Positive et 0% aux autres ensembles. La valeur 0° de la variable de sortie, teta, possède les degrés d’appartenance 1 ou 100% à

l’ensemble flou Zéro, 0% à Nég et Pos. La valeur 10° appartient à 50% aux ensembles Zéro et Pos, et 0% à l’ensemble Nég.

Pour améliorer la qualité de cette commande, nous allons ajouter une autre entrée, la

vitesse de variation de l’angle définie par la variable linguistique teta_point. Nous définissons, de même pour cette variable, 3 fonctions d’appartenance ou ensembles

flous sur l’intervalle [-10 10] pour cette variation de l’angle.

- N : Négative, - Z : Zéro, - P: Positive.

I.4. Règles floues

Les règles décrivent les relations qui doivent exister entre les variables d’entrée et celle de sortie afin que cette dernière atteigne la consigne désirée.

Chapitre 17 / Contrôle par logique floue

643

Les règles sont basées sur des opérateurs de type logique sur les appartenances des variables linguistiques aux différents ensembles flous.

Une de ces règles floues consiste à ne rien faire si l’angle et sa variation sont nulles,

soit : IF teta EST Zéro ET teta_point EST Z ALORS f EST Nulle

Dans le cas où l’angle est positif et sa variation est positive alors on applique une force

très grande positive afin de déplacer le chariot dans le sens positif et ainsi et ramener l’angle vers 0. IF teta EST Pos et teta_point est P ALORS f EST Très_Positive Dans le cas où le pendule est arrivé au point d’équilibre (teta est Zéro) mais à

tendance à s’en écarter dans le sens négatif (teta_point est N), alors il faut appliquer une tension négative (f est Négative) au moteur afin de tourner le pendule vers le sens positif.

Ces règles floues peuvent être écrites selon la table de vérité suivante :

Les clauses « teta est Nég » et « teta_point est N » sont appelées les

antécédents de la règle. La conclusion « f est Très_Négative » est appelée le conséquent de la règle. Le conséquent définit la stratégie du contrôleur afin que la sortie du système atteigne la

consigne spécifiée.

II. Etapes de mise en œuvre d’un contrôleur flou

II.1. Etape de fuzzification

L’étape de fuzzification consiste à définir des ensembles flous pour les variables d’entrée et de sortie. Pour chacune de ces variables, on doit connaître, a priori, son intervalle de définition ou univers de discours. Dans la plupart des cas, le régulateur flou reçoit comme variables d’entrée, l’erreur entre la sortie du processus et le signal de consigne ainsi que la variation de cette erreur. La dérivée de cette erreur suffit pour représenter sa variation. Ainsi la loi de commande peut être schématisée comme suit :

644 Partie II / Conception de contrôle et simulation

644

1 1zContrôleur flou Processus+

-r(t)y(t)

e(t)

Dans le cas du pendule inversé, il s’agit d’avoir 0y . L’erreur et sa variation sont alors :

e t y te t y t y t( ) ( )

( ) ( ) ( )1

On considère que le pendule n’est pas récupérable s’il sort du domaine [-20°, 20°], que la variation maximale de l’angle est de 10° en valeur absolue. On définit chacune de ces variables par 3 ensembles flous définis par des fonctions d’appartenance triangulaires (N pour négative, Z pour zéro et P pour positive). Si la tension appliquée à l’induit du moteur, qui est la sortie du régulateur, est limitée à l’intervalle [-10V; 10V], on choisit de la définir par 5 ensembles flous (NG : négative grande, N : négative, Z : zéro, P : positive et PG : positive grande) de formes triangulaires. L’étape de fuzzification consiste à avoir une définition floue des entrées-sorties. L’erreur sera l’écart angulaire entre le signal de sortie et le signal de consigne (angle nul). La variation de l’erreur est la différence entre l’erreur à l’instant courant kT à celle de l’instant précédent (k-1)T. Si on estime que les valeurs maximales, en valeur absolue, de l’erreur et de sa variation, sont respectivement égales à 20 et à 10, nous obtenons les ensembles flous suivants qui définiront les entrées-sorties du régulateur.

II.2. Etape d’inférence

C’est l’étape où l’on établit les règles floues qui permettent d’aboutir à la commande en fonction des valeurs de l’erreur et de sa variation. En général, la commande dépend non seulement de l’erreur mais aussi de sa variation. Dans le cas du pendule, il faut le ramener à la position de consigne d’autant plus énergiquement

Chapitre 17 / Contrôle par logique floue

645

qu’il s’en éloigne et que sa vitesse est grande. Les règles floues lient la variable de sortie aux variables d’entrée afin de tirer des conclusions ou déductions floues. Une règle floue comporte une prémisse du genre « Si l’erreur est négative ET la variation de l’erreur est négative » et une déduction floue du type « Alors u est positive grande ». Dans le cas où les deux variables d’entrée sont définies, chacune, par 3 ensembles flous, on aboutit à 9 règles floues, lesquelles, dans le cas particulier du pendule inversé sont données par la table, dite d’inférence, suivante.

ee

Z

P

N

Z

P

N

Z

Z

Z

PG

NG

P

P

N

N

Il faut remarquer que dans le cas de cette table, le régulateur flou fournit un incrément de commande que l’on ajoute, à chaque pas d’échantillonnage, à la commande appliquée précédemment. Les 3 cas où la commande est Z, sont ceux où l’on doit garder la même commande, soit :

l’erreur est Z et sa variation est Z (pendule à la position de consigne), l’erreur est P mais sa variation est N, l’erreur est N mais sa variation est P.

Dans les 2 derniers cas, le pendule revient de lui-même à la position de consigne. Après l’édition des règles, il reste à calculer les degrés d’appartenance de la variable de sortie à tous les ensembles flous qui lui sont associés. Aux 5 ensembles flous de la variable de sortie correspondent 5 déductions floues. 1. Si ( e est N) ET ( e est N) ALORS u est PG, 2. Si {( e est N) ET ( e est Z)} OU {( e est Z) ET ( e est N)} ALORS u est P, 3. Si {( e est Z) ET ( e est Z)} OU {( e est P) ET ( e est N)} OU {( e est N) ET ( e est P)}

ALORS u est Z, 4. Si {( e est P ET ( e est Z)} OU {( e est Z) ET ( e est P} ALORS u est N 5. Si ( e est P) ET ( e est P) ALORS u est NG. Chaque règle est composée de prémisses liées par les opérateurs ET, OU et donne lieu à une implication par l’opérateur ALORS. La méthode de Mamdani consiste à utiliser l’opérateur min pour le ET et l’opérateur max pour le OU. Plusieurs règles peuvent être activées en même temps, i.e. que chacune de leurs prémisses

646 Partie II / Conception de contrôle et simulation

646

possède un degré d’appartenance non nul. Ceci dépend des types de fonctions d’appartenance utilisées ; en l’occurrence toutes les règles sont, à chaque instant d’échantillonnage, plus ou moins activées si l’on choisit des fonctions d’appartenance de forme gaussienne. L’agrégation de ces règles, opération qui doit aboutir à une seule valeur de la variable de sortie, se fait par l’opérateur max , comme si les règles étaient liées par l’opérateur OU. Cette méthode peut être illustrée, comme suit, dans le cas de l’agrégation des règles 1 et 2. Chaque prémisse de la règle 1 est mise en évidence par l’écrêtage de la fonction d’appartenance PG soit par le degré d’appartenance de e à l’ensemble N, soit par celui de e à l’ensemble N. Comme les clauses de la prémisse de la règle sont liées par l’opérateur ET, on écrête l’ensemble PG de la variable f par le minimum des 2 degrés d’appartenance, comme le montre la figure suivante :

La règle 2 possède 2 prémisses liées par l’opérateur OU. Pour chacune de ces prémisses, on réalise la même opération que pour la règle 1. L’opérateur OU étant remplacé par l’opérateur max, on prendra le maximum des 2 surfaces obtenues.

N Z P

0 e-20 20

N Z P

0-10 10 e

N Z P

-10 -5 0 5 10

PGNG

u

min

N Z P

0 e-20 20

N Z P

0-10 10 e

N Z P

-10 -5 0 5 10

PGNG

u

min

N Z P

-10 -5 0 5 10

PGNG

u

max

L’agrégation des règles 1 et 2 se fait en prenant en chaque point de l’ensemble de définition de la variable de sortie (univers de discours), le maximum des surfaces obtenues.

Chapitre 17 / Contrôle par logique floue

647

N Z P

-10 -5 0 5 10

PGNG

u

N Z P

-10 -5 0 5 10

PGNG

u

N Z P

-10 -5 0 5 10

PGNG

u

max

Si les règles 1 et 2 sont activées en même temps, la fonction d’appartenance de la variable de sortie est symbolisée par la surface pleine ci-dessus.

II.3. Etape de défuzzification

Lors de la fuzzification, pour chaque variable d’entrée réelle, on calcule ses degrés d’appartenance aux ensembles flous qui lui sont associés. Dans l’étape de défuzzification, on réalise l’opération inverse, à savoir, obtenir une valeur réelle de la sortie à partir des surfaces obtenues dans l’étape d’inférence. Il existe plusieurs méthodes de défuzzification, dont la plus utilisée est celle du centre de gravité (Center of Area ou CoA). Il existe d’autres méthodes : Centre de gravité modifié (modified Center of Area ou mCoA), centre des maximums (Center of Maximum ou CoM), etc. Parmi ces méthodes, les plus utilisées sont la méthode du centre de gravité (CoA), et celle de la moyenne des maximas, ‘CoM’. La méthode ‘CoA’ calcule le centre de gravité de la surface obtenue après l’étape d’inférence et le projette sur l’axe horizontal. On réalise ainsi la moyenne de toutes les valeurs de la variable de sortie, chacune pondérée par son degré d’appartenance. La méthode ‘CoM’ ou la moyenne des maximas correspond à un simple calcul de moyenne arithmétique des valeurs ayant le plus grand degré d’appartenance. La méthode la plus précise où toutes les valeurs de l’univers de discours interviennent plus ou moins fortement suivant le degré d’appartenance est celle du centre de gravité (CoA).

648 Partie II / Conception de contrôle et simulation

648

III. Création, modification et sauvegarde d’un système flou

Nous allons considérer le cas de l’exemple du pendule inversé. Avec Outils Control Design and simulation Fuzzy System Designer …, nous définissons les différentes fonctions d’appartenance pour l’erreur (t), sa variation (t) et la force f.

III.1. Fonctions d’appartenance des variables d’entrée et sortie

La création des fonctions d’appartenance se fait dans l’onglet Variables. A l’aide de cet outil, nous créons, pour l’une des 2 variables d’entrée, 3 ensembles flous, N, Z et P. L’univers de discours de la variable teta est [-0.5 0.5]. Il est de -1 à 1 pour la variation d_teta. Les fonctions d’appartenance sont toutes de type triangulaire. La sortie de ce système flou possède 5 fonctions d’appartenance NG (Négatif Grand), N (Négatif), Z (Zéro), P (Positif) et PG (Positif Grand).

En cliquant sur Edit Input variable (outil crayon), nous obtenons la fenêtre d’édition suivante :

Chapitre 17 / Contrôle par logique floue

649

Après l’édition des variables d’entrée et de sortie, nous pouvons enregistrer le système flou sous le nom Inverted_Pendulum.fs. L’extension fs vient de « fuzzy system ».

Nous allons définir les règles floues dans l’onglet Rules en nous basant sur la table de vérité suivante :

En choisissant Pre-Generate Rules du menu Operate, nous obtenons la fenêtre

suivante dans laquelle nous obtenons le nombre de règles, soit 9 comme on les a mentionnées dans la table de vérité.

A ce niveau, les règles déjà créées dans l’onglet Rules vont être supprimées. Les clauses figurant avant l’opérateur THEN, comme “teta est N” AND “Variation

de teta Positive” sont appelées antecedents.

650 Partie II / Conception de contrôle et simulation

650

L’action correspondante à effectuer, située après l’opérateur THEN, comme « la force est NULLE » est appelée consequent.

Dans Antecedent Connective, nous devons choisir le type de conjonction des antécédents d’une règle.

Après la fuzzification des entrées du système flou, le contrôleur flou utilise les termes linguistiques de ces entrées et les règles pour déterminer les variables linguistiques de sortie.

Lorsqu’une règle possède plus qu’un antécédent, nous devons spécifier la méthode de conjonction de ces antécédents, à savoir comment calculer la valeur vraie de la sortie à partir de ces antécédents.

Le toolkit possède les types de conjonction suivants : AND (Minimum) : Minimum des degrés d’appartenance AND (Produit) : Produit des degrés d’appartenance, OR (Maximum) : Maximum des degrés d’appartenance, OR (OU Probabilistique) : Ou probabilistique. Supposons que l’erreur est Z avec un degré d’appartenance de 0.2 ET l’écart de l’erreur est

P avec un degré de 0.8. Dans ce cas, la règle est basée sur 2 antécédents. Le contrôleur invoque la règle « IF

teta est Z AND d_teta est P ALORS f est P ». A chaque antécédent correspond un degré d’appartenance pour la variable linguistique

donnée. La conjonction des antécédents permet de calculer le degré d’appartenance de la variable

linguistique f à l’ensemble P.

Chapitre 17 / Contrôle par logique floue

651

Si on choisit le minimum, alors le degré est égal à 0.2, si c’est le produit ce degré d’appartenance vaudra 0.2*0.8=0.16. La valeur Degree of support consiste en la valeur de la pondération de la règle. Cette valeur, comprise entre 0 et 1, permet de signifier l’importance d’une règle parmi les autres règles. Dans la plupart des cas, ce paramètre est égal à 1, signifiant que toutes les règles ont la même importance.

Avec Pre-Generate Rules, les règles sont générées sans correspondre à la table de vérité établie pour le contrôleur flou.

Nous pouvons les modifier individuellement en choisissant dans les menus déroulants des antécédents et des conséquents. Dans notre cas, nous avons 2 antécédents et 1 conséquent.

Choix de la variable

Choix de la fonction d’appartenance

Une fois qu’on a choisi les variables et leurs fonctions d’appartenance pour les antécédents,

on passe ensuite aux conséquents (un seul dans notre cas) en choisissant leurs fonctions d’appartenance.

652 Partie II / Conception de contrôle et simulation

652

On peut choisir la méthode de défuzzification, comme la suivante pour le centre de gravité.

III.2. Edition des règles floues

La fenêtre suivante montre les règles de la table de vérité du contrôleur :

Dans l’onglet Test System, nous pouvons tester le régulateur en modifiant les valeurs des variables linguistiques des entrées. On considère teta = d_teta =0, soient les valeurs centrales des fonctions d’appartenance Z de ces 2 variables. On voit bien que seule est invoquée la règle : IF « teta est Z AND d_teta est Z » THEN « f est Z ». Dans cette fenêtre, on trace la surface qui définit la relation donnant la sortie en fonction des entrées.

Chapitre 17 / Contrôle par logique floue

653

III.3. Description, rapport HTML du système flou

Avec File Description, nous obtenons la fenêtre suivante dans laquelle nous pouvons décrire le système flou.

Le système flou peut être décrit sous la forme d’une page HTML avec File Create HTML Report. Dans le cas du système pendulum.fs, nous obtenons la page HTML suivante. Dans cette page, nous retrouvons la date de création du système flou, la définition des variables d’entrée et de sortie (leur univers de discours, le nombre et le type de leurs fonctions d’appartenance).

654 Partie II / Conception de contrôle et simulation

654

Les règles floues sont décrites avec leurs antécédents et leurs conséquents.

Chapitre 17 / Contrôle par logique floue

655

IV. Modification d’un système existant

Les VIs de logique floue sont généralement utilisés pour modifier légèrement des systèmes flous générés par l’outil Control Design and Simulation.

Ces VIs sont ceux qui possèdent, dans leur étiquette, le mot Set pour spécifier les valeurs des paramètres des variables, fonctions d’appartenance et des règles floues.

Les sous-palettes concernées sont les suivantes :

IV.1. Modification d’une fonction d’appartenance

Dans l’exemple suivant, nous allons étudier le moyen de modifier une fonction d’appartenance d’une variable d’un système flou.

Grâce au VI FL Load Fuzzy System.vi, nous récupérons un système flou créé par l’outil Control Design and Simulation.

Nous traçons les fonctions d’appartenance de la variable d’entrée. Le type de variable d’entrée ou de sortie, est spécifié par Input/Output, du VI FL

Plot Variable.vi. Il s’agit de la 1ère variable d’entrée par l’index 0 de l’entrée variable index. La modification des fonctions d’appartenance est réalisée par le VI FL Set Membership

Function.vi. Pour ce VI nous indiquons les index de la variable et de la fonction d’appartenance. A l’entrée shap, nous spécifions le type de la nouvelle fonction d’appartenance. Dans cet

exemple, nous transformons le type Sigmoid en celui de triangle.

Dans le panel, nous affichons l’ancienne et la nouvelle fonction d’appartenance (la fonction

d’index 0, la 1ère) ainsi que sa version modifiée. Les 2 nœuds de propriété permettent d’imposer les valeurs, -5 et 5, pour les axes X des

deux graphes XY.

656 Partie II / Conception de contrôle et simulation

656

IV.2. Modification des règles

La modification d’une règle se fait par le VI FL Set Rule.vi. Nous considérons la 4ème règle (index 3).

Nous spécifions les antécédents et les conséquents de cette règle. Nous affichons les règles du système flou d’origine ainsi que celles du système modifié,

grâce au VI Get Rules as Text.vi. Il permet d’afficher les règles sous forme de textes.

Nous remarquons seule la 4ème règle a été changée. Les fonctions d’appartenance sont numérotées de 0 à 3 ainsi que les variables numérotées

de 0 à 1 car le système possède 2 variables d’entrée. Dans notre exemple, nous considérons le cas où la variable n° 0 d’entrée appartient à la

2ème fonction d’appartenance (P) et que la 2ème variable appartient à son ensemble P, alors la sortie (1ère variable ou n° 0) appartient à la 2ème fonction d’appartenance.

Nous vérifions bien, grâce au VI FL Get Number of Membership

Functions.vi que chacune des 2 variables d’entrée possède 2 fonctions d’appartenance et que l’unique variable de sortie en possède 4.

Chapitre 17 / Contrôle par logique floue

657

Les 2 fonctions d’appartenance des variables d’entrées de ce système sont, toutes deux, appelées N et P. Ces noms sont obtenus par le VI FL Get Membership Functions Names.vi.

V. Création d’un système flou par des VIs

Un système flou (variables d’entrée et de sortie, règles) avec ses méthodes de fuzzification et défuzzification, peut être entièrement créé sans utiliser l’outil Fuzzy System Designer.

Nous allons créer un système flou à 2 variables d’entrée (erreur et variation de

l’erreur) et 1 de sortie (cde). Ces entrées sont spécifiées sous forme de constantes obtenues par le choix Créer Commande en pointant l’entrée du VI FL New Fuzzy System.vi avec le pointeur de la souris en forme de bobine.

La variable de sortie, cde, est définie comme constante dans le diagramme. C’est un

cluster constant contenant le nom de la variable, ses valeurs, minimale et maximale, et un cluster pour définir ses fonctions d’appartenance.

Cette variable de sortie a pour nom cde, ses valeurs s’étendent de -20 à 20. Ses fonctions

d’appartenance sont :

- GN (Grande négative), - Z (Zéro) - GP (Grande positive).

Les 4 règles sont définies dans le sous-VI règles.vi. Chacune de ces règles est définie

par ses antécédents et conséquents. L’exemple suivant concerne un système à 2 variables d’entrée et 1 variable de sortie. La

condition sur les variables d’entrée est appelée antécédent. Celle sur la variable de sortie est le conséquent.

Les 2 antécédents sont définis par le VI FL Create Antecedent.vi et le conséquent

par FL Create Consequent.vi. Chaque antécédent est défini par l’index de la variable d’entrée et celui de la fonction d’appartenance.

658 Partie II / Conception de contrôle et simulation

658

1ère variable de sortie qui appartient à la 3ème fonction

d’appartenance (index 2).

Le ET qui relie les 2 antécédents correspond à prendre le minimum des degrés d’appartenance et l’appliquer à la variable de sortie sur sa fonction d’appartenance.

Méthode d’implication

des conséquents (troncature des fonctions d’appartenance par le minimum).

Les différentes variables d’entrée et de sortie ainsi que les règles sont appliquées au VI FL

New Fuzzy System.vi qui crée le nouveau système flou. On lui applique également la méthode de défuzzification (Center of Area : centre de gravité) ainsi qu’une chaîne de caractères qui sert de description.

Nous traçons les fonctions d’appartenance par l’utilisation du VI FL Plot Variable.vi. Grâce à FL Get Variable Names nous récupérons les noms des variables d’entrée et de sortie. Le domaine des valeurs d’une variable d’entrée, Input ou de sortie, Output, ainsi que son nom sont déterminés par le VI FL Get Variable.

Les autres VIs permettent d’avoir les noms des fonctions d’appartenance, les règles sous forme de texte, le nombre de variables, etc.

Le diagramme suivant montre la création des 4 règles floues.

Chapitre 17 / Contrôle par logique floue

659

Le panel suivant affiche les règles créées dans le diagramme.

Dans le panel, nous créons les 2 variables d’entrée sous la forme de clusters. Nous

affichons leurs fonctions d’appartenance dans des graphes XY. La variable de sortie, cde, est définie par 3 fonctions d’appartenance GN

(triangular), Z (gaussian) et GP (triangular) que nous affichons grâce au VI FL Get Membership Functions Names auquel on indique la valeur Output dans le menu input/output. Les 4 règles créées dans le diagramme sont affichées sous forme de texte. Nous enregistrons ensuite le système créé dans le chemin qu’on définit grâce à la commande chemin file path.

660 Partie II / Conception de contrôle et simulation

660

Dans ce même panel, nous affichons le système sous la forme d’un cluster. Nous retrouvons les 2 variables d’entrée et l’unique variable de sortie.

Ce cluster contient également les 4 règles floues, la méthode de défuzzification ainsi que la description du système.

VI. Régulateur flou

VI.1. Sans intégration

Nous utilisons le système flou précédent, créé à l’aide de VIs, pour réguler un système modélisé par une fonction de transfert analogique du 1er ordre.

Le système flou est lu dans le répertoire défini par la commande Chemin qu’on applique à l’entrée file path du VI FL Load Fuzzy System.vi.

Ce système est appliqué à l’entrée fuzzy system in du VI FL Fuzzy Controller.vi. Dans le sélecteur de VI polymorphe, nous sélectionnons le type MISO (Multiple Input Single Output) pour plusieurs entrées et une seule sortie.

Les 2 entrées du régulateur sont l’erreur (différence entre la consigne échelon et la sortie du processus) et sa variation (t) déterminée par :

(t)= (t) - (t-1)

Chapitre 17 / Contrôle par logique floue

661

Le retard est réalisé par un nœud de rétroaction. Ces 2 quantités sont assemblées sous forme d’un tableau pour être appliquées au contrôleur

flou. Nous affichons la sortie et la consigne dans un même graphe XY ainsi que l’erreur et le signal de commande dans un autre graphe XY.

Le contrôleur flou et la fonction de transfert et les autres VIs sont insérés dans une boucle de contrôle et de simulation.

Dans le panel, nous affichons la sortie qui rejoint la consigne au bout d’une quarantaine

d’échantillons. Pour approcher le domaine continu de la fonction de transfert, le pas de temps de la boucle

est choisi égal à 1 ms.

662 Partie II / Conception de contrôle et simulation

662

VI.2. Avec intégration

L’ajout d’une intégration au contrôleur flou précédent, créé à l’aide de VIs de la sous-palette Fuzzy logic, consiste à générer une variation de commande suivante, soit :

)1()()( tututdu

Ainsi, la commande à appliquer au processus sera de la forme :

)()1()( tduktutu Nous considérons un processus de fonction de transfert discrète suivante:

)8.0()5.0

8.01)5.01()( 1

11

zzz

zzzzH

Le paramètre k permet de régler la dynamique de la boucle fermée. Dans notre exemple,

nous allons considérons 3 valeurs de ce paramètre k. Nous chargeons le même contrôleur flou créé avec des VIs flous de la sous-palette Fuzzy

logic. La consigne est un signal carré du VI Signal generation.

Pour k=0.05, la sortie rejoint le signal de consigne avec un seul dépassement avec un

dynamique proche d’un 2nd ordre d’amortissement optimal 7.0 . Pour k=0.1, le temps de réponse est plus petit et l’unique dépassement un peu plus grand. Avec k=0.5, le temps de réponse est encore plus petit mais des oscillations apparaissent au

changement de consigne.

Chapitre 17 / Contrôle par logique floue

663

VII. Régulation floue de l’angle d’un pendule inversé

Le pendule inversé consiste en un chariot qui se déplace le long d’un axe et supporte un pendule. Le but de cette régulation est de maintenir le pendule à la verticale en agissant sur la force F appliquée au chariot.

VII.1. Modèle du pendule

Le modèle linéaire du pendule, sous forme d’un modèle d’état, autour d’un point de fonctionnement et pour de faibles variations de l’angle est le suivant. Le modèle d’état est formé de 4 composantes :

- l’angle du pendule,

664 Partie II / Conception de contrôle et simulation

664

- la variation de l’angle, , - la position x du chariot, - la variation de la position, x .

xx

x

Le modèle d’état est donné par :

XCyfBXAX

avec :

)(

440

)4(6

0

0004

31000

000)4()(6

0010

tf

Mm

Mml

xx

Mmmg

MmlMmg

xx

VII.2. Sous-système du pendule

Pour la régulation, nous allons utiliser un sous-VI du modèle sous forme de modèle d’état du pendule inversé.

Nous utilisons un nœud MathScript pour spécifier les matrices d’état du pendule. Ces matrices, sorties de ce nœud, sont transformées en cluster de la même forme que celui représente un modèle d’état continu. Pour cela, nous remplaçons les matrices A, B, C et D d’un modèle vide par les sorties du nœud MathScript.

La discrétisation de ce modèle continu se fait à l’aide du VI CD Convert Continuous

to Discrete.vi qui a besoin de la période d’échantillonnage T et de la méthode de discrétisation.

Nous avons choisi la méthode du bloqueur d’ordre 0 Les autres méthodes sont la méthode bilinéaire de Tustin, le bloqueur d’ordre 1, etc.

Chapitre 17 / Contrôle par logique floue

665

Nous appliquons ce modèle au bloc Discrete State-Space (modèle d’état discret) pour lequel on choisit Terminal pour Parameter source et qu’on définit comme MIMO (Multi Output Multi Input) dans Polymorphic instance après un double clic.

On obtient alors l’entrée supplémentaire State-Space à laquelle on applique le modèle

discrétisé.

Le sous-VI possède les entrées suivantes :

- M (masse du chariot), - m (masse du pendule), - l (longueur du pendule), - T (période d’échantillonnage).

Une autre entrée est la force f qu’on applique au chariot.

Les sorties sont les 4 matrices A, B, C et D et le système d’état.

Dans le panel, le système d’état affiché concerne les paramètres par défaut, définis dans le nœud MathScript.

666 Partie II / Conception de contrôle et simulation

666

VII.3. Réponse impulsionnelle du pendule

Les matrices d’état sont spécifiées dans un nœud MathScript. Pour réaliser un modèle d’état, nous avons remplacé les matrices A, B, C et D d’un cluster d’état vide par les sorties du nœud MathScript. Ce modèle d’état continu est discrétisé à la période T grâce au VI CD Convert Continuous to Discrete.vi par la méthode du bloqueur d’ordre 0. Nous affichons ce modèle d’état discret dans le cluster Discrete State-Space Model.

La fonction de transfert discrète équivalente, obtenue par le VI CD Convert to Transfer Function Model.vi est affichée dans Equation à l’aide du VI CD Draw Transfer Function Equation.vi.

Les réponses impulsionnelles des 4 composantes du tableau de la sortie sont obtenues par le VI CD Impulse Response.vi à partir de la fonction de transfert multivariable (4 sorties et 1 entrée) du système du pendule inversé.

Ces 4 réponses impulsionnelles sont obtenues par l’indexation du cluster de sortie du VI.

Chapitre 17 / Contrôle par logique floue

667

Dans le panel, nous spécifions les valeurs des paramètres M, m et l du pendule ainsi que la période d’échantillonnage. Nous affichons le système d’état du modèle linéaire du pendule, ainsi que les 4 composantes de sa fonction de transfert discrète.

VII.4. Test du contrôleur flou

Dans le diagramme suivant, nous chargeons le système flou « inverted_pendulum.fs » à l’aide du VI FL Load Fuzzy System.vi. Nous affichons ce système en choisissant « Créer un indicateur » avec la souris, sous forme de bobine, par un clic droit. Ce système est appliqué à l’entrée Fuzzy system in du VI FL Fuzzy Controller.vi. L’entrée de ce contrôleur flou est un tableau formé par les commandes teta et teta_p correspondant à l’angle du pendule par rapport à la verticale ainsi que sa variation. Ces 2 commandes sont formées par des glissières horizontales. En sortie de ce contrôleur, nous trouvons la force f à appliquer au chariot ainsi que les poids des 9 règles du système flou.

668 Partie II / Conception de contrôle et simulation

668

Le cluster d’erreur se transmet de VI en VI à partir du cluster constant d’erreur d’entrée jusqu’au cluster de sortie. Ce contrôleur est inséré dans une boucle While. Les nœuds de propriété permettent de limiter les valeurs extrêmes des glissières aux valeurs limites de l’univers de discours des 2 variables d’entrée. Dans la 2ème partie du diagramme, nous utilisons un nœud MathScript pour spécifier les matrices d’état du pendule inversé. A l’aide de la fonction Assembler par nom, nous remplaçons les matrices A, B, C et D d’un cluster d’état par celles du pendule inversé que fournit le nœud MathScript. Le modèle d’état continu est discrétisé à la période d’échantillonnage T à l’aide du VI CD Convert Continuous to Discrete.vi par la méthode du bloqueur d’ordre 0. Nous affichons l’équation du modèle d’état en utilisant le VI CD Draw State-Space Equation.vi. Dans le panel, les glissières sont, toutes deux, réglées à zéro, ce qui correspond aux fonctions d’appartenance Z avec un degré d’appartenance maximal de 1. Nous vérifions bien que la variable force f appartient à l’ensemble Z avec un degré d’appartenance de 1. A l’aide du VI FL Get Rules as Text.vi nous mettons, face à face, les 9 règles sous forme de texte et leurs poids. Dans cet exemple, avec ce choix des valeurs des glissières, nous remarquons bien que le conséquent « la force f est Z » avec le poids maximal de 1. Les poids des autres règles sont tous égaux à 0 car aucune d’elles n’est invoquée par le contrôleur.

Chapitre 17 / Contrôle par logique floue

669

VII.5. Régulation floue de l’angle du pendule

Dans le diagramme suivant, nous mettons en œuvre le contrôleur flou afin de réguler l’angle du pendule à la valeur 0. Nous allons considérer plusieurs systèmes flous créés dans le designer. Un système « .fs » est chargé à l’aide du VI FL Load Fuzzy System.vi dans le chemin désigné par la commande Chemin. Ce système flou est appliqué à l’entrée fuzzy system in du contrôleur flou. Les entrées sont la sortie teta et sa variation teta_p obtenues par indexation de l’état du pendule. A l’aide d’une structure condition, on crée une perturbation sur la sortie en lui ajoutant la valeur 0.05 à l’instant i=10. Le pendule est symbolisé par son sous-VI qui reçoit les entrées M, m, L et T et retourne le cluster du modèle d’état et l’état dont les composantes sont, respectivement x,, et .x Chacune des grandeurs est obtenue par indexation de ce vecteur d’état. L’entrée du contrôleur flou est le tableau formé par l’angle et sa variation . Le système de régulation est inséré dans une boucle For cadencée à 0.05s. Nous allons appliquer cette régulation pour différents choix de fonctions d’appartenance pour l’angle , sa variation et la force f.

Exemple 1 (pendulum2.fs)

- Angle : 3 fonctions d’appartenance, N, Z et P gaussiennes.

670 Partie II / Conception de contrôle et simulation

670

- Variation : 3 fonctions d’appartenance triangulaires.

- Force f : 5 fonctions d’appartenance

NG : Négative Grande, triangulaire, N : Triangulaire, Z : Zéro, gaussienne, P : Positive, triangulaire, PG : Positive Grande, triangulaire.

Dans le panel suivant, nous observons des faibles oscillations autour de la position verticale du pendule.

Chapitre 17 / Contrôle par logique floue

671

Exemple 2 (pendulum.fs)

- Angle : 3 fonctions d’appartenance, N, Z et P triangulaires.

- Variation : 3 fonctions d’appartenance triangulaires.

- Force f : 5 fonctions d’appartenance triangulaires.

La réjection de la perturbation de l’angle se fait après 2 oscillations et rejoint assez rapidement la consigne.

672 Partie II / Conception de contrôle et simulation

672

Exemple 3 (pendulum3.fs)

- Angle : 2 fonctions d’appartenance, N et P sigmoïdales. Dans cet exemple, l’angle est défini par 2 fonctions d’appartenance, N et P, de types sigmoïdes.

- Variation : 2 fonctions d’appartenance sigmoïdales.

- Force f : 5 fonctions d’appartenance triangulaires.

Chapitre 17 / Contrôle par logique floue

673

L’angle rejoint la consigne de la position verticale après 4 oscillations.

Partie III

Applications

Partie III. Chapitre 18 - Analyse numérique

I. Résolution d'équations non linéaires I.1. Résolution d'équations non linéaires à une variable. I.2. Résolution de systèmes d'équations non linéaires II. Résolution d'équations et de systèmes différentiels II.1. Equations différentielles du premier ordre II.1.1. Méthode d'Euler II.1.2. Méthodes de Runge-Kutta d'ordre 2 et 4 II.2. Systèmes différentiels d'ordre 1 II.2.1. Méthode d'Euler II.2.2. Méthode de Runge-Kutta d'ordre 4 III. Résolution de système d’équations par des VIs de LabVIEW III.1. Résolution par l’algorithme d’Euler III.2. Résolution par l’algorithme de Runge-Kutta d’ordre 4 III.3. Système linéaire – solution symbolique et numérique

675DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _18,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie III / Applications

676

I. Résolution d'équations non linéaires

On trouve dans la littérature plusieurs méthodes numériques pour la résolution d'une équation de type f(x) = la dichotomie, la méthode de la tangente (dite de Newton), la méthode de la corde (dite de Lagrange), etc. Nous nous intéresserons dans cette partie, à la méthode de Newton-Raphson pour la résolution d'équations non linéaires à une ou plusieurs variables.

I.1. Résolution d'équations non linéaires à une variable.

On cherche la valeur x* qui annule la fonction f. La méthode de Newton-Raphson permet d'approcher par itérations la valeur x* au moyen de la relation suivante :

)('

)(1

kxfkxf

kxkx

Dans toutes les méthodes itératives, il est nécessaire, pour éviter une divergence de la solution, de bien choisir la valeur initiale. Celle-ci peut-être obtenue graphiquement. On se propose d'appliquer cette méthode pour la cherche des racines de la fonction non linéaire d'expression :

f x ex x( ) cos2

Dans une première étape, on se propose de tracer la courbe représentative de cette fonction f(x) pour x allant de -1 à +1. Le VI suivant utilise une boucle For pour calculer 50 valeurs de cette fonction.

Pour obtenir ces valeurs de x nous utilisons un nœud d’expression après avoir transformé l’entier i du terminal d’itération en type double.

Nous affichons cette fonction, en dehors de la boucle, dans un graphe XY et le tableau

formé de x et f(x) après avoir transposé la matrice formée de ces vecteurs.

Le panel suivant représente le tracé de la fonction ainsi que l’affichage de la matrice formée des colonnes de x et f(x). En utilisant les curseurs, nous pouvons déterminer approximativement la solution x*.

Chapitre I8 / Analyse numérique

677

Au vu de la valeur de x* obtenue par les curseurs, il est judicieux de choisir x0 = 0.5. La dérivée f' a pour expression:

)sin(2)(' xxexf . Dans le diagramme suivant, nous programmons, dans une boucle For, l’expression suivante:

)1('

)1(1

kxfkxf

kxkx

Dans un nœud MathScript, nous calculons les valeurs de f(x) en utilisant le tableau x obtenue dans la boucle For. Nous traçons l’évolution de la solution x et les valeurs correspondantes de la fonction f(x) dans un graphe.

Dans le panel suivant, nous programmons xk et f(xk) dans un graphe XY. Dans le tableau x, nous remarquons la convergence de x vers la solution exacte qui annule la fonction f(x). Dans le graphe x et f(x) nous traçons l’évolution de la solution x ainsi que les valeurs correspondantes de la fonction f(x).

Partie III / Applications

678

Dans le graphe suivant, nous calculons la solution x dans un nœud MathScript. Nous traçons, comme précédemment, dans le graphe x et f(x), l’évolution de la solution x ainsi que les valeurs correspondantes de la fonction f(x).

Dans ce panel, nous affichons, dans le graphe, les valeurs de x et celles de la fonction f(x).

Chapitre I8 / Analyse numérique

679

I.2. Résolution de systèmes d'équations non linéaires

Nous considérons le cas d'un système de 2 équations non linéaires à 2 inconnues,

0),(0),(

yxgyxf

Nous cherchons la solution (x, y) de ce système. Cette solution sera obtenue de proche en proche de façon récursive par l’algorithme de Newton-Raphson. L’algorithme de Newton-Raphson devient :

)1

,1

(

)1

,1

(1

)1,1(

),(),(

),(),(

11

ky

kxg

ky

kxf

kykxyyxg

xyxg

yyxf

xyxf

kykx

kykx

Comme exemple, considérons le système suivant :

022),(

022),(

yyxyxg

yxxyxf

Les fonctions f et g admettent comme dérivées partielles :

12),(2),(

2),(12),(

yy

yxgxx

yxg

yy

yxfxx

yxf

Nous appliquons la méthode de Newton-Raphson, à chaque itération. Nous nous intéressons aux fonctions, f(x,y) et g(x,y) à 2 variables, suivantes :

yyxyxgxyxyxf

22

22

),(),(

Dans le diagramme suivant, nous utilisons 2 nœuds MathScript. Dans le nœud MathScript 1, nous utilisons la fonction meshgrid pour obtenir les matrices

X et Y, permettant d’évaluer ces fonctions à 2 variables. Nous évaluons ensuite les fonctions f et g que nous traçons dans le graphe f et g.

Partie III / Applications

680

Dans le nœud MathScript 2, nous appliquons la méthode Newton-Raphson. Dans le graphe x et y, nous traçons l’évolution des solutions x et y.

Dans le graphe f et g, nous traçons les fonctions f et g à 2 variables x et y. Nous

remarquons que ces 2 fonctions se coupent et qu’il peut y avoir des solutions. La méthode de Newton-Raphson permettra de trouver la solution (x, y). Dans le nœud MathScript 2, nous utilisons la valeur initiale (x1, y1)= (1, 0.35) à partir de

laquelle nous recherchons la solution. Nous évaluons, dans la boucle For, la matrice :

1

)1,1(

),(),(

),(),(

kykxyyxg

xyxg

yyxf

xyxf

Dans le panel, nous affichons le tableau de l’évolution de la solution que nous traçons dans

le graphe x et y.

Chapitre I8 / Analyse numérique

681

II. Résolution d'équations et de systèmes différentiels

L'analyse temporelle de systèmes physiques aboutit très souvent à la résolution d'équations ou de systèmes d'équations différentielles d'ordre n, linéaires ou non linéaires. Ces équations sont, pour la plupart, impossibles à résoudre de façon analytique. La puissance, de plus en plus grande des calculateurs, associée à des logiciels évolués de calcul numérique permet la résolution de ces équations point par point. On étudiera deux méthodes de résolution très connues : méthodes d'Euler et de Runge-Kutta.

II.1. Equations différentielles du premier ordre

II.1.1. Méthode d'Euler

La méthode d'Euler consiste à estimer l'accroissement de y entre les abscisses xi et xi 1 par un développement de Taylor d'ordre 1.

yi yi h f xi yi1 ( , )

Cette méthode est très simple mais imprécise. Elle nécessite un pas h très petit, ce qui multiplie le nombre d'opérations et rallonge le temps de calcul. Considérons l'équation différentielle du premier ordre :

y f x yx

' ( , ) 12

Partie III / Applications

682

Avec les conditions initiales x 1 et y 1, la solution théorique est: y x2 1 .

Dans le diagramme suivant, nous calculons la solution théorique et celle obtenue par la méthode d’Euler avec un pas h=0.1. La fonction f(x, y) est transmise au nœud MathScript sous forme d’une chaîne de caractères qu’on évalue par la commande eval. Dans ce diagramme, nous définissons le temps de simulation de x0 à xf dans lequel nous définissons l’expression théorique de la solution. Nous cherchons la solution d’Euler dans la boucle for en évaluant la chaîne de caractères qui définit l’équation différentielle.

Dans ce panel nous représentons la solution théorique ainsi que celle qu’on obtient par la méthode d’Euler avec un pas h=0.1.

Plus le pas est petit plus la solution se rapproche de celle obtenue par la théorie.

La méthode d'Euler nécessite un pas h très petit.

Chapitre I8 / Analyse numérique

683

II.1.2. Méthodes de Runge-Kutta d'ordre 2 et 4

II.1.2.1. Méthode de Runge-Kutta d'ordre 2

On peut améliorer l'approximation d'Euler en estimant y par un développement de Taylor d'ordre 2.

21 fhiyiy

avec :

),(1

)12,

2(2

iyixff

fhiyh

ixff

Considérons l'exemple précédent avec le même pas h = 0.1.

Partie III / Applications

684

La solution obtenue par la méthode de Runge-Kutta d'ordre 2 coïncide parfaitement avec la solution théorique pour un pas h = 0.1.

II.1.2.2. Méthode de Runge-Kutta d'ordre 4

II.1.2.2.1. Nœud MathScript

On obtient une meilleure estimation en réalisant un développement de Taylor d'ordre 4.

yi yih

f f f f1 6 1 2 2 3 4( )

avec

)3,(4

)22,

2(3

)12,

2(2

),(1

fhiyhixff

fhiyh

ixff

fhiyh

ixff

iyixff

Runge-Kutta d’ordre 4 est encore plus précis que Runge-Kutta d’ordre 2 et Euler. Cette méthode utilise beaucoup plus de points intermédiaires. Dans la méthode de Runge-Kutta d’ordre 4, on obtient une précision d’ordre 4 en évaluant 4 fois la dérivée : une au point de départ, deux au milieu de l’intervalle et la quatrième au point final.

Chapitre I8 / Analyse numérique

685

II.1.2.2.2. Fenêtre MathScript

Nous allons effectuer la résolution de l’équation à l’aide de Runge-Kutta d’ordre 4 en utilisant la fenêtre MathScript qu’on obtient par l’option Fenêtre MathScript … du menu Outils du panel. fichier Application_Kutta4.m

Partie III / Applications

686

Ce fichier de la fenêtre MathScript fait appel à la fonction kutta4.m enregistrée dans le répertoire Documents/LabVIEW Data. L’appel de cette fonction se fait dans la ligne :

[x2,y2]=kutta4(x0,y0,xf,h(i),f); Les paramètres d’appel sont les conditions initiales x0 et y0, la valeur finale de x, le pas d’itération h et la fonction f sous forme de chaîne de caractères qu’on évalue avec la commande eval. fonction kutta4.m function [x,y]=kutta4(x0,y0,xf,h,f) % % Résolution d'équation différentielle par la méthode % de Runge-Kutta d'ordre 4 % [x,y] : tableau de valeurs de la fonction y(x) % x0, y0 : conditions initiales % h : pas % xf : valeur finale de x % f : expression de la fonction y'=f(x,y) % f est une chaîne de caractères % tx=x0: h:xf; ty=y0; for i=1:floor((xf-x0)/h) x=tx(i); y=ty(i); f1=eval(f); x=tx(i)+h/2; y=ty(i)+f1*h/2; f2=eval(f); y=ty(i)+f2*h/2; f3=eval(f); x=tx(i)+h; y=ty(i)+f3*h; f4=eval(f); ty(i+1)=ty(i)+h*(f1+2*f2+2*f3+f4)/6; end x=tx;y=ty;

Chapitre I8 / Analyse numérique

687

Dans la fenêtre suivante, nous traçons la solution théorique, et celles obtenues par la méthode de Runge-Kutta d’ordre 4 avec les pas 2, 1 et 0.1.

Nous remarquons bien que l’ordre 2 est le plus loin de la théorie et l’ordre 0.1 plus proche.

II.2. Systèmes différentiels d'ordre 1

Les calculs effectués précédemment peuvent se généraliser aux systèmes d'équations différentielles du premier ordre. Considérons le cas d'un système de 2 équations différentielles où u(x) et v(x) sont des fonctions de la variable réelle x.

),,()('),,()('

vuxgxvvuxfxu

La méthode est basée, comme précédemment, sur le principe qui consiste à choisir des valeurs discrètes de la variable x espacées d'un pas h,

hxx ii 1

pour lesquelles on calcule des valeurs approchées u xi( ) et v xi( ) à partir de conditions initiales données.

Partie III / Applications

688

II.2.1. Méthode d'Euler

L'algorithme d'Euler devient dans le cas d'un système de deux équations :

),,(1

),,(1

iviuixghiviviviuixfhiuiu

Considérons un moteur à courant continu, modélisé par le circuit suivant, pour lequel R et L sont respectivement la résistance et la self d'induit. La force contre-électromotrice E est proportionnelle à la vitesse angulaire w : wKE

L

R

Eu(t)

i(t)

L'équation électrique donne :

wKdt

tdiLtiRtu )()()(

D'autre part, si on note m le couple moteur et f le coefficient de frottements visqueux, l'équation mécanique permet d'écrire :

fmdttdwJ )(

m : couple moteur, proportionnel au courant d'induit iKm ,

f : couple de frottements visqueux, proportionnel à la vitesse angulaire

wff .

On obtient ainsi le système différentiel dont les variables sont le courant d'induit i et la vitesse angulaire w .

)]()([1)(

)]()()([1)(

twftiKJdt

tdw

twKtiRtuLdt

tdi

On se propose de déterminer l'évolution du couple moteur et de la vitesse angulaire.

Chapitre I8 / Analyse numérique

689

Les paramètres électromécaniques du moteur sont :

2.05.0,1..1.0,1..1.0

,50,5

mkgJsradmNfAmNK

mHLR

Dans ce fichier, les variables x, y et z définissent respectivement, le temps, le courant d’induit et la vitesse de rotation. Dans le diagramme suivant, nous faisons appel à la fonction syst_mot_euler.m à laquelle on transmet le temps initial x0, la valeur initiale du courant d’induit y0, la vitesse initiale z0, le temps final de simulation xf et le pas h. Dans cette fonction nous programmons la méthode d’Euler et nous récupérons le temps, le courant et la vitesse de rotation. Les grandeurs f et g sont celles qui définissent les équations différentielles. fichier syst_mot_euler.m function [x,y,z]=syst_Moteur_euler(x0,y0,z0,xf,h) % Résolution d'un système de deux équations différentielles % du premier odre, par la méthode d'Euler % [x,y,z] : tableau de valeurs des fonctions y(x) et z(x) % conditions initiales % x0 : temps2 % y0 : courant i % z0 : vitesse w % h : pas % xf : valeur finale de x % fsys : fichier M contenant les expressions des fonctions % y'=f(x,y,z) et z'=g(x,y,z) global R L K f J tx=x0:h:xf; % signal de commande (tension d’induit) u=5*(tx>=10 & tx<=50); ty(1)=y0; tz(1)=z0; for i=1:floor((xf-x0)/h) x=tx(i); % temps (s) y=ty(i); % courant (A) z=tz(i); % vitesse (rad/s)

Partie III / Applications

690

f1 = (u(i)-R*y-K*z)/L g1 = (K*y-f*z)/J ty(i+1)= ty(i)+h*f1; tz(i+1)= tz(i)+h*g1; L’appel de la fonction sys_mot_euler permet de récupérer le temps, le courant d’induit et la vitesse de rotation. Les entrées du nœud MathScript sont les paramètres du moteur, les conditions initiales et le pas h. En sortie, nous récupérons le temps, le courant d’induit qu’on multiplie par le coefficient K pour obtenir le couple qu’on trace, avec la vitesse de rotation, dans des graphes XY. Les variables R L K f J sont déclarées globales dans ce nœud MathScript et dans la fonction sys_moteur_euler afin que leurs valeurs soient connues dans cette fonction.

Dans le panel, nous avons le cluster qui regroupe les paramètres du moteur et les deux graphes XY de la vitesse de rotation et du couple moteur.

Chapitre I8 / Analyse numérique

691

Afin de comparer la courbe de la vitesse ci-dessus à celle qu’on obtient par la fonction de transfert continue ou du modèle d’état continu, nous allons utiliser le toolkit Conception de contrôle et simulation. Le modèle d’état continu qui définit le courant d’induit et la vitesse de rotation, se déduit directement des équations précédentes.

uBw

iAuL

w

i

Jf

JK

LK

LR

dtdw

dtdi

0

1

uDw

iCu

w

iw 010

Dans ce diagramme, nous définissons le modèle d’état du moteur grâce à la commande ss à

partir des matrices d’état ci-dessus. Dans la boucle de contrôle et simulation, nous utilisons le bloc State-Space. En double

cliquant sur ce bloc, nous créons l’entrée supplémentaire State-Space à laquelle on relie le résultat du nœud MathScript.

Nous appliquons un signal carré d’amplitude 5, de période 60 et de rapport cyclique 50%. La durée de la simulation est spécifiée à la valeur 60 dans le nœud d’entrée de la boucle de

simulation. Par indexation, nous récupérons la deuxième composante d’état qui est la vitesse de

rotation. Le bloc Collector associe le temps de simulation au signal temporel de la vitesse afin d’utiliser un graphe XY.

Partie III / Applications

692

Dans le panel, nous retrouvons la même courbe de vitesse que dans le cas précédent de résolution du système d’équations différentielles par la méthode d’Euler.

Dans le diagramme suivant, nous insérons les lignes de programme de la fonction sys_moteur_euler.m directement dans le nœud MathScript.

Nous obtenons, bien sûr, les mêmes résultats que précédemment.

Chapitre I8 / Analyse numérique

693

Dans le premier graphe XY, nous affichons la courbe de vitesse et le signal carré de commande. Dans le deuxième graphe, nous affichons simultanément le courant d’induit et le couple moteur.

Dans le diagramme suivant, nous créons l’échelon de commande grâce à une structure condition à l’intérieur d’une boucle For. Lorsque le temps de simulation est plus grand ou égal à 100, le signal de commande varie de 0 à 5. On ajoute 1 au terminal d’itération pour obtenir le temps tx de l’algorithme d’Euler. La taille N de ce tableau permet de fixer la limite haute de l’itération de la boucle For. Cette taille a été spécifiée par la valeur du terminal N de décompte de la boucle. Cette valeur est égale à la valeur entière de (tf-t0)/h. La commande floor du nœud d’expression permet d’arrondir à l’entier le plus bas de la valeur (tf-t0)/h. Nous traçons le courant d’induit dans le même graphe que le couple moteur ainsi que la vitesse et l’échelon de commande et la vitesse de rotation.

Partie III / Applications

694

Nous retrouvons les mêmes valeurs statiques et la même dynamique que précédemment.

II.2.2. Méthode de Runge-Kutta d'ordre 4

Pour déterminer les valeurs approchées de u x( ) et de v x( ) , solutions du système :

u x f x u vv x g x u v

'( ) ( , , )'( ) ( , , )

on utilisera l'algorithme de Runge-Kutta d'ordre 4 décrit ci-après.

ui uih f f f f

vi vih g g g g

1 6 1 2 2 2 3 4

1 6 1 2 2 2 3 4

( )

( )

avec

f f xi ui vi f f xih ui

h f vih g

g g xi ui vi g g xih ui

h f vih g

1 2 2 2 1 2 1

1 2 2 2 1 2 1

( , , ) ( , , )

( , , ) ( , , )

)3,3,(4)22,22

,2

(3

)3,3,(4)22,22

,2

(3

ghivfhiuhixggghivfh

iuhixgg

ghivfhiuhixffghivfh

iuhixff

II.2.2.1. Moteur à courant continu

Dans le 1er nœud MathScript du diagramme suivant, nous avons programmé l’algorithme de résolution d’un système d’équations différentielles de Runge-Kutta d’ordre 4.

Chapitre I8 / Analyse numérique

695

Les variables ty et tz respectivement le courant d’induit et la vitesse de rotation. A chaque étape de cet algorithme nous calculons les grandeurs f et g qui représentent les

dérivées du courant d’induit et de la vitesse de rotation. Les parties, électrique et mécanique, sont régies par les équations suivantes :

wfdtdwJe

dtdiLiRu ,

La force électromotrice e et le couple sont, respectivement proportionnels à la vitesse de

rotation w et au courant d’induit i avec le même coefficient K .

wKe iK

Nous obtenons les quantités f et g qui définissent les équations différentielles:

L

tzKtyRuL

wKiRudtdif

J

tzftyKJ

wfiKdtdwg

L’algorithme de Runge-Kutta d’ordre 4 est représenté par les lignes de code suivantes dans

le langage MathScript. La variable tx représente le temps de simulation sous forme d’un tableau allant de t0 à tf par pas de h.

tx=t0:h:tf; % temps ty(1)=i0; tz(1)=w0; % courant et vitesse for i = 1:floor((tf-t0)/h) x = tx(i); y = ty(i); z = tz(i); f1 = (u(i)-R*y-K*z)/L; g1 = (K*y-f*z)/J; x = tx(i)+h/2; y = ty(i)+f1*h/2; z = tz(i)+g1*h/2; f2 = (u(i)-R*y-K*z)/L; g2 = (K*y-f*z)/J; x = tx(i)+h/2; y = ty(i)+f2*h/2; z = tz(i)+g2*h/2; f3 = (u(i)-R*y-K*z)/L; g3 = (K*y-f*z)/J; x = tx(i)+h/2; y = ty(i)+f3*h/2;

Partie III / Applications

696

z = tz(i)+g3*h/2; f4 = (u(i)-R*y-K*z)/L; g4 = (K*y-f*z)/J; ty(i+1) = ty(i)+h*(f1+2*f2+2*f3+f4)/6; tz(i+1) = tz(i)+h*(g1+2*g2+2*g3+g4)/6; end t = tx; i = ty; w = tz; A la fin de l’algorithme, nous récupérons les tableaux du temps, courant et vitesse de rotation.

Les entrées du nœud MathScript sont :

- les paramètres électromécaniques du moteur obtenus par désassemblage du cluster Paramètres moteur défini dans le panel, - les temps, initial t0 et final tf, le pas h, les conditions initiales i0 et w0, - le signal de commande u, le temps de simulation tx ainsi que leur longueur N.

Le signal de commande est un échelon de hauteur 5 grâce à la structure condition. Nous avons ajouté 1 au terminal d’itération i afin que le temps commence à 1. La longueur N de ces tableaux est fixée par la valeur du terminal de décompte de la boucle For.

Dans ce diagramme, nous avons comparé la solution obtenue par Runge-Kutta d’ordre 4 à

celle donnée à la sortie du modèle d’état qui représente le modèle du moteur à courant continu. A partir des équations précédentes qui définissent le moteur, les variables d’état sont le

courant d’induit et la vitesse de rotation. Les équations d’état sont les suivantes. La commande est la tension u appliquée à l’induit.

Chapitre I8 / Analyse numérique

697

Nous avons le modèle d’état continu suivant :

uL

w

i

Jf

JK

LK

LR

dtdw

dtdi

0

1

et 01C

Ce modèle d’état est défini par le bloc State-Space de la palette Conception de contrôle et simulation Simulation Continuous linear systems.

En double cliquant sur ce bloc, nous spécifions Terminal à Parameter source. Ceci permet de créer l’entrée supplémentaire State-Space à laquelle on transmet le résultat de la commande ss du langage MathScript à partir des matrices du modèle d’état.

Nous avons récupéré, par indexation, la deuxième composante du modèle d’état correspondant à la vitesse qu’on compare au résultat obtenu précédemment.

Dans le 3ème graphe XY, nous remarquons que les deux vitesses coïncident parfaitement.

II.2.2.2. Circuit RLC

On se propose d'étudier l'évolution du courant i et de la tension s du circuit RLC suivant :

HLRFC 5.01100 C.

La tension d'entrée est un échelon e(t)=10V. Les lois de l'électricité permettent d'aboutir au système suivant d'équations différentielles :

Partie III / Applications

698

dttdsCti

dttdiLtiRtste

)()(

)()()()(

Mis sous la forme de Cauchy, le système devient :

Cti

dttds

LtiRtste

dttdi

)()(

)()()()(

Ces équations, représentant les grandeurs f et g de l’algorithme suivant (Runge-Kutta d’ordre 4) sont les variables de retour de la fonction RLC_dot.m à laquelle on transmet le temps, le courant et la tension.

L’algorithme de Runge-Kutta d’ordre 4 est programmé dans la fenêtre MathScript sous le

nom Appl_RLC_Kutta4.m.

Chapitre I8 / Analyse numérique

699

Les courbes suivantes représentent le courant dans le circuit et la tension aux bornes de la capacité. Les nombreuses oscillations montrent que le système est sous amorti.

Nous allons vérifier qu’on obtient le même résultat en traçant la courbe de la tension en utilisant les blocs de l’outil Conception de contrôle et simulation.

Nous utilisons le bloc Transfer Function de la sous-palette Continuous Linear Systems pour créer une fonction de transfert continue que l’on définit grâce à la commande tf à l’intérieur d’un nœud MathScript.

Cette commande crée la fonction de transfert à partir de son numérateur et son dénominateur.

Le bloc Collector, de la sous-palette Simulation Utilities, permet

d’associer le signal temporel de la vitesse de rotation et le temps de simulation afin de pouvoir utiliser un graphe XY à l’extérieur de la boucle de simulation.

Pour obtenir la réponse indicielle, nous avons appliqué à la fonction de transfert, un échelon

avec le bloc Step Signal de la sous-palette Signal Generation.

Partie III / Applications

700

Nous avons défini la même amplitude de 10 que dans le cas précédent. Le temps de simulation est fixé à 50 dans le nœud d’entrée de la boucle de contrôle et simulation.

Nous trouvons la même forme oscillatoire et les mêmes amplitudes que dans le cas précédent.

Chapitre I8 / Analyse numérique

701

II.2.2.3. Système mécanique

Considérons un corps de masse M accroché à un ressort de constante de raideur k. La résistance de l'air crée une force de frottement proportionnelle à la vitesse avec un coefficient f.

La position x de la masse est repérée par rapport à l'origine o correspondant à la longueur naturelle du ressort. Par application de la loi fondamentale de la dynamique, on obtient l'équation différentielle suivante qui régit l'évolution de la position x :

FxkxfxM

Cette équation du second ordre peut être transformée en un système de 2 équations différentielles du premier ordre. En posant vx , nous obtenons le système suivant à 2 équations différentielles :

vxMFxkvfv

MM

Nous allons résoudre ce système en utilisant la commande ode_rk45. Nous considérons les valeurs numériques suivantes :

mNksradNfKgM /2.0)//(1.01

Avant d’utiliser ces commandes, nous cherchons la réponse indicielle du système en

utilisant sa fonction de transfert et son modèle d’état avec le toolkit Conception de contrôle et simulation.

En utilisant la transformée de Laplace de l’équation différentielle :

)()()( 2 pFpXkpfpM

Nous obtenons alors la fonction de transfert liant la position x à la force F :

Partie III / Applications

702

kpfpMpFpX

2

1)()(

Le modèle d’état s’obtient à partir du système d’équations différentielles précédent.

vxMFxkvfv

MM

FMxv

Mk

Mf

xv

0

1

01

Pour obtenir la position x, nous devons spécifier la ma trice d’observation suivante :

10C

La matrice D est nulle car il n’y a aucune relation directe entre la commande F et la sortie x. Dans le nœud MathScript suivant, nous créons la fonction de transfert, à l’aide de la

commande tf à partir de son numérateur et dénominateur ainsi que son modèle d’état à l’aide de la commande ss à partir des matrices d’état.

Nous traçons la réponse indicielle pour chaque cas. Pour le cas de la fonction de transfert nous traçons le signal de sortie du VI CD Step

Response.vi dans un graphe XY, pour celle du modèle d’état, il suffit de choisir Créer Indicateur en cliquant droit à l’aide de la souris sous forme de bobine.

Nous obtenons la même réponse oscillatoire amortie

Chapitre I8 / Analyse numérique

703

La syntaxe de la fonction ode_rk45 est la suivante : [x, y] = ode_rk45(f, t0:tf, y0) f : chaîne de caractères représentant le nom d'un fichier M dans lequel est définie l'équation différentielle, t0, tf : valeurs, initiale et finale, de la variable temps, y0 : vecteur colonne de valeurs initiales de la fonction y = f(t). Le système d'équations différentielles doit être représenté dans un fichier fonction sous la forme d'un vecteur colonne où chaque ligne représente une équation du système.

Dans le diagramme suivant, nous définissons les variables k M F et fr comme globales et

nous leur assignons leurs valeurs numériques. De même nous définissons les conditions, initiale et finale, du temps de simulation et les

valeurs initiales de la position et de la vitesse.

Partie III / Applications

704

Pour la résolution du système d’équations différentielles, nous faisons appel à la fonction masse_dot.m dans laquelle nous définissons ce système à l’aide de la commande ode_rk45 basée sur l’algorithme de Runge-Kutta à pas variable. Nous transmettons à la fonction masse_dot.m le temps et le tableau des variables position et vitesse. Dans cette fonction, nous spécifions le système d’équations différentielles du l’ensemble masse-ressort-amortisseur.

Dans le panel, nous affichons, dans le même graphe XY, la courbe de la positon et de la

vitesse. Nous retrouvons bien la valeur statique 101k

x comme précédemment.

La vitesse s’annule bien en régime statique.

Chapitre I8 / Analyse numérique

705

III. Résolution de système d’équations par des VIs de LabVIEW

Les VIs de résolution des équations ou systèmes d’équations différentielles se trouvent dans la sous-palette Mathématiques Différentielles Equations différentielles Equations différentielles ordinaires.

III.1. Résolution par l’algorithme d’Euler

Considérons le circuit RLC suivant, pour lequel nous cherchons à calculer le courant i et la tension v aux bornes de la capacité.

La loi d’Ohm permet d’obtenir les 2 relations suivantes liant le courant i et la tension v aux bornes de la capacité :

dtdvCi

iRdtdiLEv

Les dérivées du courant et de la tension sont alors :

LiRvE

dtdi

Ci

dtdv

Partie III / Applications

706

Ce VI possède les entrées/sortie suivantes :

Dans le diagramme suivant, nous utilisons le VI ODE Euler Method.vi auquel nous appliquons les noms des variables v et i ainsi que t sous forme de chaînes de caractères.

Aussi pour les 2 autres chaînes correspondant aux expressions précédentes définissant les

équations différentielles du 1er ordre.

Il existe aussi des entrées pour les temps, initial et final, le pas de résolution h et les valeurs initiales des variables v et i.

En sortie, nous récupérons le tableau des solutions obtenues par cet algorithme. La durée de calcul, en millisecondes, est fournie par la sortie tops.

Un code d’erreur est fourni par la sortie erreur.

Avec mFC 1 , 100R , HL 1.0 , et VE 12 nous avons :

ivL

iRvEdtdi

idtdv

100010120

1000

Chapitre I8 / Analyse numérique

707

Dans cet exemple, nous avons défini les chaînes de caractères dv et di dans le panel en

fonction des variables i et v. Le courant s’annule en régime permanent à partir de la condition initiale i0=0.1 A.

La fonction de transfert du système est donnée par :

242 101.011

11)(

pppCLpCRpH

C’est un système de second ordre de pulsation propre sradw /10 2

0 et de coefficient

d’amortissement .521

LCR C’est un circuit fortement amorti.

Nous pouvons vérifier cette solution en traçant la réponse indicielle de cette fonction de transfert avec les valeurs précédentes des composants R, L et C.

Partie III / Applications

708

III.2. Résolution par l’algorithme de Runge-Kutta d’ordre 4

La résolution du même circuit RLC précédent par la méthode de Runge Kutta d’ordre 4 est effectuée par le VI ODE Runge Kutta 4th Order.vi.

Dans la partie 1, à ce bloc nous appliquons les noms des variables i et v ainsi que t pour le temps sous forme de chaînes de caractères. Les chaînes di et dv sont les expressions qui définissent les équations différentielles.

Comme pour le VI de la résolution par Euler, nous définissons les instants, initial et final ainsi que le pas h. Nous récupérons les solutions de la tension v et du courant i par indexation et nous les affichons dans un graphe.

Nous obtenons le même type de résultat que par la méthode d’Euler.

Chapitre I8 / Analyse numérique

709

Dans la partie 2 du diagramme, nous traçons la réponse de la fonction de transfert équivalente au circuit RLC.

Nous affichons cette fonction de transfert par le VI CD Draw Transfer Function Equation.vi. Nous appliquons un échelon à cette fonction de transfert. La réponse est équivalente à celle obtenue par la méthode de Runge-Kutta.

III.3. Système linéaire – solution symbolique et numérique

Dans la partie 1, nous utilisons le VI ODE Linear System Symbolic.vi auquel on transmet la matrice définissant le système linéaire d’équations différentielles ainsi que les conditions de courant et de tension. Nous considérons un circuit RLC en régime libre avec une condition initiale non nulle du courant.

Les lois des mailles et de Faraday nous donnent :

Les dérivées de la tension et du courant forment un tableau lié à celui des variables v et i

comme suit :

i

v

i

v

LR

L

C

dtdi

dtdv

110

10000

1

10

Ce système à 2 équations linéaire peut être résolu par le VI ODE Linear System. La

solution peut être du type symbolique ou numérique. Cette matrice, qu’on applique au VI, ainsi que le vecteur des conditions initiales sont définis dans le panel.

La solution symbolique en sortie de ce VI est affichée dans la chaîne formula. Le code de l’erreur est transformé en cluster d’erreur par le VI Error Cluster From Error Code.vi de la sous-palette Dialogue et interface utilisateur.

Dans la partie 2 de ce diagramme, nous avons évalué la chaîne correspondant à la solution de la tension par le VI Eval y=f(x).vi sur 100 points entre les instants 0 et 10. Nous affichons le résultat de cette évaluation dans le graphe tension v.

Partie III / Applications

710

Dans la partie 3, nous utilisons le VI ODE Linear System Numeric.vi pour obtenir la solution numérique du système linéaire d’équations différentielles. Après avoir transposé le tableau résultat, nous les affichons directement dans le graphe tension v et courant i. Le cluster d’erreur est obtenu par la fusion des 3 clusters d’erreur par la fonction Fusionner les erreurs de la sous-palette Dialogue et interface utilisateur.

Les 2 graphes transitoires de la tension sont les mêmes. La tension et le courant s’annulent

puisque nous sommes en régime libre.

Partie III. Chapitre 19 - Statistiques et probabilités

I. Calcul de moyenne, variance, mode et médiane I.1. Moyenne et variance I.2. Ecarts, gamme et centile I.3. Mode et médiane I.4. Moments II. Coefficient de corrélation II.1. Coefficient de corrélation linéaire

II.2. Tracé d’histogramme II.3. Kurtosis et Skewness d’une distribution II.3.1. Kurtosis ou indicateur d’écrasement

II.3.2. Coefficient de Skewness ou de d’asymétrie II.3.3. Exemple III. Lois de probabilité III.1. Lois continues III.1.1. Loi de Gauss III.1.2. Loi Gamma III.1.3. Loi exponentielle III.1.4. Loi du khi-2 ou khi carré III.2. Lois discrètes III.2.1. Loi de Bernoulli III.2.2. Loi Binomiale IV. Théorème central limite ou théorème de limite centrale V. Covariance et matrice de covariances V.1. Covariance de 2 variables aléatoires V.1.1. Calcul de la covariance à partir du coefficient de corrélation linéaire V.1.2. Estimation de la corrélation V.2. Matrice de covariances V.2.1. Application pour la taille et l’âge V.2.2. Application pour les dimensions d’une pièce usinée V.2.3. Matrice de covariances des bruits blancs V.2.4. Matrice de covariances d’un bruit blanc et d’un signal sinusoïdal V.2.5. Matrice de covariances d’un bruit blanc et d’un bruit rose

711DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _19,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie III / Applications

712

La sous-palette Probabilités et statistiques se trouve dans la palette Mathématiques.

On trouve des VIs qui permettent de calculer des paramètres statistiques, tels la moyenne, variance, covariance, tracé d’histogramme, etc.

I. Calcul de moyenne, variance, mode et médiane

I.1. Moyenne et variance

Dans le diagramme suivant, nous générons un bruit gaussien, de variance 1, en utilisant le VI Waveform de bruit gaussien de la sous-palette Traitement du signal Génération de waveforms.

Chapitre 19 / Statistiques et probabilités

713

Nous spécifions un écart-type de 1. Nous récupérons le signal contenu dans la waveform, pour lequel nous calculons la moyenne et la variance.

Dans le panel, nous affichons les différents résultats de moyenne, variance et le bruit

temporel. Nous retrouvons une moyenne nulle et une variance proche de 1, valeur que nous avons spécifiée.

I.2. Ecarts, gamme et centile

Différents écarts permettent de renseigner sur la dispersion d’une distribution statistique. L’écart le plus courant étant l’écart-type qui mesure l'étalement d'un ensemble de données autour de la valeur moyenne. La gamme mesure la différence entre les valeurs, minimale et maximale, d’un tableau de données. Le centile est chacune des 99 valeurs qui divisent un tableau de données en 100 parts égales.

. Dans le diagramme suivant, nous utilisons le VI Measures of spread.vi pour calculer des moyennes selon le type qu’on spécifie dans la constante menu déroulant. Lorsqu’on spécifie « écart-type », on calcule d’abord la variance qui est la moyenne des écarts au carré, par rapport à la moyenne du tableau x.

Partie III / Applications

714

n

kx xx

n 1

22 )(1 avec n

kkx

nx

1

1

Les paramètres statistiques d’un échantillon ou tableau sont tous des moyennes. L’écart-type est la racine carrée de cette variance. La gamme est définie comme étant la

différence entre les valeurs, maximale et minimale. Cette gamme est calculée par le VI Measures of spread.vi pour lequel on spécifie le type « gamme » pour la moyenne à calculer. Pour comparaison, nous calculons le max et le min du tableau dont nous faisons la différence. L’écart moyen absolu est la moyenne des valeurs absolues des valeurs du tableau. Par comparaison, nous calculons cette moyenne en considérant la valeur absolue du tableau dont on calcule la moyenne. L’écart interquartile est une mesure de dispersion qui s'obtient en faisant la différence entre le premier et le troisième quartile. L’interquartile Q2 correspond à la médiane de la série statistique considérée.

L’écart interquartile, différence Q3-Q1, mesure la dispersion de la distribution considérée.

La fonction de répartition est divisée en 4 parties de 25% chacune. Nous visualisons, dans

le schéma suivant, les interquartiles Q1, Q2 et Q3 et l’écart interquartile Q3 - Q1. La densité de probabilité d’une variable aléatoire gaussienne centrée (moyenne nulle) et

réduite (écart-type unité) est donnée par l’expression suivante : 2

2

21)(

t

exf

L’écart interquartile peut s’obtenir à partir de la fonction de répartition, ).()( xXPxF La fonction de répartition F(x) est tabulée.

Densité de probabilité f(x)

Fonction de répartition F(x)

Pour cette distribution, Q2, correspondant à la médiane, est nul. Q1 = 0.67 et Q3 = -0.67,

l’écart interquartile vaut : Q3 - Q1 = 1.34

Chapitre 19 / Statistiques et probabilités

715

La fonction de répartition est la surface comprise ente la courbe de f(x) et l’axe des x. Dans le diagramme suivant, nous calculons la densité de probabilité d’une loi de probabilité

d’une loi gaussienne, centrée et réduite, dans un nœud MathScript. Nous calculons son intégrale par le VI Integral x(t).vi en utilisant la méthode des

trapèzes pour le calcul de surfaces.

Nous vérifions, dans le panel, que la médiane est nulle du fait que loi est centrée. Dans ce panel, nous affichons la densité de probabilité et de la fonction de répartition que

nous avons obtenue par intégration de la densité.

Tout comme le quartile divise un échantillon en 4 parts égales (25%), le centile le fait en 100 intervalles égaux de 1%.

Le 1er centile limite le 1% inférieur des données, jusqu’au 99ème centile. Dans la fonction de répartition d’une loi normale centrée réduite, le 20ème centile est tel

que F = 0.2, soit environ C20=0.8. Le 50ème centile est le centile médian soit 0 ou F=0.5 puisque la distribution est centrée.

Partie III / Applications

716

L’écart interquartile mesure l’écart entre le 25-ième et 75-ième centile d’un tableau. Cette mesure d'étalement supporte mieux les valeurs aberrantes que les autres mesures.

Dans le diagramme suivant, nous calculons le minimum du signal obtenu par la waveform

après avoir récupéré le signal temporel Y. Puis nous l’affichons dans un graphe. Ensuite, nous calculons l’écart-type, la gamme, l’écart moyen absolu et l’écart interquartile.

Chapitre 19 / Statistiques et probabilités

717

Nous avons spécifié une variance de 1 pour le signal gaussien, ce que nous retrouvons dans

ce panel avec un écart-type de 1.03548. La gamme vaut 6.05608, ce que nous observons approximativement dans le graphe suivant

et dans la valeur 5.90415 correspondant pour la différence entre les valeurs, maximale et minimale, obtenue par le VI Max. et min. d’un tableau.

I.3. Mode et médiane

Le mode d’une distribution est la valeur qui revient le plus fréquemment. Pour l’ensemble de données {2, 3, 5, 2, 4, 2}, le mode unique est 2.

Une série de données peut avoir plusieurs modes ; elle est dite multimodale, comme

l’ensemble {4, 2, 8, 4, 7, 4, 3, 8, 4, 8} qui a les deux modes : 4 et 8. Le mode est obtenu par le VI Mode.vi.

On peut choisir le type unimodal ou Multimodal pour le type de série considérée.

Partie III / Applications

718

Dans le diagramme suivant, nous considérons 3 cas pour une même série de données : le type unimodal, avec l’entrée Intervalles égal à 0 et 1.

Lorsque cette entrée est égale à 1, la sortie est la valeur centrale de la série, lorsque cette entrée vaut 0, on obtient le mode réel.

Dans le cas multimodal, nous obtenons les différents modes de la série.

I.4. Moments

Une variable aléatoire est définie par des valeurs typiques correspondant aux notions de valeur centrale (ou de position) et de dispersion.

Le moment est un paramètre statistique d’une variable aléatoire X, la moyenne ou paramètre de position est le moment d’ordre 1, la variance est le moment d’ordre 2.

Le moment d’ordre k, km , est défini comme étant l’espérance mathématique de la variable X à la puissance k, soit :

)( kk XEm

Le moment centré d’ordre k, exemple de la variance pour le moment d’ordre 2, est défini comme l’espérance mathématique de la variable à laquelle on soustrait la valeur moyenne et qu’on élève ensuite à la puissance k.

kk XEXE ))(

Le VI Moment about mean permet de calculer le moment centré d’un tableau X, soit

celui d’une variable aléatoire à laquelle on a soustrait sa valeur moyenne. L’entrée ordre permet de choisir le type de moment qu’on veut calculer :

- moment d’ordre 1 ou espérance mathématique (moyenne), - moment d’ordre 2 ou variance, - moment d’ordre 3 ou Skewness, - moment d’ordre 4 ou Kurtosis, etc.

Chapitre 19 / Statistiques et probabilités

719

On définit le moment centré d’ordre k par 1

0)(1 n

i

ki

kx xx

n.

x est la valeur moyenne de la variable X, n la taille du tableau et k l’ordre du moment. Dans le diagramme suivant nous calculons les moments centrés d’ordre 1 et 2 qui

correspondent, respectivement, à la moyenne et à la variance du tableau aléatoire gaussien généré par le VI Gaussian White Noise Waveform.vi sous forme de waveform d’un bruit blanc gaussien centré.

Nous traçons également le signal temporel ainsi que son histogramme.

Dans le panel, nous vérifions le type gaussien de la distribution du signal ainsi que la

similitude du moment centré d’ordre 1 et la moyenne ainsi que le moment centré d’ordre 2 et la variance.

II. Coefficient de corrélation

II.1. Coefficient de corrélation linéaire

Le coefficient de corrélation linéaire est lié à la notion de régression linéaire. Ce coefficient est compris entre -1 et +1.

Partie III / Applications

720

Le coefficient de corrélation linéaire sert à quantifier la liaison mathématique linéaire entre 2 variables quantitatives. Ce coefficient est donné par l’expression suivante, pour 2 variables X et Y :

)()(

)()(

1

0

1

0

1

0

yyxx

yyxxr

k

N

k

N

kk

k

N

kk

La covariance entre X et Y a pour expression :

Nxy1 )()(

1

0yyxx k

N

kk

Les variances des variables aléatoires X et Y sont données par :

1

0

22 )(1 N

kkx xx

N et

1

0

22 )(1 N

kky yy

N,

1

0

N

kkxx et

1

0

N

kkyy sont les moyennes des échantillons ou variables X et Y.

Plus la valeur absolue du coefficient de corrélation linéaire se rapproche de 1, mieux la

corrélation linéaire est meilleure. r = 1 : la corrélation linéaire est parfaite, Y= a X + b avec a>0, r = -1 : la corrélation linéaire est parfaite, Y= a X + b avec a<0,

r = 0 : pas de corrélation linéaire.

La droite de régression linéaire est donnée par :

1

0

2

1

0

)(

)()(

N

kk

N

kkk

xx

yyxxa

avec y=a x +b, et en utilisant les propriétés de la moyenne ou espérance mathématique, nous avons :

bxEabxaE )()( , soit :

bxay , soit xayb .

Nous donnons ci-après quelques exemples de ce coefficient ainsi que les courbes correspondantes.

Dans le cas où ce coefficient est égal à 1 en valeur absolue, nous obtenons une droite. Dans le cas où il est égal à +0.7 et -0.7, on observe une tendance linéaire.

Chapitre 19 / Statistiques et probabilités

721

Les 2 cas r=0, l’abscisse et l’ordonnée sont toutes deux aléatoires dans le premier cas et une forme en x4 bruitée dans l’autre.

r = 1

-2.5 -2 -1.5 -1 -0.5 0 0.5 1 1.5 2 2.5-5

-4

-3

-2

-1

0

1

2

3

4

5

r = -1

-2.5 -2 -1.5 -1 -0.5 0 0.5 1 1.5 2 2.5-1.5

-1

-0.5

0

0.5

1

1.5

r = 0.7

-3 -2 -1 0 1 2 3-2

-1.5

-1

-0.5

0

0.5

1

1.5

2

r = -0.7

-2 -1.5 -1 -0.5 0 0.5 1 1.5 2 2.5-2

-1.5

-1

-0.5

0

0.5

1

1.5

2

r = 0

-3 -2 -1 0 1 2 3-1.5

-1

-0.5

0

0.5

1

1.5

r = 0

-2 -1.5 -1 -0.5 0 0.5 1 1.5 2-18

-16

-14

-12

-10

-8

-6

-4

-2

0

2

Dans le diagramme suivant, nous considérons les données représentant l’âge et la taille

d’une personne de 0 à 25 ans. On se propose d’effectuer une régression linéaire de la taille en fonction de l’âge.

Nous disposons d’un tableau 2D (tableau constant spécifié dans le diagramme) que nous

indexons pour obtenir les tableaux 1D de l’âge et de la taille. Nous utilisons le VI Correlation Coefficient de la palette Mathématiques

Probabilités et statistiques pour calculer le coefficient de corrélation.

Partie III / Applications

722

Nous calculons le coefficient de corrélation linéaire dans le nœud MathScript ainsi que les paramètres a et b de la droite de régression linéaire. Nous affichons cette droite ainsi que les mesures dans un même graphe XY.

Nous traçons, dans un graphe, l’erreur de régression, mesures – droite de régression, et

affichons sa moyenne et sa variance obtenues par le VI Std Deviation and Variance.vi. Le coefficient de régression linéaire, 0.9674, étant proche de 1, l’erreur de régression est faible.

Dans le panel, nous représentons les vecteurs de l’âge et de la taille et affichons leur graphe

ainsi que la droite de régression de ces mesures dans un graphe XY. Dans un graphe, nous affichons l’erreur de la régression ainsi que sa moyenne et sa

variance. Nous obtenons une moyenne nulle et une variance faible de 0.0055. Ceci est dû à la valeur de 0.9674 du coefficient de régression linéaire assez proche de 1.

Chapitre 19 / Statistiques et probabilités

723

II.2. Tracé d’histogramme

Nous pouvons aussi générer un signal aléatoire par l’intermédiaire du VI de type Express Simuler un signal de la palette Express Entrée.

En double cliquant sur le VI, nous pouvons cocher la case Ajouter un bruit à un signal quelconque dont nous pouvons spécifier une amplitude nulle.

Avec le VI Histogram et General Histogram, nous traçons l’histogramme

d’un signal aléatoire de distribution uniforme de la palette Traitement du signal Generation de waveforms.

Nous utilisons, d’autre part, des VIs de type Express pour générer un bruit gaussien par le

VI Simuler un signal qu’on ajoute à un signal continu de valeur nulle. L’histogramme est obtenu par le VI Créer un histogramme. Le VI Express Statistics permet de calculer beaucoup de paramètres statistiques d’un

signal. Ces paramètres sont choisis dans la fenêtre de dialogue de ce VI. Par un double clic sur ce VI, nous avons choisi de récupérer la moyenne, la variance,

l’aplatissement (Kurtosis) et la dissymétrie (Skewness). Ces paramètres sont assemblés pour former un cluster.

Partie III / Applications

724

Dans la face-avant, nous traçons les histogrammes du bruit uniforme, du bruit gaussien ainsi que le signal temporel de ce dernier.

Nous vérifions la moyenne et la variance unité du bruit gaussien. Le Kurtosis est égal à 3,06 car il est gaussien et le Skewness nul car la distribution est symétrique.

II.3. Kurtosis et Skewness d’une distribution

II.3.1. Kurtosis ou indicateur d’écrasement

La mesure de Kurtosis mesure le degré d’écrasement de la distribution. Il est adimensionnel et défini par l’expression suivante :

22

4

)()(

xxExxEK

Chapitre 19 / Statistiques et probabilités

725

C’est le moment centré d’ordre 4 sur le carré de la variance. Lorsqu’il est positif, la distribution est pointue. Le Kurtosis d’une gaussienne est égal à 3.

Le degré d’aplatissement d’une distribution est défini par le moment d’ordre 4 :

44 )( xxE

Afin d’avoir un nombre sans dimension, on le divise par le carré de la variance. Souvent, on retranche cette valeur pour obtenir le coefficient de Fisher.

II.3.2. Coefficient de Skewness ou de d’asymétrie

Le coefficient de Skewness indique le degré d’asymétrie d’une distribution. Il est défini par l’expression suivante :

32

3

)(

)(

xxE

xxES

C’est le rapport du moment d’ordre 3 sur le cube de l’écart-type. S’il est nul, la distribution

est symétrique. S’il est positif, la distribution est asymétrique vers la droite, s’il est négatif, elle l’est vers la gauche. Une loi gaussienne possède un coefficient de Skewness nul.

II.3.3. Exemple

Nous avons calculé le Kurtosis et le Skewness dans un nœud MathScript en utilisant leurs formules littérales suivantes :

32

3

)(

)(

xxE

xxES et 22

4

)()(

xxExxEK

Nous utilisons également le VI Skewness and Kurtosis.vi pour calculer le Skewness et Kurtosis des données du tableau en entrée. Nous traçons l’histogramme des données du tableau en utilisant le VI de type Express Créer un histogramme. Dans le cadre, pour Tableau 2, nous calculons son Skewness et son Kurtosis de la même façon. Dans le dernier cadre, nous générons un signal gaussien centré de variance unité.

Ce VI de la sous-palette Traitement du signal Génération de

waveforms génère des waveforms dont nous récupérons le signal Y par le VI Obtenir des composantes des waveforms afin de passer du type waveform au type flottant.

Partie III / Applications

726

Ensuite, nous utilisons les mêmes VIs pour calculer le Skewness et le Kurtosis des données obtenues. Comme le signal est gaussien, il doit avoir, théoriquement un Skewness de 0 car sa dispersion est parfaitement symétrique et Kurtosis de 3.

Les valeurs du Skewness et du Kurtosis, obtenues par le VI Skewness et Kurtosis

ainsi que par calcul littéral dans le nœud MathScript, sont équivalentes. La valeur obtenue d’un Kurtosis de 2,79141, proche de 3 caractérise une loi gaussienne. Un

Skewness de 0,00219017, proche de 0, signifie que la distribution est symétrique.

On vérifie le kurtosis de 3 d’une distribution gaussienne et un skewness nul du fait de sa

symétrie. L’ensemble de ces blocs sont insérés dans une boucle While cadencée à 0.5 seconde.

Nous vérifions bien la valeur 3 du Kurtosis d’une gaussienne et sa dissymétrie nulle.

Chapitre 19 / Statistiques et probabilités

727

III. Lois de probabilité

III.1. Lois continues

III.1.1. Loi de Gauss

La loi de probabilités de Gauss est définie par une densité de probabilité : 2)(

21

21)(

xx

exf

Les valeurs distribuées selon cette loi peuvent-être obtenues par le VI Continuous Random.vi, de la sous-palette Probabilités Continu aléatoire, qui possède les entrées-sorties suivantes :

Nous devons spécifier la moyenne x et l’écart-type des données aléatoires qu’on

récupère en sortie. Dans le diagramme suivant, nous générons 1280 valeurs d’une variable aléatoire gaussienne centrée (moyenne nulle) et réduite (écart-type unité).

Dans ce panel, nous affichons le signal temporel, la moyenne spécifiée de 0, la médiane qui

est égale à la valeur spécifiée de la moyenne, soit 0. La dissymétrie de -0.0138, proche de zéro, montre que l’histogramme ou densité de probabilité est symétrique.

Le coefficient de Kurtosis de 2.84701, proche de 3, montre que cette distribution est de caractère gaussien.

La valeur d’étalement qu’on a spécifiée comme étant l’écart- type vaut 1.00217, proche de 1 comme spécifié dans la génération du signal. La médiane ou valeur centrale est de 0.00 quasiment nulle car le signal est centré. L’histogramme est bien celui d’une gaussienne.

Partie III / Applications

728

III.1.2. Loi Gamma

La loi Gamma est une distribution, de variables aléatoires réelles et positives, dont la densité de probabilité est donnée par l’expression suivante, si on note X la variable aléatoire de distribution Gamma.

)(),;( 1

xexxp

Cette distribution dépend des 2 paramètres et , strictement positifs, appelés respectivement facteur de forme et d’échelle.

Cette distribution permet de modéliser beaucoup de paramètres physiques évoluant selon des lois exponentielles, du 2 (khi-deux ou khi carré), etc. Dans le diagramme suivant, nous générons des variables aléatoires de Gauss ou Gamma. Dans le cas de la distribution Gamma, nous traçons la densité de probabilité avec Continuous PDF.vi et la fonction de répartition en utilisant le VI Continuous CDF.vi.

Chapitre 19 / Statistiques et probabilités

729

Nous calculons la moyenne et la variance avec 2 méthodes : en générant la même loi Gamma et en utilisant le VI Std Deviation and Variance.vi et en calculant le moment centré d’ordre 2 correspondant à la variance donnée le VI Continuous Moments.vi. Dans le panel, nous affichons la densité de probabilité et la fonction de répartition dans les graphes XY.

Nous obtenons une moyenne de 20 et une variance de 100. Nous avons choisi les paramètres b=4 et c=5 correspondant aux paramètres et .

La moyenne et la variance sont données par :

20)(XE 100)( 22 X

Nous vérifions bien ces valeurs théoriques.

III.1.3. Loi exponentielle

La loi exponentielle d’une variable X, d’espérance mathématique E(X) définit, par exemple, la durée de vie d’un objet.

Dans le cas d’une variable aléatoire qui suit cette loi, la densité de probabilité est donnée

par les expressions suivantes :

0)(

1)(

00)(

)( teXE

tf

ttf

XEt

Elle est souvent définie selon un paramètre comme suit :

tetf )( avec 1)(XE , étant un paramètre strictement positif.

Partie III / Applications

730

La variance vaut 2

1 et la médiane prend la valeur E(X) ln(2).

Dans le diagramme suivant, nous allons vérifier ces différents paramètres en générant 1280 valeurs d’une variable aléatoire de dispersion exponentielle, par l’utilisation du VI Continuous Random.vi pour lequel on choisit l’option Exp pour la dispersion exponentielle.

Dans le panel, nous vérifions que la médiane, obtenue par le VI Median.vi, est égale à

E(X) ln(2) et que la moyenne est égale à l’écart-type soit 0.5 comme spécifié lors de la génération de la loi exponentielle.

Nous vérifions également que les valeurs de la variable aléatoire sont toutes positives. Nous affichons le cluster d’erreur du VI de type Express Créer un histogramme. L’élément status (état) permet d’arrêter la boucle lorsqu’il y a erreur lors de l’exécution

de ce VI. Nous affichons également les coefficients du Kurtosis et de dissymétrie (Skewness) dont la

valeur 1.7884 qui signifie que la distribution n’est pas symétrique.

Chapitre 19 / Statistiques et probabilités

731

III.1.4. Loi du khi-2 ou khi carré

La loi du 2 est générée quand on fait la somme de variables indépendantes, de distributions gaussiennes centrées et réduites. Lorsqu’on fait la somme de k variables, la variable somme, élevée au carré, suit une loi du 2 à k degrés de liberté.

Si X1, X2, …, Xk les k variables indépendantes, distribuées selon des lois normales de moyenne ix et d’écart-type i , la somme de ces variables centrées et réduite suit une loi du

2 à k degrés de liberté. Cette variable est donnée par :

2

1)()(

k

i i

ixXkY

i

La fonction de répartition de cette variable est donnée par :

21

2

2 )2

(2

1)(tk

k etk

tf

représente la fonction Gamma, 0

1)( dtetx tx pour 0x

Nous générons, dans le diagramme suivant, une loi du 2 à 7 degrés de liberté. L’espérance mathématique vaut k et la variance 2k.

Partie III / Applications

732

Nous vérifions les valeurs théoriques k et 2k, respectivement de la moyenne et de la variance.

III.2. Lois discrètes

III.2.1. Loi de Bernoulli

La loi de Bernoulli est une distribution de probabilité discrète qui prend la valeur 1 avec la probabilité p et 0 avec la probabilité q = 1-p.

xx ppxsixsi

pp

xXP 1)1(01

1)(

Toute épreuve qui n’admet que 2 issues, l’apparition d’un événement A avec une probabilité p et A avec la probabilité 1-p, est une épreuve de Bernoulli.

Dans le diagramme suivant, on génère 1280 épreuves de Bernoulli avec p=0.2. Nous vérifions la moyenne, égale .2.0p et la variance de 16.0)1( pp . Le VI Discrete Random qui génère des lois discrètes telle la loi discrète de Bernoulli

se trouve dans la sous-palette Probabilités Discrète aléatoire. Nous générons une distribution de Bernoulli dont nous allons vérifier ses différents

paramètres statistiques (moyenne, variance, etc.).

Chapitre 19 / Statistiques et probabilités

733

Les entrées-sorties du VI Discrete Random.vi avec le choix Bernoulli sont les suivantes :

Nous affichons quelques valeurs du signal généré et vérifions :

- la moyenne 20.0)( pxE - la variance 16.0)2.01(*2.0)1( pp .

Nous calculons la moyenne et la variance en utilisant le VI Std Deviation and

Variance.vi et en calculant les moments discrets par le VI Discrete Moments.vi.

III.2.2. Loi Binomiale

Une variable binomiale Sn est la somme de n variables de Bernoulli. Ainsi, une variable binomiale représente le nombre de succès obtenus lorsqu’on répète n épreuves identiques et indépendantes de Bernoulli, chacune d’elles ne pouvant résulter que 2 résultats possibles : échec ou réussite. La loi de probabilité de la somme de n variables de Bernoulli, de paramètre p, est la loi binomiale de paramètres n et p.

Si Xi est la ième variable de Bernoulli, la variable Sn de la loi binomiale est donnée par : n

iin XS

1

La probabilité d’avoir k succès à l’issue de n épreuves indépendantes est donnée par l’expression suivante :

knkkn ppCkSnP )1()(

Partie III / Applications

734

Cette loi est notée B(n, p). Sa moyenne vaut n p et sa variance n p (1-p). Dans le diagramme suivant, nous générons les lois B(10, 0.2) et B(10, 0.5) discrètes dont

nous calculons la moyenne et la variance. Puis nous recalculons ces derniers paramètres en utilisant les valeurs théoriques.

Dans les 2 cas, nous retrouvons des valeurs proches des valeurs théoriques.

IV. Théorème central limite ou théorème de limite centrale

Somme de variables uniformes dans l’intervalle [0 100]

Dans le diagramme suivant, nous générons 12800 valeurs distribuées selon une loi uniforme, dans l’intervalle [0 100].

Nous traçons l’histogramme et calculons leur moyenne et leur variance. Dans le nœud MathScript, nous faisons la somme de 10000 de ces valeurs et calculons la

moyenne et la variance de la variable somme obtenue.

Chapitre 19 / Statistiques et probabilités

735

Nous obtenons toujours une variance unité et une valeur moyenne nulle pour la variable

somme. Dans cet exemple, nous observons aussi une tendance gaussienne pour la dispersion.

V. Covariance et matrice de covariances

V.1. Covariance de 2 variables aléatoires

V.1.1. Calcul de la covariance à partir du coefficient de corrélation linéaire

La covariance de 2 variables aléatoires X et Y, ou variance conjointe de X et Y,

notée 2XY , est définie par :

)()()()()(2),( YEXEXYEyYxXEXYYXCov

C’est la moyenne du produit des 2 variables centrées. La variance de la variable X est un

cas particulier de la covariance :

222 )()()(22 XEXExXEXXX

Partie III / Applications

736

Etant donné les tableaux X et Y correspondant à l’âge et à la taille, nous pouvons estimer cette covariance à partir du coefficient de corrélation obtenu précédemment:

1

)()(),(

1

0

n

yyxxYXCov

n

kkk

YX

Dans le diagramme suivant, on obtient le coefficient de corrélation des tableaux X et Y, en

utilisant le VI Correlation Coefficient.vi. Nous le recalculons en utilisant l’expression de la corrélation.

Nous affichons le coefficient de corrélation linéaire et la covariance entre les variables X et

Y. Ce coefficient, proche de 1, montre que X et Y sont liées linéairement.

V.1.2. Estimation de la corrélation

L’estimateur de la covariance de 2 variables aléatoires X et Y est donné par l’expression suivante :

n

y

n

x

n

yxn

kk

n

kk

n

kkk

XY111ˆ

Le paramètre n correspond à la taille de l’échantillon des variables X et Y. Dans le diagramme suivant, nous considérons les 2 tableaux étudiés précédemment, l’âge et

la taille, que nous avons obtenus par indexation d’une matrice. Nous utilisons l’opérateur somme des éléments d’un tableau.

Chapitre 19 / Statistiques et probabilités

737

Dans le panel, nous affichons la relation Y(X) dans un graphe XY et la valeur estimée de la

covariance. Nous trouvons une covariance de 1.99815, proche de 2.2492 que nous avions obtenue

précédemment.

V.2. Matrice de covariances

Dans le cas d'un vecteur dont les composantes sont des variables aléatoires indépendantes, la matrice variances-covariances contient les variances de ces variables aléatoires et des covariances de ces variables prises 2 à 2.

Cette matrice carrée possède la forme suivante, en considérant n variables aléatoires :

Partie III / Applications

738

21

222

1212

1

...),(.............)1,(

),(..),(

Xnn

X

nX

XXCov

XXCovXXCovXXCov

Le calcul de cette matrice s’obtient par le VI Covariance Matrix.vi. Ce VI sort aussi le vecteur moyen de l’entrée ou moyenne du ou des vecteurs d’entrée.

Nous considérons la même matrice formée de l’âge et de la taille, que nous appliquons à

l’entrée de ce VI. La sortie du VI est une matrice.

V.2.1. Application pour la taille et l’âge

Dans le diagramme suivant, nous disposons d’une matrice dont ses 2 colonnes sont l’âge et la taille.

Nous obtenons une matrice carrée (2x2), symétrique. Nous retrouvons la covariance de 2.24792 que nous avions obtenue précédemment. La variance de la variable X (âge) est très élevée, 57.25 par rapport à celle de la variable Y

(taille), qui est de 0.0917.

Chapitre 19 / Statistiques et probabilités

739

Le vecteur moyen est formé de la moyenne de l’âge et de la taille, il représente la tendance centrale pendant que la matrice de variances représente la dispersion, de la même façon que la variance pour une variable aléatoire.

V.2.2. Application pour les dimensions d’une pièce usinée

On considère le cas d’une pièce parallélépipédique de hauteur h, largeur l et de longueur L. Nous disposons des mesures suivantes sur 5 pièces, en centimètres.

Hauteur h Longueur L Largeur l

9.9795 5.1343 2.4139

9.9876 4.7585 2.2908

10.1490 5.1434 1.8786

10.1409 5.3260 2.1175

10.1417 5.0978 1.6851

Dans ce diagramme, nous disposons de ces mesures sous la forme d’une matrice.

Nous calculons le vecteur moyen (moyenne des colonnes de la matrice) et la matrice de variances de ces mesures.

Partie III / Applications

740

La variance de la hauteur, 0.0078, est très faible par rapport à celle de la longueur, 0.0426 et de la largeur 0.0576.

Ces 2 dernières sont du même ordre de grandeur. Les covariances sont très faibles, pour les mesures prises 2 à 2.

V.2.3. Matrice de covariances des bruits blancs

Les bruits blancs ne sont pas corrélés, ni à eux-mêmes ni à d’autres signaux. Dans le diagramme suivant, nous générons 2 bruits gaussiens d’écart-type 0.05, rajoutés

respectivement à des valeurs constantes 10 et 5. Un bruit blanc uniforme d’écart-type 1 est ajouté à la valeur constante 1.

Les 3 signaux sont assemblés par la fonction Construire un tableau. Nous obtenons un tableau 2D que nous transposons par la fonction Transposer un tableau 2D.

Nous calculons la matrice de covariances en utilisant le VI Covariance Matrix.vi. En indexant ce tableau, nous pouvons récupérer la 1ère colonne par l’indexation et nous traçons son histogramme.

Nous calculons les valeurs, minimale et maximale, afin de les spécifier dans la boite de dialogue du VI Créer un histogramme.

Chapitre 19 / Statistiques et probabilités

741

Nous calculons le coefficient de Kurtosis ainsi que le Skewness (dissymétrie). Dans le panel, nous affichons la matrice de covariance, carrée (3x3), les valeurs, minimale

et maximale ainsi que les 5 premières valeurs de la matrice de mesures. Nous obtenons un Skewness (dissymétrie) proche de 0 et un coefficient de Kurtosis proche

de 3. Ces coefficients démontrent que la distribution est proche d’une gaussienne comme le montre l’histogramme. Nous retrouvons les variances 0.0025 du bruit de la 1ère colonne dans les éléments (1,1) et (2,2) de la matrice de variances. Il en est de même de la variance

2887.032

1 du bruit uniforme dans l’élément (3,3).

V.2.4. Matrice de covariances d’un bruit blanc et d’un signal sinusoïdal

Nous utilisons le même bruit gaussien d’écart-type 0.05 que nous rassemblons à un signal sinusoïdal d’amplitude unité. Nous récupérons le signal sinusoïdal par indexation du tableau en spécifiant l’index 1 pour la fonction Indexer un tableau. Nous traçons l’histogramme de ce signal sinusoïdal et calculons son coefficient de Kurtosis ainsi que son Skewness.

Partie III / Applications

742

Dans le panel, nous affichons la matrice de covariances. Nous retrouvons bien la variance 0.0025 du bruit gaussien ainsi que la valeur 0.5 du signal

sinusoïdal. La covariance entre les 2 signaux de 0.0039 montre que le bruit gaussien n’est pas corrélé

avec le signal déterministe sinusoïdal. Le Skewness (dissymétrie) est nulle et le coefficient de Kurtosis est proche de 1.5, ce qui

correspond à celui d’un signal sinusoïdal.

V.2.5. Matrice de covariances d’un bruit blanc et d’un bruit rose

Un bruit rose est un bruit blanc filtré. La matrice de mesures est constituée d’un bruit blanc gaussien et un bruit rose obtenu par filtrage de ce même bruit.

Nous utilisons une boite de calcul pour programmer l’équation de récurrence qu’on déduit

de la fonction de transfert du filtre utilisé. La fonction de ce transfert du filtre est la suivante :

1

1

1)(

zazb

azbzH

Cette fonction de transfert numérique relie l’échantillon y(k) de la sortie du filtre IIR à celui

du signal d’entrée x(k). Nous en déduisons l’équation de récurrence suivante :

)1()1()( kxbkyaky Nous utilisons le nœud de rétroaction pour retarder les signaux x et y. La boucle For permet d’obtenir un tableau de même nombre d’éléments que le bruit

gaussien d’entrée.

Chapitre 19 / Statistiques et probabilités

743

Après indexation de la matrice de mesures, nous affichons le signal de sortie du filtre ainsi que son histogramme.

Nous calculons, de même, le Skewness (dissymétrie) et le coefficient de Kurtosis du bruit en sortie du filtre.

Avec une covariance de -0.00038, la matrice de variances montre que le bruit blanc d’entrée n’est pas corrélé avec le bruit rose de sortie du filtre. Nous avons toujours la variance du bruit gaussien de 0.0025.

Dans le vecteur moyen, nous vérifions la valeur 10 de la moyenne du bruit gaussien du fait de son offset de 10.

La valeur 0.01353 montre que le signal de sortie est centré comme celui à l’entrée du filtre. En effet, les moyennes, y du bruit de sortie du filtre et x du bruit de l’entrée, sont liées par

le gain statique du filtre : xa

by1

Comme le bruit en entrée est centré, le bruit de sortie l’est aussi. La variance en sortie est donnée par l’expression suivante, en fonction de la variance du

bruit en entrée. Comme le signal de sortie est centré, nous avons :

22222222

2222222

)1(1()1(2)1(

)1()1()1(2)1())1()1(()(

xy

y

bakxEbkykxEbayEa

kxbkxkybakyaEkxbkyaEkyE

1()1( kykxE = 0 car les signaux d’entrée et de sortie du filtre ne sont pas corrélés.

Nous avons alors : 222

22

64.011

1 xxy ab 0.0694

La valeur 0.005 obtenue est proche de cette valeur théorique. L’histogramme du bruit en sortie est gaussien du fait du théorème de centrale limite. En effet, ce filtre revient à faire une sommation des échantillons successifs du bruit en entrée. Si on exprime l’échantillon y(k) en fonction des échantillons à l’instant (k-3), nous pouvons retrouver cette sommation :

)1()2()3()3()( 23 kxbkxbakxbakyaky

Partie III / Applications

744

Au fur et à mesure, on remarque la formation d’une gaussienne centrée. Le Skewness de 0.0544 montre que la gaussienne est centrée et la valeur 2.5712 du coefficient du Kurtosis est proche de 3, ce qui valide le caractère gaussien de la distribution.

Partie III. Chapitre 20 – Régulation, contrôle de procédés

I. Régulateur proportionnel et Intégral PI avec les VIs express II. Commandes PI et PID II.1. Commande Proportionnelle, Intégrale et Dérivée, PID II.2. Commande proportionnelle et intégrale, PI numérique III. Le PID de « Conception de contrôle et simulation » III.1. Utilisation du VI PID de la palette Contrôle et simulation III.2. PID analogique avec filtrage de la dérivée IV. Commande linéaire quadratique avec intégration LQI V. Commande RST V.1. Utilisation des VIs du langage G V.2. Utilisation du nœud MathScript et une boite de calcul VI. Utilisation de l’outil « Conception de contrôle et simulation » VI.1. Régulation PID série analogique VI.2. Régulation numérique par compensation de pôles VII. Régulation par le choix de la FTBF VII.1. Utilisation d’un nœud MathScript VII.2. Utilisation d’une boucle For et une boite de calcul VIII. Commande asymptotique et optimale dans l'espace d'état VIII.1. Commande asymptotique par placement de pôles VIII.2. Commande optimale dans l'espace d'état VIII.2.1. Régulation autour d'une consigne nulle VIII.2.2. Régulation autour d'une consigne constante non nulle VIII.2.3. Régulation autour d'une consigne variant dans le temps

745DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _20,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie III / Applications 746

I. Régulateur proportionnel et Intégral PI avec les VIs express

L’action intégrale du régulateur PI est réalisée par le VI Somme de la palette VI express comme le montre le diagramme de ce régulateur défini par le sous-VI « PI xpress.vi ». Ce sous-VI effectue la correction PID suivante :

)1()()()()(0

kkKdiKkKkuk

iip

Pour réaliser un régulateur PI, il suffit d’affecter la valeur 0 au paramètre Kd.

)(k est l’entrée du régulateur correspondant à la différence entre la consigne et le signal de sortie du processus à réguler.

La somme est réalisée par le VI de type Express Somme de la sous-palette Express

Arithmétique et comparaison Opérations dans le domaine temporel.

Le processus du 1er ordre à réguler est défini par le sous-VI « process_1er_Ordre.vi » sous la forme de l’équation de récurrence,

)1()1()( 11 kubkyaky ,

Cette équation relie la commande u(k) à la sortie y(k). Nous utilisons une boite de calcul dont les entrées y1 et u1 seront données par les cellules

(k-1) de 2 registres à décalage, un registre qui fournit la commande u(k), un autre pour la sortie y(k) du processus.

Chapitre 20 / Régulation, contrôle de procédés

747

Pour utiliser ces 2 registres à décalage, nous avons besoin d’une boucle For ou While.

Dans le diagramme, la consigne est définie par les constantes 2 et 5 que l’on choisit

alternativement par la commande « sélecteur » en utilisant la fonction Sélectionner. Entre les instants 100 et 101, nous appliquons une perturbation de hauteur 2 qu’on ajoute à

la sortie. Les paramètres 1a et 1b sont obtenus en désassemblant le cluster process défini dans le panel.

Les valeurs des paramètres pK et iK ont conduit à 3 dépassements au tour de la consigne. La perturbation est aussi rejetée après 3 dépassements.

Le panel suivant montre le signal de sortie et celui de la consigne ainsi que ceux de l’erreur

et de la commande. L’erreur s’annule en régime permanent grâce à la présence de l’intégration, réalisée par le

VI Express Somme, dans le régulateur.

Partie III / Applications 748

II. Commandes PI et PID

II.1. Commande Proportionnelle, Intégrale et Dérivée, PID

Le régulateur PID est presque le seul utilisé dans le domaine industriel. Son expression est donnée, dans sa partie analogique, par la formule générale suivante :

t

dip dttdeKdtteKteKtu

0

)()()()(

Ce régulateur possède 3 actions qui remplissent, chacune une fonction particulière : - La partie proportionnelle fournit une action proportionnelle à l’erreur entre la consigne

et la sortie du processus, - La partie intégrale permet d’annuler parfaitement cette erreur, en régime statique, - L’action dérivée permet d'augmenter la vitesse de la réponse et de prévoir les futures

variations du processus. Dans le diagramme suivant, nous programmons ce régulateur dans un nœud MathScript.

L’intégrale, simulée par une somme discrète est donnée par : )1()( kSekeSek La partie intégrale est ainsi réalisée uniquement par la somme de l’erreur e(k) à l’instant

courant k et la somme de l’instant précédent, Se(k-1). La dérivée est représentée par la différence de ces 2 erreurs : ).1()(_ kekeekd Les paramètres, proportionnel Kp, intégral Ki et dérivé Kd sont des entrées du nœud MathScript dans lequel les 3 actions (proportionnelle, intégrale et dérivée) sont programmées. Ces paramètres sont spécifiés dans le cluster PID Parameters du panel qu’on désassemble dans ce diagramme. La commande u(k), issue de ce régulateur, est reliée à l’erreur e(k) par l’expression suivante :

)1()()()()(1

kekeKdjeKikeKpkuk

j

Les paramètres a1 et b1 du processus sont, eux aussi, obtenus par désassemblage du

cluster Process parameters défini dans le panel. Dans ce diagramme, nous utilisons 4 registres à décalage pour récupérer à l’instant k, les

valeurs précédentes de la commande u, la sortie y, l’erreur e et la somme Se. Ces registres

Chapitre 20 / Régulation, contrôle de procédés

749

sont tous initialisés à 0. Le temps d’attente, qui simule la cadence d’échantillonnage, est égal à 0.05s.

Le panel est composé de 3 onglets qui servent à spécifier les valeurs des paramètres du régulateur, afficher la courbe des signaux de sortie de consigne et de sortie. Le 3ème onglet sert pour l’affichage des signaux de l’erreur et de la commande. La figure suivante montre la poursuite d’une consigne sous forme de créneaux. Cette poursuite se fait avec un seul dépassement.

Partie III / Applications 750

La figure suivante montre l’allure des signaux de commande et d’erreur. En régime permanent et grâce à l’action intégrale dans le régulateur, l’erreur est parfaitement nulle.

II.2. Commande proportionnelle et intégrale, PI numérique

L’expression qui donne cette commande, déduite de celle du PID, ne comporte pas d’action dérivée:

t

dtteKiteKptu0

)()()(

Sa transformée de Laplace permet d’écrire : )()()( pEp

KiKppU

U(p) et E(p) sont respectivement la transformée de Laplace de la commande et de l’erreur. Pour obtenir l’équivalent discret de ce régulateur, nous pouvons, par exemple remplacer l’opérateur analogique p de dérivation par son équivalent ( du domaine discret. Nous obtenons ainsi :

et sont les échantillons temporels, à l’instant discret k, du signal de commande et d’erreur. Le signal de commande u(k) et l’erreur e(k) sont liés par l’équation de récurrence suivante :

)1()()()1()( keKkeKKkuku pip

Chapitre 20 / Régulation, contrôle de procédés

751

Nous utilisons une structure séquence empilée avec 2 séquences. Dans la séquence 0, nous calculons le signal de sortie y(k) en fonction de sa valeur précédente y(k-1) et celle du signal de commande, u(k-1).

Le système à commander est un 1er ordre discret défini par le sous-VI « 1ER ORDRE.vi ». La sortie y(k) est donnée par l’équation de récurrence suivante :

)1()1()( 11 kubkyaky

Les paramètres a1 et b1 du processus du 1er ordre sont obtenus en désassemblant le cluster « Process parameters ».

Le diagramme du sous-VI qui définit le processus est le suivant :

La séquence 1 permet d’obtenir la commande u(k) à appliquer au processus à l’instant courant k. L’entrée ek est l’erreur et Sek la somme des erreurs.

Partie III / Applications 752

La commande u(k) est calculée dans un nœud MathScript.

Le diagramme représente une boucle While dans laquelle est insérée la structure séquence empilée. Cette structure possède 2 étapes, l’étape 1 ci-dessus dans laquelle on calcule la valeur de la commande u(k) et l’étape 0 qui permet de mesurer la sortie y(k) du processus représenté par le sous-VI 1er ordre.vi. Le nœud MathScript inséré dans l’étape 1, reçoit comme entrées les paramètres Kp, Ki, Kd du régulateur, spécifiés dans le panel ainsi que les valeurs de l’erreur ek et de la variable somme Se(k). Les paramètres Kp, Ki, Kd du régulateur ainsi que ceux du processus, a1 et b1 sont spécifiés dans les clusters PID Parameters et Process Parameters.

Chapitre 20 / Régulation, contrôle de procédés

753

Le panel suivant représente les valeurs des paramètres du régulateur, un bouton rotatif qui permet de modifier le signal de consigne et un bouton M/A qui autorise ou non l’exécution du VI. Le signal de sortie coïncide parfaitement avec la consigne en régime permanent après quelques oscillations.

Les signaux de l’erreur et de la commande sont les suivants :

Partie III / Applications 754

III. Le PID de « Conception de contrôle et simulation »

Le module « Conception de contrôle et simulation » comporte une palette pour la conception du PID.

III.1. Utilisation du VI PID de la palette Contrôle et simulation

Le VI PID est représenté comme suit :

Le tableau suivant résume les entrées et sorties de ce VI. Entrées

Output range : cluster formé des limites, basse et haute de la sortie du processus

Setpoint : signal de consigne

Process variable : signal de sortie du processus

PID gains : gains, proportionnel Kp, intégral Ti et dérivée Td

dt : intervalle de temps en secondes, durant lequel ce VI sera appelé.

Sorties

Output : sortie du PID correspondant à la commande appliquée au processus

dt : intervalle de temps en sortie.

Chapitre 20 / Régulation, contrôle de procédés

755

Dans le diagramme suivant, nous utilisons le VI PID.vi de la palette Contrôle et simulation. Nous spécifions les paramètres du PID dans le cluster Paramètres du PID, de même que ceux du processus spécifiés dans le cluster Process. Dans le panel, la consigne est fournie par le bouton rotatif consigne. L’entrée Process variable est reliée à la sortie du processus. Les limites, basse 0 et haute 12, du signal de sortie sont spécifiées dans un cluster constant. Nous n’avons pas câblé l’entrée dt, la boucle while est cadencée par la valeur temps d’attente de 0.05s. Nous avons tracé les signaux de consigne, la sortie du processus, la commande et le signal d’erreur dans des graphes déroulants.

La poursuite se fait sans dépassement, selon une dynamique du 1er ordre de gain statique unité.

III.2. PID analogique avec filtrage de la dérivée

Ce type de régulateur a pour expression : 1

11)(p

NT

pTpT

KpCd

d

ip

Partie III / Applications 756

Nous considérons un processus analogique de gain statique unité et de constante de temps s20 .

Dans le diagramme suivant, nous utilisons de nombreux VIs de la palette Contrôle et

simulation.

Le VI CD Construct Transfer Function Model.vi permet de construire un

modèle de fonction de transfert de type SISO (Single Input Single Output) ou MIMO (Multiple Input Multiple Output) à partir des tableaux 1D représentant le numérateur et le dénominateur.

Cette fonction de transfert est représentée sous forme de cluster dans Transfer

Function Model Process. Son équation est affichée en sortie du VI CD Draw Transfer Function

Equation.vi. Le régulateur PID est spécifié par le VI CD Construct PID Model.vi à partir des 3

entrées représentant les paramètres Kp, Ti, Td et de la constante de temps du filtre passe-bas qui filtre la dérivée.

Comme pour le modèle de fonction de transfert du processus, celle du régulateur est aussi

dans un cluster. La mise en série du régulateur et du processus se fait par le VI CD series.vi qui met

en série les 2 fonctions de transfert présentes à ses 2 entrées. Le bouclage unitaire se fait grâce au VI CD Feedback. Avec CD Step Response.vi nous affichons la réponse indicielle du système bouclé.

Chapitre 20 / Régulation, contrôle de procédés

757

IV. Commande linéaire quadratique avec intégration LQI

La commande LQI, telle qu'elle est présentée ci-après, est basée sur la minimisation d'un critère quadratique. Elle est prédictive à un pas et possède une intégration afin de rejeter l'erreur en régime permanent. Le critère J à minimiser permet d'assurer un compromis entre le carré de la variation de la commande de l'instant d'échantillonnage k et le carré de l'erreur de poursuite de l'instant futur (k+1).

22 )()1( kuRkeJ

La minimisation de ce critère consiste à calculer la variation de commande optimale qui

satisfait à : 0)( u

J . La présence de l'erreur future )1(ke et de l'incrément de commande

)(ku permet d'aboutir à une commande prédictive à un pas d'échantillonnage et d'inclure une intégration. Considérons un système du premier ordre de modèle discret :

11

11

1

1

1)()(

zazb

zAzB

qui relie les entrées-sorties du processus par l'équation de récurrence suivante :

)1()1()( 11 kubkyaky

Pour faire apparaître l'incrément de la commande, on dérive les deux termes de cette expression pour obtenir le nouveau modèle prédicteur.

)()1()()1()1(ˆ 111 kubkyakyaky

En désignant par )1(kr la consigne future, l'erreur )1(ke est estimée par :

)1(ˆ)1()1( kykrke

Partie III / Applications 758

La minimisation du critère permet d'aboutir à l'incrément de commande optimal suivant :

)1()()1()1()( 1121

21 kyakyakr

Rbbku

La commande à appliquer réellement au processus, à l'instant discret k, se calcule par la somme de la commande appliquée à l'instant (k-1) et de l'incrément u(k).

)()1()( kukuku

A partir du modèle du processus et de la loi de commande, on obtient la fonction de transfert en boucle fermée suivante :

21 1)11(11

)()(

zazakrky

avec Rb R1

2.

Le gain statique est égal à l'unité grâce à la présence de l'intégration, la dynamique est du second ordre de coefficient d'amortissement et de pulsation non amortie 0. Ces 2 paramètres vérifient les relations suivantes :

( ) cos ( )1 1 2 0 1 2

1

0

2 0

a e T

a e

T

T

On s'impose une valeur du coefficient d’amortissement22 , et on déduit celle de la

pulsation normalisée 0T par le rapport des 2 relations précédentes.

12 0 1 21

10a

a e TT cos( )

C'est une relation non linéaire en 0T que l'on peut résoudre facilement dans la fenêtre de commande de la fenêtre MathScript. La deuxième relation permet le calcul du coefficient de réglage R.

Rb

a e T12

12 0 1

Calcul de R

Dans le diagramme suivant, nous programmons la relation précédente donnant le coefficient R en fonction des paramètres , Tw0 du modèle de 2nd ordre que l’on souhaite obtenir en boucle fermée.

Chapitre 20 / Régulation, contrôle de procédés

759

Dans le VI de type Express Formule, nous calculons le coefficient R.

Le calcul du paramètre est calculé dans une boite de calcul.

Dans le panel, la consigne est spécifiée à l’aide d’un bouton rotatif.

Partie III / Applications 760

Commande LQI

Le diagramme suivant, nous mettons en œuvre la commande linéaire quadratique avec intégration LQI.

Nous avons utilisé la valeur du coefficient R obtenu précédemment. L’algorithme de cette régulation est inséré dans une boite de calcul. Le processus, du 1er ordre, est spécifié dans le VI de type Express Formule dans la sous-

palette Express Arithmétique et comparaison.

Nous avons utilisé 2 registres à décalage pour stocker les valeurs précédentes de la commande u(k-1) et de la sortie y(k-1). Le signal de commande est saturé entre les valeurs low et high avec des tests qui commandent des structures condition.

Chapitre 20 / Régulation, contrôle de procédés

761

Dans le panel suivant, nous traçons les signaux de consigne et de sortie ainsi que celui de l’erreur et de la commande.

V. Commande RST

L'intérêt de ce type de commande -contrairement à beaucoup d'autres correcteurs numériques tel le classique PID- est de spécifier la loi de réjection des perturbations indépendamment de celle de la poursuite du signal de consigne. Pour cette raison, ce régulateur est dit "poursuite et régulation à objectifs indépendants". Le calcul de la loi de commande est basé sur un critère polynomial qui permet de spécifier la dynamique de réjection de l'erreur "signal de référence - sortie" (perturbation).

0)1(ˆ)1()( 1 kykrzP

Cette dynamique se fait par le choix du polynôme de régulation P z( )1 .

Si l'on choisit un polynôme de régulation du premier ordre, ,11115.01)1( zpzzP

la perturbation sera divisée par deux à chaque instant d'échantillonnage. Comme exemple d'application de cette commande, considérons un modèle de processus analogique du premier ordre avec retard pur qui devient après discrétisation:

11

11

1

11

1)()()(

zazb

zAzBzH

La sortie y(k) est donnée par l’équation de récurrence suivante :

)1()1()( 11 kubkyaky Cette équation donne le prédicteur suivant :

)()()1(ˆ 11 kubkyaky

Partie III / Applications 762

Pour faire intervenir une intégration dans la loi de commande, nous dérivons l’équation de ce prédicteur :

)()1()()1()1(ˆ 111 kubkyakyaky Avec le polynôme de régulation du premier ordre, la commande u(k) à appliquer au processus à l'instant d'échantillonnage k est :

)1()()1()()1(1)( 11111

kyakypakrpkrb

ku

Lorsqu'il s'agit de consignes telles l'échelon ou le signal carré, il est préférable de les filtrer pour donner le signal de référence r t( ) . On choisit généralement un filtre du premier ou du second ordre de gain statique unité.

Le filtre de référence du second ordre est de la forme : 22

11

211

11)(

zzzH r

Si l'on choisit un filtre du premier ordre de pôle 1, il suffit de spécifier 2 0. Les coefficients 1 et 2 déterminent la pulsation propre non amortie 0 et le coefficient d'amortissement par les relations suivantes :

)2(exp)1cos()(exp2

02

2001

TwTwTw

T est la période d'échantillonnage.

V.1. Utilisation des VIs du langage G

Dans cet exemple, nous allons mettre au point la commande RST sans intégration. Nous utilisons toujours le même critère de base. Avec le prédicteur donné par le modèle du processus, nous obtenons la loi de commande suivante :

)()()()1(1)( 1111

kypakrpkrb

ku

Dans le diagramme suivant, la boite de calcul permet d’obtenir le signal de commande.

Chapitre 20 / Régulation, contrôle de procédés

763

Le VI Express Formule permet de calculer le signal de sortie du processus.

Nous utilisons une boucle For dans laquelle on crée 2 registres à décalage pour la commande u et la sortie y du processus.

La commande est limitée entre les valeurs -10 et +10 en utilisant le sous-VI VI_Limit.vi.

Ce VI utilise 2 structures condition imbriquées.

Cette limitation peut être aussi réalisée dans la boite de calcul suivante.

Partie III / Applications 764

Nous modifions la valeur du paramètre p1 dans la structure condition. Sa valeur change de 0.9 à -0.2 à l’instant 250.

L’erreur et la commande sont tracées dans le même graphe déroulant comme la sortie et la consigne.

A partir de l’instant discret k=250T, le paramètre de régulation p1 passe de 0.9 à -0.2. La dynamique de régulation, lente et apériodique devient rapide et oscillatoire.

Chapitre 20 / Régulation, contrôle de procédés

765

V.2. Utilisation du nœud MathScript et une boite de calcul

Le critère de régulation est le suivant : 0)1(ˆ)1( tezP .

Avec )1(ˆ te , la valeur future de l’erreur consigne-sortie, Considérons un processus donné par le modèle du 1er ordre suivant :

11

121

11

1)()(

zazbbzzH

La sortie prédite à un pas est donnée par :

)1()()()1(ˆ 211 kubkubkyaky

0)1(ˆ)1()1()1(ˆ)1( 11 tytrzptezP

La variation de commande )(ku est alors donnée par l’expression suivante :

)1()1()()1()()1(1)( 211111

kubkyakypakrpkrb

ku

Nous ajoutons cette variation à la commande précédente pour obtenir la commande à appliquer au processus à l’instant courant k. La consigne est une suite d’un signal carré et d’une sinusoïde obtenu par la fonction Construire un tableau pour laquelle nous choisissons l’option Concaténer les entrées dans son menu local. Nous ajoutons 1 à ce signal pour obtenir des variations entre 0 et 2. Dans la boite de calcul, nous déterminons les paramètres 1 et 2 afin d’avoir un coefficient

d’amortissement optimal22 .

Les entrées num et den du nœud MathScript sont le numérateur et le dénominateur de la fonction de transfert discrète du processus :

1

111

8.01)5.01()(

zzzzH

Preg est le polynôme du 1er ordre qui définit la dynamique de la régulation. Le signal de consigne est formé d’une suite d’un signal carré et d’une sinusoïde. Les paramètres 1 et 2 du modèle de référence sont calculés dans une boite de calcul en fonction du coefficient d’amortissement et de la pulsation propre d’un second ordre.

Partie III / Applications 766

Nous avons introduit des perturbations aux instants 250 et 1200. Celle à l’instant k=250 a été rejetée avec des oscillations à cause de la valeur négative du paramètre p1. Lorsque ce paramètre est positif, la perturbation est rejetée sans oscillations.

VI. Utilisation de l’outil « Conception de contrôle et simulation »

Avec Conception de contrôle et simulation, nous pouvons utiliser les fonctions de transfert pour modéliser le processus ainsi que le régulateur. Nous allons étudier un régulateur PID série en analogique et une régulation numérique par compensation de pôles.

VI.1. Régulation PID série analogique

Les actions proportionnelle, intégrale et dérivée sont en série, comme le montre le schéma suivant :

Chapitre 20 / Régulation, contrôle de procédés

767

Le sous-système de simulation de cette forme de PID est le suivant. Nous avons utilisé les paramètres des sous-palettes Continuous Linear Systems (Derivative, Integrator), Signal Arithmetic (Gain, Summation, Multiplication).

La consigne carrée est générée par Pulse Signal (signal carré). Le processus à réguler est un système du 1er ordre analogique de constante de temps de 5s et de gain statique unité.

Le panel suivant représente les commandes Kp, Ti, Td, le nombre N d’échantillons, le pas de temps dt de la boucle de contrôle et simulation ainsi que les courbes de consigne, sortie, l’erreur et le signal de commande.

Partie III / Applications 768

VI.2. Régulation numérique par compensation de pôles

Considérons un processus discrétisé de fonction de transfert :

11

121

11

1)()(

zazbbzzH

Si on veut compenser le pôle a1 et avoir une erreur nulle en régime permanent, le régulateur

doit avoir l’expression suivante :

)1()(1

)()()( 11

21

111

zzbbzak

kekuzD

k est un paramètre de réglage. u(k) et e(k) sont les signaux de commande et d’erreur à l’instant courant k. Les pôles de ce régulateur sont les zéros du processus et ses zéros sont les pôles du

processus pour qu’il y ait compensation. Pour que le gain statique de la FTBF soit égal à 1, le régulateur doit comporter une

intégration. La fonction de transfert en boucle ouverte est:

1

111

1)()(

zzkzHzD

La fonction de transfert en boucle fermée se comporte comme un 1er ordre de pôle (1-k). Ce pôle est bien réglé par le paramètre k.

)1(1)()(1)()()( 1

1

11

111

kzzk

zHzDzHzDzF

Le gain statique (z=1) est bien égal à 1 quelle que soit la valeur du paramètre k.

Pour le régulateur et le processus, nous utilisons la fonction de transfert discrète Discrete Linear Systems de la sous-palette Conception de contrôle et simulation Simulation.

Le régulateur a pour fonction de transfert en z suivante :

5.05.18.0)( 2 zz

zkzD

Le paramètre k permet de modifier la dynamique de régulation. Dans ce diagramme, nous utilisons le bloc Access Model Hierarchy pour accéder au gain Gain du paramètre k. Ce bloc est relié par sa sortie error out à l’entrée error de la boucle de contrôle et simulation. En double cliquons sur ce bloc, nous obtenons la liste des paramètres des blocs de la boucle de contrôle et simulation. Nous choisissons la valeur gain du bloc Gain. Nous avons choisi Set dans le menu Get/Set pour spécifier et pas lire cette valeur.

Chapitre 20 / Régulation, contrôle de procédés

769

Le bloc Halt Simulation de la sous-palette Utilities permet d’arrêter l’exécution de la boucle de contrôle et simulation lorsqu’on appuie sur le bouton Halt ?.

Nous avons créé une perturbation en ajoutant la valeur 50 à la sortie à l’instant t=60 dans la condition vrai d’une structure condition. Le temps de simulation est obtenu par le bloc Simulation Time de la sous-palette Utilities. Avec Icon Style du menu local, ce style est choisi de type Express pour le régulateur et le processus. Les signaux de consigne et de sortie sont tracés simultanément dans un graphe waveform grâce au bloc SimTime Waveform de la sous-palette Graph Utilities après avoir réuni ces signaux en tableau par Build Array de la palette Tableau. Les signaux de commande et d’erreur sont tracés par cette même méthode.

Partie III / Applications 770

Dans le panel suivant, nous affichons les courbes de sortie, de consigne ainsi que ceux de l’erreur et de commande.

VII. Régulation par le choix de la FTBF

La FTBF est la fonction de transfert en boucle fermée par le régulateur. Si on appelle )( 1zD la fonction de transfert d’un régulateur discret et )( 1zH celle du

processus à réguler, le schéma du système en boucle fermée est donné par :

y(k) : échantillon n° k du signal de sortie du processus, r(k) : échantillon n° k du signal de consigne, e(k) : échantillon n° k de l’erreur consigne-sortie, e(k) = r(k)-y(k), u(k) : signal de commande ou sortie du régulateur. En notant )()()()()( 11 kykrzHzDky , nous obtenons la fonction de transfert en

boucle fermée suivante:

)()(1)()(

)()()( 11

111

zHzDzHzD

krkyzF

Si on spécifie, à l’avance, la fonction de transfert )( 1zF désirée, nous obtenons celle du

régulateur )( 1zD suivant :

)(1)()()( 11

11

zFzHzFzD

Chapitre 20 / Régulation, contrôle de procédés

771

Nous allons choisir la fonction de transfert en boucle fermée suivante, du 2nd ordre de gain statique unité :

22

11

211

1

1)1()(

zzzzF

En régime statique, en faisant z = 1, le gain est égal à 1.

Les paramètres 1 et 2 sont reliés à la pulsation propre 0w et au coefficient d’amortissement par les expressions suivantes :

)2exp()1cos()exp(2

02

2001

TwTwTw

Si on pose T

kw0 , nous obtenons :

)2exp()1cos()exp(2

2

21

kkk

Le régulateur a pour expression, d’après la relation précédente :

)1()1()(1)1()( 1

211

21

11

211

zzzbbzazD

Ce régulateur possède une action intégrale du fait qu’on a imposé un gain statique unité.Si on note l’incrément de commande )1()()( kukuku , la fonction de transfert qui la lie à l’erreur est la suivante :

)1()(1)1(

)()(

12

121

11

211

1

zzbbza

zzU

VII.1. Utilisation d’un nœud MathScript

La consigne est un signal carré VI Square Waveform.vi de la sous-palette Traitement du signal Génération de waveforms.

La pulsation propre normalisée w0T=0.1 et le coefficient d’amortissement optimal 22

sont des entrées du nœud MathScript. Les paramètres du processus sont obtenus par désassemblage du cluster a1-b1-b2 spécifié dans le panel. Les paramètres 1 et 2 du modèle de référence sont calculés dans le nœud MathScript. L’incrément de commande est calculé par l’équation de récurrence obtenue par l’expression ci-dessus.

Partie III / Applications 772

La commande u(k) à appliquer au processus est obtenue en ajoutant cet incrément à la commande de l’instant précédent.

Nous traçons les 4 signaux (consigne, commande, sortie et erreur) dans un même graphe. Nous retrouvons bien la dynamique d’un système du 2nd ordre ; la sortie suit la consigne avec un seul dépassement.

VII.2. Utilisation d’une boucle For et une boite de calcul

Si l’on ne dispose pas du module NI LabVIEW MathScript, nous pouvons utiliser une boucle For et une boite de calcul. Le coefficient d’amortissement et la pulsation propre, obtenus par désassemblage du cluster z_w0T défini dans le panel, sont des entrées d’une boite de calcul pour spécifier les paramètres 1 et 2 du modèle de référence du 2nd ordre.

Chapitre 20 / Régulation, contrôle de procédés

773

Ces paramètres sont transmis à une boucle For. A l’intérieur de la boucle For, nous utilisons une autre boite de calcul dans laquelle nous calculons la sortie du processus, l’erreur et l’incrément de commande. Nous avons créé 5 registres à décalage pour l’incrément de commande )(ku , la sortie y, la commande u, l’erreur et la consigne ou signal de référence ref. La sortie y(k), la commande u(k), l’erreur et le signal de consigne sont tracés dans le même graphe.

Le signal de consigne est un échelon et la poursuite se fait approximativement avec un seul

dépassement car la valeur du coefficient d’amortissement est légèrement inférieur à22 .

Partie III / Applications 774

VIII. Commande asymptotique et optimale dans l'espace d'état

VIII.1. Commande asymptotique par placement de pôles

On suppose un système linéaire ou linéarisé décrit par une équation d'état discrète résultant de la discrétisation du processus continu. Un régulateur a pour objet de maintenir la sortie à la valeur de la consigne en présence de perturbations. Considérons un double intégrateur de fonction de transfert analogique :

2

1)(p

pH

Le modèle d’état est obtenu par le schéma suivant : Les ma trices d’état sont les suivantes :

010

10

0010

DCBA

Pour obtenir le modèle d’état discret, nous utilisons le VI Convert Continuous to Discrete.vi pour échantillonner ce modèle analogique à la période T=0.1s.

Nous obtenons le modèle d’état discret suivant :

Chapitre 20 / Régulation, contrôle de procédés

775

Le signal de commande s'exprime par un retour de l'état, sous la forme : ).()( txFtu La loi de commande par retour d'état est schématisée comme suit :

-+

+

u(t)

A

B

F

x(t)z 1

Le comportement du système bouclé par la matrice F est donné par l'équation matricielle suivante :

)()()1( kxFBAkx

Cette équation permet de suivre l'évolution de l'état du système à partir de conditions initiales non nulles ou suite à l'application d'une perturbation. Si le processus est commandable, on peut placer les pôles du système en boucle fermée (par retour d'état) n'importe où dans le plan z. Ces pôles sont les solutions de l'équation caractéristique suivante : det(zI A BF) 0 Cette équation permet d’aboutir à la relation suivante :

0)005.01.0(1.0)1.01()005.01( 2121 fffzfz

Si l'on désire un retour à l'équilibre suivant une dynamique de second ordre de pôles réels z1 0 6. et z2 08. , les deux coefficients de retour d'état sont solutions du système :

16.004.0008.004.002.0009.0

21

21

ffff

Il suffit de résoudre le système matriciel suivant :

BFAff

16.004.0

04.0008.002.0009.0

2

1

La solution est : BAF 1 Nous obtenons : 6.5,8 21 ff .

Le modèle d’état discret du double intégrateur est le suivant :

)(1.0)()1()(005.0)(1.0)()1(

22

211

kukxkxkukxkxkx

Dans le diagramme suivant, nous programmons les 2 équations d’état précédentes en utilisant des fonctions et VIs des sous-palettes Signal Arithmetic et Discrete Linear Systems du toolkit Conception de contrôle et simulation. Nous affichons les deux états x1 et x2 en utilisant un waveform graph par Simulation Graph Utilities SimTime Waveform. Pour spécifier la valeur du gain par

Partie III / Applications 776

l’intermédiaire d’une constante, nous devons double cliquer sur son icône et choisir Terminal pour Parameter source. La condition initiale d’un état est spécifiée dans Initial condition après un double clic sur le bloc retard unitaire z-1.

Les courbes suivantes sont l’évolution des composantes d’état à partir de la condition initiale x1(0)=1 et x2(0)=0 et celle de la commande.

Chapitre 20 / Régulation, contrôle de procédés

777

Les mêmes résultats sont obtenus en utilisant le script RETETAT.m dans la fenêtre MathScript.

fichier RETETAT.m

VIII.2. Commande optimale dans l'espace d'état

La commande optimale dans l'espace d'état est basée sur la minimisation d'un critère quadratique, le plus général étant :

J x N T H x N x t T Q x t u t T R u tt

N12

12 0

1( ) ( ) ( ) ( ) ( ) ( )

N désigne l'instant auquel on atteint l'objectif qui est l'annulation de l'état dans le cas d'une régulation autour d'une consigne nulle. Q et H sont des matrices de pondération, symétriques. La matrice H ou terme de pondération terminal permet de pénaliser plus ou moins l'écart final par rapport à la cible cherchée. Q est une matrice de pondération de l'état intermédiaire. R est une matrice de pondération des signaux de commande. Dans le cas d'un système à p entrées dont le modèle d'état est d'ordre n, les matrices H, Q et R sont carrées, symétriques et d'ordres n et p respectivement. Le problème consiste à minimiser le critère J sous la contrainte suivante

x t Ax t Bu t( ) ( ) ( )1

Partie III / Applications 778

La minimisation du critère quadratique entre les étapes (N-1) et N sous la contrainte précédente permet d'obtenir.

u N R BT P N B BT P N A x N

F N x N

( ) ( ) ( ) ( )

( ) ( )

11

1

1 1

P N AT P N P N B R BT P N B BT P N A Q( ) ( ) ( ) ( ) ( )11

(Équation de RICCATI)

La détermination du retour d'état F(N-1) est basée sur le principe d’optimalité dont l'énoncé est dû à BELLMAN (1962). On applique cette commande au modèle du double intégrateur analogique discrétisé à T=0.1s.

Le modèle d’état analogique de ce système est le suivant :

)()(

01)(

)(10

)()(

0010

)()(

2

1

2

1

2

1

txtx

ty

tutxtx

txtx

VIII.2.1. Régulation autour d'une consigne nulle

Dans le 1er nœud MathScript, nous avons spécifié ces matrices et obtenu l’état analogique en utilisant la commande ss. Ce modèle d’état est discrétisé par le VI CD Convert Continuous to Discrete.vi avec la période d’échantillonnage T=0.1s. Le modèle d’état analogique est affiché dans Equation_ss_ana grâce au VI CD Draw State-Space Equation.vi. Dans le nœud MathScript N°2, nous avons programmé la commande du retour d’état optimal en résolvant l’équation de RICCATI. Les matrices de l’état discret sont obtenues par désassemblage du cluster qui représente le modèle d’état discret. Les matrices P et Q sont égales à la matrice H qui est spécifiée dans le panel. A l’instant t=N/2, nous avons créé une perturbation sur la vitesse (variable x2) en lui retranchant la valeur 1.

Chapitre 20 / Régulation, contrôle de procédés

779

Dans le nœud MathScript N° 3, nous avons utilisé les valeurs finales du retour d’état, F=[8 4] pour réaliser le retour d’état permanent. Nous avons appliqué la même perturbation de vitesse.

Dans le panel, nous avons affiché :

- la matrice H, - le coefficient de pondération R, - les modèles d’état analogique et discrétisé, - l’évolution des retours d’état donnés par l’équation de RICCATI, - l’évolution du vecteur d’état et de la commande en commande optimale, - l’évolution du vecteur d’état et de la commande en régime permanent.

Partie III / Applications 780

Le retour d'état est constant sauf au voisinage du point d'arrivée. Le régime permanent correspond à la solution permanente de l'équation de RICCATI. Le plus souvent on implante le régime permanent.

VIII.2.2. Régulation autour d'une consigne constante non nulle

Dans le programme suivant, on implante le retour d'état permanent pour une régulation autour d'une consigne constante de position. La deuxième composante du vecteur d'état est nulle. L'état correspondant est représenté par le vecteur :

x ref_5

0

La loi de commande est schématisée comme suit :

z 1+

+

u(t)

A

BF x(t)

-

+x ref_

Cette commande est implantée dans un nœud MathScript. Les matrices d’état, entrées du nœud, sont obtenues par désassemblage du cluster A-B-C défini dans le panel. Le tableau représentant la matrice est transformée en matrice, par le VI Array To Matrix.vi, pour ne pas avoir à la transposer dans le nœud MathScript. Le tableau x_ref représente la consigne de 5 avec une vitesse nulle.

Chapitre 20 / Régulation, contrôle de procédés

781

Pour atteindre une consigne de valeur 5, avec une pondération de la commande R = 0.1, ce signal atteint des valeurs qui ne sont généralement pas supportées par le matériel. Si la commande est limitée dans l'intervalle [-10 V, 10 V], nous avons deux possibilités, soit saturer cette commande avant de l'envoyer au processus, soit augmenter la pondération R, les deux ayant la même conséquence, celle de rallonger le temps de réponse. Avec R = 1, nous obtenons une poursuite beaucoup plus lente et un signal de commande d’amplitude beaucoup plus faible à cause d'une pondération beaucoup plus forte.

La dynamique est plus lente que précédemment à cause d'une plus forte pondération de la commande.

VIII.2.3. Régulation autour d'une consigne variant dans le temps

En général, la loi de commande permettant de réguler autour d'une consigne r(t) non nulle,

u t q r t F x t( ) ( ) ( )

comporte un retour d'état et une commande anticipative.

Partie III / Applications 782

r(t)z 1

-+

+

u(t)

A

B

F

x(t)y(t)C

+q

L'équation d'état devient :

x(t 1) Ax(t) B q r(t) F x(t) (A BF) x(t) B q r(t)

La sortie en régime permanent, s'exprime en fonction du signal de consigne par :

y C I A B F B q r( ) 1

L'égalité entre la sortie et la consigne en régime permanent est obtenue avec la valeur suivante de l'anticipation :

q C I A B F B( ) 1 1

Le signal de consigne est formé d’un signal carré qu’on fait suivre d’une sinusoïde grâce à la fonction Construire un tableau pour lequel on coche l’option Concaténer les entrées dans le menu local.

Nous avons utilisé la variable locale ref pour tracer la consigne en même temps que la sortie du processus dans le même graphe. Dans le nœud MathScript, nous avons utilisé les commandes inv d’inversion matricielle et eye pour spécifier une matrice identité.

Chapitre 20 / Régulation, contrôle de procédés

783

Dans le panel, nous affichons le signal de sortie qui suit parfaitement le signal de consigne variable dans le temps.

Pour R=10, les variations de commande sont très faibles lors des variations de consigne. La sortie est toujours égale, en régime permanent, sur les paliers de la consigne. Nous observons un retard constant en régime sinusoïdal.

Partie III. Chapitre 21 - Traitement du signal déterministe

I. Extraction d’une sinusoïde par filtrage II. Filtres FIR et IIR II.1. Filtres FIR II.1.1. Filtre FIR de type Express II.1.2. Réponse impulsionnelle - Filtre dérivateur II.1.3. Réponse indicielle – Filtre dérivateur II.1.4. FFT - filtre dérivateur II.1.5. FFT - filtre moyenneur II.1.6. Filtre FIR définies par ses spécifications fréquentielles II.1.7. FFT - filtre FIR quelconque II.1.8. Filtrage d’un signal par un filtre FIR II.2. Filtres IIR II.2.1. Pôles et zéros, diagramme de Bode et réponse indicielle II.2.2. Réponse impulsionnelle d’un filtre IIR II.2.3. Réponse indicielle II.2.4. Diagramme de Nyquist II.2.5. Filtres numériques de Bessel et Chebyshev II.2.6. Filtre de Yulewalker II.2.7. Filtre Elliptique et Butterworth – Filtrage de la somme de 3 sinusoïdes III. Filtres analogiques III.1. Circuit RLC III.2. Détermination du filtre de Butterworth par son expression théorique III.2.1. Utilisation d’un nœud MathScript III.2.2. Utilisation des VIs du langage G de LabVIEW IV. Filtrage d’un signal aléatoire IV.1. Filtre moyenneur – nœud de rétroaction IV.2. Filtre moyenneur dans l’espace d’état V. Filtrage adaptatif V.1. Algorithme LMS - Filtre FIR d’horizon 2 V.1.1. Utilisation des VIs du langage G V.1.2. Utilisation du nœud MathScript V.1.3. Utilisation des VIs de calcul matriciel V.2. Algorithme RLS - Filtre FIR d’horizon 3 V.3. Filtre antibruit VI. Identification de paramètres inconnus VII. Prédiction de signal

785DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _21,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie III / Applications

786

I. Extraction d’une sinusoïde par filtrage

Dans cette application, on s’intéresse à l’extraction d’une sinusoïde par filtrage d’une somme de 3 autres de différentes amplitudes et de fréquences.

Les VIs qui génèrent les 3 sinusoïdes se trouvent dans la sous-palette Traitement

du signal Génération de waveforms.

Le tableau suivant récapitule les amplitudes et les fréquences.

sinusoïde Amplitude fréquence x1 A1= 5 f1=10 Hz x2 A2=10 f2=5 Hz x3 A3=15 f3=1 Hz

Les amplitudes A2=10 et A3=15 sont spécifiées par des constantes dans le

diagramme. La sinusoïde x2(t) est générée par un VI définissant une waveform par la formule

sin wt. Ces formules sont insérées dans un menu déroulant de type Ring. Les éléments de ce menu déroulant sont des chaînes récupérées par un nœud de

propriété lié à ce menu et pour lequel on associe la propriété Chaines[]. La somme de ces 3 sinusoïdes est filtrée par un filtre passe-bande IIR de type

Butterworth d’ordre 12 et de bande passante [4.8 5.2 Hz]. Ce filtre est défini par le VI Filter de type Express qui se trouve dans la sous-

palette Traitement de signal Conditionnement de waveforms.

Chapitre 21 / Traitement du signal déterministe

787

En double cliquant sur ce bloc, nous obtenons la boite de dialogue suivante dans

laquelle on peut régler ses paramètres.

Nous avons choisi un filtre de type passe-bande dont la bande passante s’étend de 4.8 à 5.2 Hz. Le filtre se retrouve également dans la sous-palette Express (Analyse de signaux).

Partie III / Applications

788

Dans ce diagramme, nous générons les 3 waveforms par les VIs de la sous-palette Traitement du signal Génération de waveforms.

Nous utilisons le VI Extract Single Tone Information.vi de la sous-

palette Mesures sur waveform. Ce VI, auquel on applique le signal filtré, permet de détecter la fréquence, l’amplitude et

la phase du signal d’entrée. Nous affichons les 3 signaux, le signal Somme et le signal en sortie du filtre. Les 3 sinusoïdes sont échantillonnées à 100 Hz grâce au cluster sampling info. La sous-palette Mesures sur waveform contient des VIs permettant différentes

mesures telles la FFT, la valeur moyenne et efficace, etc. Dans ce diagramme nous avons utilisé le VI FFT Spectrum pour obtenir le spectre du

signal filtré. Dans le panel, nous affichons les 3 sinusoïdes en prenant soin d’utiliser la même échelle

d’amplitude. Dans le graphe Somme, nous affichons le signal de la somme des 3 sinusoïdes. Nous

utilisons la même échelle d’amplitude que pour les 3 sinusoïdes. Dans le graphe de la FFT, nous retrouvons bien un seul pic à la fréquence 5 Hz qui

correspond au signal x2 de la sinusoïde de 5 Hz. Dans le cluster infos sur l’éch., nous spécifions une fréquence

d’échantillonnage de 1 KHz et 1000 échantillons. Nous retrouvons bien la même amplitude de 1 et une fréquence de 5 Hz pour le signal en

sortie du filtre.

Chapitre 21 / Traitement du signal déterministe

789

II. Filtres FIR et IIR

Un filtre numérique a pour fonction de transfert générale :

)()()( 1

11

zAzBzH

Considérons le filtre suivant :

11

22

110

1

1

11

1)(

)()()(

zazbzbbz

zAzBzH

L’échantillon y(k) de la sortie est donné par l’équation de récurrence suivante :

)3()2()1()1()( 2101 kxbkxbkxbkyaky Cette expression peut être divisée en 2 parties : les parties AR (Autorégressive) et MA

(Moyenne Ajustée ou Moving Average). La partie AR correspond à : )1()( 11 kyaky . Cette expression définit le régime

transitoire du système d’où sa stabilité. La partie MA correspond à une combinaison linéaire des échantillons du signal d’entrée

et des coefficients du filtre. )3()2()1()( 2102 kxbkxbkxbky

Si on divise cette expression par la somme des coefficients, 210 bbb , nous obtenons

une moyenne pondérée des échantillons x(k) du signal d’entrée. L’expression ci-dessus de y(k) est appelée Moving Average (moyenne mobile) que

l’on peut considérer comme une moyenne ajustée (MA) du fait qu’elle n’est pas divisée par la somme des coefficients bi.

Partie III / Applications

790

II.1. Filtres FIR

Un filtre FIR (Finite Impulse Response ou Réponse Impulsionnelle Finie, RIF) est un filtre numérique non récursif.

L’échantillon y(k) de la sortie ne dépend que d’un nombre fini d’échantillons du signal

d’entrée x(k). Sa réponse impulsionnelle est toujours stable et de durée finie, dépendante du nombre

des coefficients du filtre. Cette réponse impulsionnelle est une combinaison linéaire décrite par la fonction de

transfert suivante : )()()( 111 zXzBzH

La réponse impulsionnelle est alors : N

iiN ikbNkbkbkbkh

010 )()(...)1()()(

avec

kiki

k01

)(

et N est le nombre de coefficients du filtre.

II.1.1. Filtre FIR de type Express

Dans ce diagramme, nous utilisons uniquement des VIs de type Express pour générer le signal carré et pour spécifier le filtre FIR.

Le VI Mesure de tons permet d’estimer la fréquence et l’amplitude du signal d’entrée.

Avec le VI Filtre, nous pouvons choisir soit un filtre FIR soit IIR dans sa fenêtre de

dialogue.

Chapitre 21 / Traitement du signal déterministe

791

Dans notre exemple, nous choisissons un filtre FIR, passe-bas de 23 coefficients et une fréquence de coupure de 8 Hz.

Le panel affiche les signaux d’entrée et de sortie du filtre, l’amplitude et la fréquence du

signal d’entrée, estimés par le VI Mesure de tons. Nous obtenons exactement la fréquence de 10 Hz et une amplitude de 6.36725.

Partie III / Applications

792

II.1.2. Réponse impulsionnelle - Filtre dérivateur

Le filtre numérique dérivateur du 1er ordre a pour fonction de transfert : 11 1)( zzH Dans le diagramme suivant, nous calculons la réponse impulsionnelle de ce filtre. La réponse impulsionnelle est la suite des valeurs suivantes :

1 -1 0 0 … 0 Dans la 1ère méthode, nous utilisons le VI Impulse Pattern.vi, de la palette

Traitement du signal Génération de signaux pour générer une impulsion.

Cette impulsion est appliquée au VI Filter.vi qui définit un filtre FIR auquel on applique un tableau de valeurs pour spécifier ses coefficients.

Le VI Convolution.vi permet de faire une convolution entre les échantillons

temporels du signal d’entrée (l’impulsion) et ceux de la réponse impulsionnelle correspondant au tableau des valeurs [1 -1].

Dans la boucle For, nous utilisons les 2 autres méthodes dans lesquelles, nous utilisons

l’équation de récurrence suivante : )1()()( kxkxky

Nous utilisons 2 registres à décalage pour le signal x d’entrée et y de sortie. Nous avons utilisé un script MATLAB, de la palette Mathématiques scripts

et formules, dans lequel la commande filter permet d’obtenir la sortie du filtre dont le numérateur est donné par l’entrée num et de dénominateur égal à 1. Nous obtenons les mêmes résultats que ceux obtenus précédemment.

Dans le 1er graphe, nous traçons simultanément le résultat de la convolution et du filtre

FIR. Les résultats sont identiques. Dans le graphe Rep_impulse, nous traçons l’impulsion d’entrée et le résultat obtenu

en utilisant le nœud de rétroaction.

Chapitre 21 / Traitement du signal déterministe

793

Dans Rep_impulse 2, nous traçons l’impulsion d’entrée et la sortie obtenue en utilisant les registres à décalage.

II.1.3. Réponse indicielle – Filtre dérivateur

Dans le diagramme suivant, nous appliquons un signal carré pour obtenir la réponse indicielle du filtre dérivateur pour lequel on utilise le nœud de rétroaction pour symboliser le retard z-1.

Comme on le voit sur la courbe de la face-avant, le signal de sortie du filtre est partout

nul sauf aux fronts, descendant et montant, du signal carré d’entrée. L’impulsion est positive au front montant et négative au front descendant ; ce qui fait la

fonction de dérivation de ce filtre.

Partie III / Applications

794

C’est aussi un filtre passe-haut car seuls les fronts passent à travers le filtre, le signal de sortie étant nul en régime permanent.

II.1.4. FFT - filtre dérivateur

Le VI suivant permet de déterminer la réponse en fréquences du filtre dérivateur précédent.

La réponse en fréquences d’un filtre est la transformée de Fourier de sa réponse impulsionnelle.

Pour ce filtre dérivateur, elle est donnée par l’expression suivante :

)2/sin(2)(1)( 2222 wTejeeeeeHjwTjwTjwTjwT

jwTjwt Son module est alors :

)2/sin(21)( wTeeH jwTjwt La réponse en fréquences d'un filtre numérique peut être calculée à partir de sa réponse impulsionnelle h k( ) ( k N N,... ...0, ), par la relation :

H j h k e j kk N

k N( ) ( )

Lorsqu'on tronque h k( ) par une fenêtre rectangulaire, le module du gabarit obtenu, présente des oscillations, connues sous le nom du phénomène de Gibbs. Dans notre cas du filtre dérivateur, la réponse impulsionnelle ne possède que 2 échantillons, on n’a pas besoin de la tronquer. Dans le diagramme suivant, nous utilisons un nœud MathScript dans lequel, nous calculons le module de la réponse en fréquences en utilisant cette formule générale et en calculant le module pour le cas particulier du filtre dérivateur. L’entrée h du nœud MathScript est le tableau contenant les échantillons h(k) du filtre.

Chapitre 21 / Traitement du signal déterministe

795

Dans le panel, nous traçons les 2 réponses en fréquences qui sont confondues. Nous avons calculé la réponse en fréquences en déterminant la FFT de la réponse

impulsionnelle par l’utilisation de l’expression générale de la réponse en fréquences.

D’après la courbe de la réponse en fréquences, nous déduisons que c’est un filtre passe-

haut. Nous avons utilisé des pulsations normalisées en considérant le domaine .

II.1.5. FFT - filtre moyenneur

Le filtre moyenneur est un filtre FIR de fonction de transfert :

)z(121H(z) 1

La réponse en fréquences, ou transformée de Fourier de la réponse impulsionnelle, a pour expression :

)2/cos(2

)( 2/2/2/

2/ wTeeeejwH jwTjwTjwT

jwT

Partie III / Applications

796

Son module se réduit à :

)2/cos()( wTeH jwt Nous utilisons le même VI précédent pour lequel il suffit juste de modifier les échantillons de la réponse impulsionnelle h du filtre de l’entrée du nœud MathScript et l’expression calculée du module de la réponse en fréquences à l’intérieur de ce noeud. Nous avons calculé la réponse en fréquences en utilisant le VI FFT Spectrum (Mag-Phase).vi qui renvoie l’amplitude et la phase. Nous n’utilisons pas de fenêtre pour tronquer la réponse impulsionnelle.

D’après les courbes suivantes du module de la réponse en fréquences, on déduit que le filtre moyenneur est de type passe-bas.

II.1.6. Filtre FIR définies par ses spécifications fréquentielles

Le filtre FIR peut être aussi défini par ses spécifications fréquentielles comme les fréquences de coupure. Dans le diagramme suivant, nous utilisons le VI Digital FIR Filter.vi de la sous-palette Traitement du signal Conditionnement de waveform.

Chapitre 21 / Traitement du signal déterministe

797

Dans le cluster FIR filter specifications, nous définissons les fréquences de coupure, basse et haute, dans les bandes, passante et atténuée. Dans le cluster optional FIR Filter specifications, nous définissons des spécifications optionnelles tels les gains maximaux dans les bandes, passante et atténuée. Dans cet exemple, le signal peut être atténué jusqu’à 3 dB, au maximum, dans la bande passante. Pour la bande coupée, le signal doit être atténué d’au moins 60 dB. Ainsi, 3dB correspond à l’atténuation maximale dans la bande passante et 60 dB à l’atténuation minimale dans la bande coupée. Dans le cluster filter information, nous récupérons des informations sur le filtre, à savoir l’ordre ou le nombre de ses coefficients ainsi que sa réponse en fréquences. Dans cet exemple, nous désassemblons ce cluster pour afficher l’ordre et tracer sa réponse en fréquences.

Le panel représente les clusters des spécifications, la courbe des signaux d’E/S du filtre ainsi que son gain en fonction de la fréquence.

Partie III / Applications

798

II.1.7. FFT - filtre FIR quelconque

On peut définir un filtre FIR par ses caractéristiques fréquentielles. Dans le diagramme suivant, nous cherchons un filtre passe-haut dont on spécifie les

fréquences de coupure, basse et haute, la fréquence d’échantillonnage, le type de fenêtre de troncature, le nombre des coefficients du filtre. Ceci se fait grâce au VI FIR Windowed Filter.vi.

Nous appliquons à ce filtre une impulsion et nous obtenons la transformée de Fourier de

la réponse à cette impulsion grâce au VI FFT.vi qui renvoie un complexe en coordonnées cartésiennes transformées en polaires dont le rayon r représente l’amplitude que nous transformons en dB.

Le VI FIR Windowed Coefficients.vi renvoie les coefficients du filtre.

Le panel suivant représente les caractéristiques du filtre, le tableau des coefficients et la

courbe du gain en dB.

Chapitre 21 / Traitement du signal déterministe

799

II.1.8. Filtrage d’un signal par un filtre FIR

Dans le diagramme suivant, nous spécifions les caractéristiques d’un filtre FIR auquel on applique un signal carré et on trace les réponses, temporelle et fréquentielle en dB.

Nous utilisons le VI Digital FIR Filter.vi pour spécifier ce filtre. Ce VI

renvoie le signal de sortie sous forme de waveform ainsi que l’amplitude et la phase de sa transformée de Fourier. L’amplitude est également un cluster ; pour cela nous utilisons 2 fonctions Désassembler par nom avant de tracer le module de cette transformée en échelle logarithmique. Cette waveform ainsi que celle du générateur du signal d’entrée sont assemblées en cluster qu’on transforme en tableau avant de tracer les signaux d’entrée et de sortie.

Les spécifications de ce filtre sont dans le cluster FIR Filter Specification.

Le panel est constitué de 3 onglets : Spécification du filtre ; dans cette

page, on choisit la topologie, le type, le nombre de coefficients du filtre ainsi que ses différentes fréquences caractéristiques, Réponse fréquentielle : Tracé de la réponse en fréquences et Réponse temporelle : Tracé du signal temporelle en sortie du filtre.

Le filtre FIR est défini par ses caractéristiques fréquentielles par ses fréquences de coupure via le cluster caractéristiques du filtre RIF.

La réponse en fréquences est celle d’un filtre passe-bas.

Partie III / Applications

800

II.2. Filtres IIR

Les filtres IIR (Infinite Impulse Response ou Réponse Impulsionnelle Infinie RII) possèdent la partie AR (AutoRégressive) dans leur fonction de transfert ; ils ont alors une réponse impulsionnelle infinie.

Un filtre RII est récursif, i.e. que sa sortie à l’instant k dépend de ses valeurs à quelques

instants précédents selon l’ordre du filtre. L’avantage d’un filtre IIR est qu’il nécessite moins de calculs qu’un filtre FIR de mêmes

performances, l’inconvénient est qu’il peut être instable. La fonction de transfert d’un filtre IIR est donnée par l’expression suivante :

NN

MM

zazazbzbbz

zH...1

)...()( 1

1

110

11

II.2.1. Pôles et zéros, diagramme de Bode et réponse indicielle

Considérons le filtre IIR numérique suivant du 2nd ordre de fonction de transfert :

zzzzzzH

2.016.1)( 23

2

Chapitre 21 / Traitement du signal déterministe

801

Dans le nœud MathScript, nous définissons le numérateur et le dénominateur d’un filtre RII du 2nd ordre.

A l’aide de la commande tf, nous créons cette fonction de transfert que nous utilisons

dans la boucle de simulation afin de :

- afficher son équation, - tracer le diagramme de Bode, - placer les pôles et les zéros dans le plan complexe, - tracer la réponse indicielle.

Dans la boucle de simulation et de contrôle nous utilisons les VIs suivants :

- CD Draw Transfer Function Equation.vi (affichage de l’équation d’une fonction de transfert),

- CD Bode.vi (tracé du diagramme de Bode), - CD Pole-Zero Map.vi (tracé du plan des pôles et des zéros de la fonction de

transfert), - CD Step Response.vi (tracé de la réponse indicielle).

Tous ces VIs, dont le nom commence par CD, appartiennent à la sous-palette Control

Design de l’outil Conception de contrôle et simulation.

Dans le panel, nous affichons l’équation de la fonction de transfert discrète, les 2 pôles,

les 2 zéros, les pôles et zéros dans le plan complexe, le diagramme de Bode et la réponse indicielle.

Partie III / Applications

802

II.2.2. Réponse impulsionnelle d’un filtre IIR

Nous considérons le filtre IIR de fonction de transfert suivante :

1958.03695.042066.04131.002066.0)( 24

24

zzzzzzH

Cette fonction de transfert est définie par son numérateur num et dénominateur den que

l’on spécifie dans un nœud MathScript en utilisant la commande tf. La sortie sys du nœud MathScript est appliquée à l’entrée Transfer Function du

bloc Discrete Transfer Function. Cette entrée supplémentaire est créée lorsqu’on choisit Terminal pour Parameter source dans la fenêtre de dialogue de ce bloc, obtenue par un double clic.

Le bloc Collector permet d’associer le temps de simulation au signal de sortie de la fonction de transfert. Ceci permet d’utiliser un graphe XY pour tracer ce signal.

La courbe suivante représente la réponse impulsionnelle qui tend vers zéro lorsqu’un

système est stable.

Chapitre 21 / Traitement du signal déterministe

803

II.2.3. Réponse indicielle

Dans le diagramme suivant, nous appliquons un signal carré à 2 filtres RII définis de 2 façons différentes.

Le VI Basic Function Generator.vi, permet de générer un signal carré

(Square Wave) dont on spécifie l’amplitude, la fréquence, le nombre d’échantillons et la fréquence d’échantillonnage. Il génère un signal de type waveform ou forme d’onde.

La 1ère méthode de création du filtre RII est fournie par le VI Digital IIR

Filter.vi pour lequel nous appliquons ses spécifications dans le cluster IIR filter specifications.

Ces spécifications sont sa topologie (Butterworth, Chebyshev, etc.), le type de filtre (passe-haut, passe-bas, etc.), l’ordre, ses fréquences de coupure et ses atténuations en dB dans la bande passante et la bande atténuée.

Le 2ème et 3ème filtre sont définis par ses coefficients directs (numérateur) et inverses

(dénominateur). Nous avons défini le 4ème filtre en utilisant une boucle de simulation et de contrôle dans

laquelle le filtre RII est réalisé par le bloc Discrete Filter auquel on transmet sa fonction de transfert.

Cette fonction de transfert est définie par les coefficients de son numérateur (Forward Coefficients) et de son dénominateur (Reverse Coefficients).

Ces coefficients sont fournis par le VI Cascade To Direct Coefficients.vi à partir du cluster du cluster du filtre RII de type Butterworth, passe-bas de 2nd ordre dont on définit la fréquence d’échantillonnage et les fréquences de coupure, basse et haute.

Partie III / Applications

804

Le tableau suivant résume les VIs utilisé et leurs sous-palettes : VI Sous-palette Basic Function

Generator.vi Traitement du signal

Génération de waveforms, Digital IIR Filter.vi Traitement du signal

Conditionnement de waveform IIR Cascade Filter.vi Traitement du signal Filtres IIR Filter.vi Traitement du signal Filtres

RII avancé Butter Coefficients.vi Traitement du signal Filtres

RII avancé Cascade To Direct

Coefficients.vi Traitement du signal Filtres RII avancé

Discrete Filter Conception de contrôle et simulation Simulation Discrete Linear Systems

Dans le panel, nous affichons les clusters définissant les filtres et leurs réponses

indicielles.

II.2.4. Diagramme de Nyquist

Le VI Frequency Response Function (Real-Im).vi permet de déterminer les valeurs réelles et imaginaires de la fonction de transfert entre les 2 signaux, celui de l’entrée et de sortie du filtre dont on veut obtenir le diagramme de Nyquist.

Les entrées/sorties sont celles d’un filtre dont les coefficients du numérateur

(Coefficients directs) et ceux du dénominateur (Coefficients inverses) sont spécifiés par le cluster Spécifications du filtre RII dans le panel.

Chapitre 21 / Traitement du signal déterministe

805

Dans ce panel, nous affichons les spécifications du filtre RII du 2nd ordre (coefficients

directs du numérateur et inverses pour le dénominateur) et son diagramme de Nyquist.

II.2.5. Filtres numériques de Bessel et Chebyshev

Ces filtres, comme celui de Butterworth se trouvent dans la palette Traitement du signal Digital Filtrer Design. En utilisant la sous-palette Design, nous pouvons mettre au point ces filtres et pour

analyser ces filtres en traçant les réponses, impulsionnelles, indicielles, etc. Nous allons mettre au point des filtres de Bessel et Chebychev qu’on analysera à travers

leurs réponses impulsionnelles et diagrammes de Bode.

II.2.5.1. Filtre de Bessel

Les filtres de Bessel et Chebyshev se trouvent dans la sous-palette Traitement du signal Digital Filter Design Design IIR.

Partie III / Applications

806

Le VI DFD Bessel Design.vi permet de spécifier le filtre de Bessel dont le type

passe-bas, d’ordre 2, de fréquence de coupure basse de 0.12 Hz et haute de 0.45 Hz. Sa réponse en fréquences est déterminée par le VI DFD Freq Response.vi de la

sous-palette Analysis. La réponse impulsionnelle est obtenue par le VI DFD Plot Impulse

Response.vi, ses pôles et zéros par DFD Plot Pole-Zero.vi de la même sous-palette Analysis.

Le VI de type Express Filter Analysis permet d’obtenir simultanément

différentes propriétés : réponses, impulsionnelle et indicielle, la phase, etc.

Le VI DFD Get Freq Response.vi permet de calculer et de tracer les valeurs de

l’amplitude en dB (valeur par défaut) et la phase pour des valeurs de fréquences spécifiées par le tableau freq points [Hz].

Dans le panel suivant, nous retrouvons les spécifications précédentes, la réponse en

fréquences, la réponse impulsionnelle, ses pôles et zéros dans le plan complexe.

Chapitre 21 / Traitement du signal déterministe

807

II.2.5.2. Filtre de Chebyshev

Le filtre de Chebychev est réalisé par le VI DFD Chebyshev.vi, de la sous-palette Advanced IIR Filter Design. Nous spécifions, dans cet exemple, un filtre passe-haut. Nous traçons la réponse en fréquences et la réponse indicielle.

Dans le panel, nous retrouvons les spécifications de ce filtre passe-haut, sa réponse en

fréquences, sa phase et sa réponse indicielle. En régime permanent de l’échelon, la réponse indicielle est nulle puisque le filtre est de type passe-haut.

Partie III / Applications

808

II.2.6. Filtre de Yulewalker

Dans le nœud MathScript, nous définissons un gabarit d’un filtre passe-bas et cherchons un filtre de Yulewalker d’ordre 16 qui passe au mieux sur ce gabarit. La commande yulewalk permet d’obtenir le numérateur B et dénominateur A de la fonction de transfert discrète de ce filtre. La commande freqz renvoie la réponse en fréquences H ainsi que les pulsations sur 512 points. Nous traçons le module de H en même temps que le gabarit à l’aide de la commande plot.

En sortie du nœud MathScript, nous affichons le numérateur et le dénominateur du filtre ainsi que le module de la réponse en fréquences en dB.

Tracé 1 représente le gabarit et la réponse en fréquences du filtre.

Chapitre 21 / Traitement du signal déterministe

809

L’équation de la fonction de transfert est affichée grâce au VI CD Draw Transfer Function Equation.vi.

Nous traçons le lieu des pôles et zéros et affichons leurs valeurs. La réponse indicielle de cette fonction de transfert est calculée par CD Step

Response.vi entre le temps initial t0 et final tf par pas dt. Le panel suivant représente la réponse en fréquences en dB, l’équation de la fonction de

transfert du filtre de Yulewalker d’ordre 16, sa réponse indicielle, ses pôles et ses zéros.

Nous remarquons que 2 paires de pôles complexes conjugués sont compensées par des

zéros.

II.2.7. Filtre Elliptique et Butterworth – Filtrage de la somme de 3 sinusoïdes

Dans cet exemple, nous allons utiliser les filtres de type elliptique et Butterworth afin de récupérer une sinusoïde à partir d’une somme de 3 sinusoïdes de fréquences, amplitudes et phases différentes :

)3

10(sin)(

)4

20(sin5.0)(

)40(sin2)(

3

2

1

ttx

ttx

ttx

Le filtre elliptique est de type passe-bas de fréquence de coupure de 5.2 Hz et une

ondulation maximale dans la bande passante de 1 dB. Le filtre de Butterworth est de type passe-bande d’où les 2 fréquences de coupure, basse

de 8 Hz et haute de 12 Hz afin de récupérer la sinusoïde de 10 Hz.

Partie III / Applications

810

Les VIs FFT.vi et Auto Power Spectrum.vi, qui permettent de calculer la

transformée de Fourier et le spectre de puissance du signal de sortie des filtres, se trouvent, respectivement, dans les sous-palettes Traitement du signal Transformées et Traitement du signal Spectres Analyse spectrale.

Dans Tracé 1, nous obtenons le résultat de la commande stem du nœud MathScript

qui trace la FFT du signal somme sous forme de bâtons aux fréquences 5, 10 et 20 Hz.

Chapitre 21 / Traitement du signal déterministe

811

Dans le panel suivant, nous affichons les signaux temporels des signaux de sortie des deux filtres ainsi que leurs transformées fréquentielles avec les deux méthodes, par la FFT et le calcul du spectre de puissance.

III. Filtres analogiques

III.1. Circuit RLC

On considère le circuit RLC suivant :

La fonction de transfert de ce circuit est donnée par :

21

1)(pCLp

RL

pH

C’est un circuit du 2nd ordre de coefficient d’amortissement CL

R21 et de pulsation

propreCL

w 10 .

Partie III / Applications

812

Les matrices d’état sont les suivantes :

0,01,10

,1110

DCLC

BRCLC

A

Dans le diagramme suivant, nous mettons œuvre ce modèle d’état en utilisant le VI CD

Construct State-Space Model.vi par la méthode symbolique. Pour cela, nous faisons apparaître le sélecteur de VI polymorphe dans lequel on choisit

Symbolic. Nous avons choisi de spécifier les valeurs symboliques de ces matrices dans le panel. A l’entrée variables, nous appliquons un tableau de clusters dont lequel chaque

cluster est formé d’une chaîne de caractères représentant la variable symbolique, comme la chaîne ‘R’ pour la résistance et une valeur numérique représentant la valeur de cette variable.

En sortie de ce VI, nous obtenons le modèle d’état avec lequel nous pouvons:

- tracer le diagramme de Bode (Bode.vi),

- calculer le coefficient d’amortissement et la pulsation propre (Damping Ratio.vi and Natural Frequency.vi),

- afficher les pôles et les zéros (CD Pole-Zero Map.vi) dans le plan complexe,

- afficher les valeurs des pôles et des zéros (CD Poles.vi et CD Zeros.vi),

- afficher l’équation du modèle d’état (CD Draw State-Space Function Model.vi),

- obtenir la fonction de transfert équivalente (CD Convert to Transfer Function Model.vi),

- tracer la réponse indicielle (CD Step Response.vi).

Tous ces VIs commençant par CD se trouvent dans la sous-palette Control Design

de l’outil Conception de contrôle et simulation. Nous utilisons une boite de calcul pour spécifier les valeurs théoriques du coefficient

d’amortissement et de la puissance propre qu’on comparera à celles que nous obtenons par l’utilisation du VI CD Damping Ratio and Natural Frequency.vi.

Le VI CD Convert to Transfer Function Model.vi permet de

transformer un modèle d’état en sa fonction de transfert équivalente. La réponse indicielle et impulsionnelle est obtenue par les VIs CD Step

Response.vi et CD Impulse Response.vi pour un modèle d’état ou fonction de transfert que l’on spécifie par SS ou TF dans le sélecteur de VI polymorphe.

Chapitre 21 / Traitement du signal déterministe

813

Dans le panel, nous affichons les matrices d’état sous forme symbolique, l’équation de

ce modèle d’état, les pôles et zéros ainsi que le diagramme de Bode, la réponse indicielle, l’équation de transfert équivalente, etc.

III.2. Détermination du filtre de Butterworth par son expression théorique

Le module de la fonction de transfert d’un filtre de Butterworth d’ordre n est donné par :

n

cff

fH2

1

1)(

Partie III / Applications

814

avec cf la fréquence de coupure à -3 dB. L’affaiblissement du signal produit par ce filtre est :

n

cdB f

ffH

fA2

1log10)(

1log20)(

Les paramètres n et fc sont déterminés à partir des spécifications (contraintes) ci-dessous :

2e

cMf

ff

Mf est la fréquence maximale du signal à échantillonner à la fréquence ef . Le signal à échantillonner à la fréquence ef possède le spectre suivant avec Mf sa

fréquence maximale :

Le spectre du signal échantillonné devient périodique dans le domaine fréquentiel de

période ef . Nous obtenons le spectre périodique suivant :

La fréquence de coupure du filtre cf doit être comprise entre Mf et

2ef pour qu’il n’y

ait pas de repliement de spectre. Les fréquences repliées sont celles qui sont supérieures à +( Me ff ). Ainsi, pour que l’influence des fréquences repliées soit inférieure à % , il faut que le

filtre affaiblisse d’au moins : dB)01.0log(20

Chapitre 21 / Traitement du signal déterministe

815

A partir de ces contraintes, on peut déterminer :

la fréquence de coupure cf l’ordre du filtre n

Le type de filtre le plus utilisé dans ce cas est celui de Butterworth car sa coupure est

meilleure que celle d’un simple filtre RC ou de Bessel mais moins que celle d’un filtre de Chebychev.

Ce dernier possède l’inconvénient de présenter des oscillations dans la bande utile

(bande passante correspondant au gain maximal). Considérons le cas d’un signal analogique de :

fréquence maximale KhzfM 10 fréquence d’échantillonnage )2(30 Me fKhzf affaiblissement minimal des fréquences repliées %5%

Ainsi Khzff Me 20 , et à cette fréquence l’atténuation doit être supérieure ou égale à

dB4605.0log2001.0log20 . On impose, de plus, une condition relative à l’atténuation maximale à la fréquence Mf ,

soit par exemple 1 dB. La courbe d’atténuation doit être inférieure à 1 dB à la fréquence Mf et supérieure à 46 dB à la fréquence Me ff . Le graphique suivant donne un exemple de gabarit répondant aux contraintes énoncées

précédemment :

Le problème consiste à résoudre un système de 2 inéquations à 2 inconnues : l’ordre n et

la fréquence de coupure cf .

dBffAdBfA

Me

M

46)(1)(

L’expression de l’atténuation peut être écrite de la façon suivante :

Partie III / Applications

816

cffnfA ln2exp(1log10)(

La méthode consiste à calculer, pour les valeurs successives de l’ordre n, à partir de n=1,

les valeurs de cf (la fréquence de coupure) qui correspond à :

dBAfA M 1)( max puis les valeurs :

dBAffA Me 46)( min

Nous avons ainsi :

maxln2exp(1log10)( AffnfA

c

MM

soit :

10ln

ln2exp(1ln

10max c

M

ffn

A

Si l’on pose10

10lnmaxAa , on obtient :

cffna ln2exp(1)exp(

Nous obtenons finalement l’expression de la fréquence de coupure :

)2

)1)(exp(lnexp(na

ff Mc

III.2.1. Utilisation d’un nœud MathScript

Les fréquences, maximale fM et d’échantillonnage fe, sont choisies dans le panel pour être des entrées du nœud MathScript.

L’atténuation maximale, Amax, à la fréquence fM, est choisie égale à 1 dB.

L’entrée permet de calculer la valeur minimale, Amin, de l’atténuation à la fréquence (fe-fM).

Nous utilisons la boucle While dans laquelle on augmente l’ordre n du filtre tant que

l’atténuation reste plus faible que Amin.

A chaque itération, nous récupérons la valeur de la fréquence de coupure fc.

L’atténuation est tracée, en sortie du nœud MathScript, dans un graphe XY, en fonction de la fréquence.

L’ordre n et la fréquence de coupure fc sont affichés dans le cluster n-fc.

Chapitre 21 / Traitement du signal déterministe

817

Dans le panel, nous traçons l’atténuation du filtre de Butterworth avec l’ordre n et la

fréquence de coupure fc calculés dans le nœud MathScript.

III.2.2. Utilisation des VIs du langage G de LabVIEW

Dans le diagramme suivant, nous utilisons 2 nœuds MathScript, une boucle While et des VIs du langage G.

Les entrées de la boucle While sont les fréquences caractéristiques fe et fM ainsi que les atténuations Amax et Amin.

Nous calculons directement l’atténuation en utilisant les blocs de l’exponentielle et du

logarithme. Nous en déduisons le tableau des atténuations, l’ordre n et la fréquence de coupure fc. Dans le 2ème nœud MathScript, nous programmons l’expression théorique du filtre de

Butterworth d’ordre n et de fréquence de coupure fc.

Partie III / Applications

818

Nous obtenons le même résultat que précédemment. Dans le panel, nous affichons les paramètres caractéristiques, ainsi que la courbe de

l’atténuation en fonction de la fréquence. Nous créons 3 curseurs, à l’aide de l’option Propriétés du menu local en cliquant droit sur le graphe XY.

Grâce à ces curseurs, nous affichons les atténuations aux différentes fréquences caractéristiques. A l’aide curseur 0, nous obtenons l’atténuation de 48 dB à la fréquence (fe-fM). Le curseur curseur 1 nous donne l’atténuation de 0.876 dB qui est bien inférieure à Amax=1 dB. Avec curseur 3, nous vérifions l’atténuation de 3 dB de la fréquence de coupure fc.

IV. Filtrage d’un signal aléatoire

IV.1. Filtre moyenneur – nœud de rétroaction

Dans le diagramme suivant, nous filtrons un bruit blanc gaussien par le filtre moyenneur suivant :

)z(121H(z) 1

Chapitre 21 / Traitement du signal déterministe

819

Le retard z-1 est effectué par un nœud de rétroaction de la palette Structures. Dans son menu local, option Apparence, nous choisissons nœud de délai de transformée en z.

Dans ce bout de diagramme, nous appliquons une impulsion sur 10 échantillons

temporels. La réponse impulsionnelle de ce filtre est constituée des 2 échantillons )(k et )1(k

de hauteur 0.5 comme affichés dans le graphe suivant.

Dans le diagramme suivant, nous appliquons à ce filtre moyenneur un bruit blanc

gaussien centré d’écart-type unité. Nous calculons la moyenne et la variance du bruit à l’entrée et en sortie du filtre

moyenneur. Si on appelle x et 2

x la moyenne et la variance du bruit en entrée du filtre, celles du bruit en sortie, y et 2

y , sont données par :

0)1( xxHy

5.02

)2()1(2

2222 xxy hh

H(1)est le gain statique du filtre et h(k) l’échantillon n°k de sa réponse

impulsionnelle.

Partie III / Applications

820

Dans le panel suivant, nous affichons les bruits en entrée et en sortie du filtre, leurs histogrammes respectifs et leurs moyennes et variances.

Nous vérifions bien que les moyennes sont identiques et que la variance en sortie est moitié de celle en entrée. Les distributions de ces bruits sont toutes deux gaussiennes.

IV.2. Filtre moyenneur dans l’espace d’état

Dans cet exemple, on se propose de programmer ce filtre moyenneur sous forme de son modèle d’état. Pour obtenir ce modèle d’état, nous considérons la fonction de transfert suivante :

)z(1z21H(z) 11

Chapitre 21 / Traitement du signal déterministe

821

Malgré le retard supplémentaire par rapport au cas précédent, ce filtre remplit toujours la fonction de moyenneur.

La sortie s’exprime, en fonction de l’entrée, par l’expression suivante :

)2(5.0)1(5.0)( kukuky En notant )()(1 kykx , le choix de la variable )(2 kx n’est pas unique. Un modèle d’état de ce filtre peut être le suivant :

)(5.0)1()(5.0)()1(

2

21

kukxkukxkx

D’où les matrices d’état suivantes :

0,01,5.05.0

,0010

DCBA

Nous allons utiliser l’outil Conception de contrôle et simulation. Le modèle d’état est défini, à l’aide de la commande ss du langage MathScript, dans le

nœud MathScript. Le bloc Discrete State-Space, de la sous-palette Discrete Linear

Systems, utilise ce modèle d’état lorsqu’on applique la sortie du nœud MathScript à son entrée supplémentaire State-Space.

Cette entrée apparaît comme 2ème entrée lorsqu’on choisit Terminal pour

Parameter source après un double clic.

Dans le panel suivant, nous affichons la réponse impulsionnelle du filtre moyenneur et les histogrammes du bruit en entrée et sortie du filtre.

Partie III / Applications

822

Nous obtenons bien une distribution triangulaire en sortie lorsqu’on applique en entrée

de ce filtre un signal uniforme. En effet, le filtre moyenneur peut être considéré comme filtre sommateur et la

distribution d’une somme de variables uniformes suit bien une distribution triangulaire de même valeur moyenne

V. Filtrage adaptatif

Les filtres adaptatifs sont des filtres numériques dont les coefficients s’adaptent à des phénomènes variant dans le temps comme dans le cas de l’élimination d’un bruit dont les caractéristiques fréquentielles changent avec le temps.

Un filtre adaptatif est schématisé comme suit :

Le filtre peut être du type FIR ou IIR. L’algorithme permet d’ajuster les coefficients du filtre selon un algorithme d’adaptation.

Cet algorithme peut être du type LMS ou RLS.

d(k) est un signal d’entrée additionnel du filtre adaptatif.

Chapitre 21 / Traitement du signal déterministe

823

Dans le cas d’un filtre FIR, les étapes de mise à jour de ses coefficients par l’algorithme LMS sont les suivantes :

1. calcul de la sortie y(k) du filtre FIR : )()()( kkXky T

avec :

)1(...

)1()(

)(

Nkx

kxkx

kX : vecteur d’entrée du filtre

)(...

)()(

)(

1

1

0

kb

kbkb

k

N

: vecteur des coefficients du filtre FIR

2. Calcul de l’erreur )()()( kykdke

3. Mise à jour des coefficients du filtre par l’équation : )()()()1( kXkekk

avec :

: scalaire d’adaptation (step size).

Les filtres adaptatifs se trouvent dans la palette Traitement du signal Adaptive Filters.

Parmi ces filtres, certains serviront à l’identification, d’autres à la suppression d’un

bruit, la prédiction d’un signal, etc.

Pour l’adaptation, 2 algorithmes seront utilisés : LMS (Least Mean Squares ou Moindres

Carrés Moyens) et RLS (Real Least Squares : Moindres Carrés Exacts).

Partie III / Applications

824

V.1. Algorithme LMS - Filtre FIR d’horizon 2

V.1.1. Utilisation des VIs du langage G

Les VIs de cette sous-palette Adaptive Filters ont une étiquette commençant par AFT pour Adaptive Filter Toolkit.

Le VI AFT Create FIR LMS crée un filtre FIR adaptatif utilisant l’algorithme standard des moindres carrés moyens dont la longueur (nombre de coefficients) est définie par l’entrée filter length.

La structure de ce filtre est transmise aux autres VIs par la sortie adaptive filter out.

La mise à jour des coefficients de ce filtre est réalisée par le VI AFT Filter Signal and Update Coefficients.vi. Ce VI reçoit les entrées/sorties du modèle à identifier et renvoie sa sortie et l’erreur ou différence entre cette sortie et celle du processus à identifier.

Les coefficients mis à jour sont lus par le VI AFT Get Coefficients.vi. Le processus à identifier est modélisé par l’expression suivante :

)1()()( 21 kubkubky

C’est un filtre FIR de longueur 2. L’élément u(k-1) est obtenu par le nœud de rétroaction à partir de u(k).

La commande u(k) est une séquence binaire pseudo aléatoire de période 1023.

Pour obtenir des valeurs entre -1 et 1, nous faisons passer les valeurs de cette séquence par la relation 2(x-0.5). Les paramètres b1 et b2 sont spécifiés par le cluster b1-b2 dans le panel.

Chapitre 21 / Traitement du signal déterministe

825

Le panel suivant représente :

- le stimulus (SBPA), - la sortie du filtre avec celle du processus à identifier, - l’erreur d’identification, - l’évolution des paramètres du filtre et ceux du processus.

La sortie du filtre rejoint celle du processus ainsi pour les paramètres identifiés.

V.1.2. Utilisation du nœud MathScript

Dans ce qui suit, nous allons utiliser le nœud MathScript pour programmer l’algorithme LMS pour estimer les coefficients d’un filtre FIR adaptatif.

Le signal stimulus est une séquence pseudo aléatoire SBPA de longueur 1023. A la ligne 3, nous initialisons le vecteur teta des paramètres à 0. Dans la ligne 7, nous calculons les valeurs du signal d. L’algorithme LMS est programmé dans les 3 lignes 13 à 15 dans lesquelles nous suivons

les 3 étapes décrites précédemment. Nous traçons les signaux d et y dans 2 graphes, respectivement pour les 200 premiers

échantillons et 200 derniers échantillons temporels. Ces 2 graphes permettent de montrer les régimes, transitoire et permanent. Les 2

coefficients du filtre FIR adaptatif sont tracés dans un graphe XY. Les valeurs finales des coefficients sont obtenues par indexation du tableau de ces

paramètres en utilisant sa taille.

Partie III / Applications

826

Dans le panel, nous affichons l’évolution et la convergence des 2 coefficients, les 200

premiers et derniers échantillons temporels des signaux d et y. Après le régime transitoire, nous observons une totale similitude de ces signaux, soit une erreur d’adaptation nulle. Nous traçons également le stimulus SBPA. Nous obtenons parfaitement les mêmes valeurs 1 et 0.5 des coefficients simulés au bout de 2000 échantillons temporels.

Dans cet exemple, nous avons utilisé un gain d’adaptation (step size) de valeur 0.002. Le régime transitoire dure un peu plus de 2000 échantillons temporels.

V.1.3. Utilisation des VIs de calcul matriciel

Dans l’exemple, nous avons utilisé le calcul matriciel afin d’obtenir les signaux d’entrée d et de sortie y par l’utilisation du produit scalaire des tableaux, du stimulus et respectivement, des coefficients simulés et ceux identifiés à chaque itération.

Grâce à l’auto-indexation d’un tableau entrant dans une boucle For, chaque valeur u(k) du stimulus est sauvegardé dans un registre à décalage.

Chapitre 21 / Traitement du signal déterministe

827

Les valeurs précédentes u(k-1) et u(k-2) sont assemblées en un tableau 1D grâce à la fonction Construire un tableau. Un autre registre à décalage permet d’obtenir la valeur teta(k-1) du vecteur des coefficients du filtre adaptatif.

Le panel suivant ressemble à celui de l’exemple précédent sauf que la valeur du gain

d’adaptation a été augmentée à 0.005 et que nous avons tracé également l’évolution de l’erreur d’adaptation, soit la différence des signaux d et y.

La durée du régime transitoire a été divisée par 2.

V.2. Algorithme RLS - Filtre FIR d’horizon 3

Dans cet exemple, nous considérons un système à identifier de type :

)2()1()()( 321 kubkubkubky

Partie III / Applications

828

L’identification se fait à l’aide de l’algorithme RLS. Le stimulus est la même séquence SBPA de l’exemple précédent. Le régime transitoire dure moins longtemps que précédemment dans le cas du filtre LMS.

Dans le panel, comme dans l’exemple précédent, nous affichons le stimulus, les sorties

du filtre et du processus et l’erreur d’identification.

V.3. Filtre antibruit

Dans le diagramme suivant, nous utilisons le VI AFT Create FIR Filtered-X LMS.vi afin de supprimer un bruit indésirable.

Ce bruit est simulé par une suite de 2 sinusoïdes de fréquences et amplitudes différentes.

Chapitre 21 / Traitement du signal déterministe

829

Le VI AFT Filtered Signal and Update Coefficients.vi reçoit ce signal à supprimer et l’erreur. Cette erreur est la somme de la sortie du filtre et du signal à supprimer. Comme l’algorithme utilise cette erreur pour la mise à jour des coefficients, celle-ci s’annule et les coefficients convergent et deviennent constants.

Dans le panel suivant, nous affichons, dans un même graphe, la sinusoïde à supprimer et

l’erreur résiduelle de la suppression. Dans le 2ème graphe, nous avons affiché l’évolution des 5 premiers coefficients du filtre. Nous observons des oscillations de ces valeurs dans le régime transitoire. Dans le dernier graphe, nous affichons la sinusoïde d’origine, celle après le retard de 200 et celle à l’entrée du filtre.

Nous avons choisi un filtre de 128 coefficients et un gain d’adaptation (step size) égal à 0.001.

Avec un gain d’adaptation de 0.002, nous obtenons une meilleure et rapide élimination

du bruit.

Partie III / Applications

830

Le régime transitoire dure 3 fois moins longtemps que pour un gain de 0.001. Dans l’exemple suivant, le filtre reçoit la moitié du bruit à annuler. Lorsque cette part

devient de plus en plus faible, la durée du régime transitoire devient de plus en plus grande.

VI. Identification de paramètres inconnus

Le VI AFT Filter Signal.vi est attaqué par le signal stimulus généré par le sous-VI Système inconnu bruité.

La sortie de ce VI est retranchée au signal de sortie du sous-VI pour former le signal d’erreur qu’on applique au VI AFT Update Coefficients.vi pour mettre à jour les coefficients du filtre adaptatif afin d’annuler cette erreur. Les coefficients mis à jour sont lus par AFT Get Coefficients.vi.

L’histogramme, la moyenne et la variance du signal d’erreur sont déterminés, respectivement, par le VI Express Créer un histogramme et Std Deviation and Variance.vi.

Sa fonction d’autocorrélation est déterminée par le VI TSA Auto-Correlation

Function.vi de la sous-palette Correlation and Spectral Analysis.

Chapitre 21 / Traitement du signal déterministe

831

Le processus bruité est symbolisé par le sous-VI système inconnu bruité.vi.

La sortie du processus est un bruit gaussien filtré par un filtre FIR dont les coefficients (ceux à identifier) sont spécifiés dans le tableau coefficients inconnus, dans le panel. A cette sortie, on ajoute un autre bruit gaussien.

Le panel représente l’évolution de l’erreur d’identification, celle des paramètres par

rapport à ceux du modèle d’origine. Cette erreur s’annule et les paramètres identifiés rejoignent parfaitement ceux du

processus à identifier. L’histogramme de l’erreur est gaussien, son autocorrélation est une impulsion de Dirac,

ce qui montre une bonne identification car l’erreur peut être assimilée à un bruit blanc. L’affichage de quelques valeurs des coefficients montre que ceux identifiés sont très

proches de ceux du processus, à l’instar du 2ème : 0,0204617 contre 0,0204622.

Partie III / Applications

832

VII. Prédiction de signal

Dans le diagramme suivant, nous nous intéressons à la prédiction d’un signal à l’aide d’un filtre autorégressif AR à 50 coefficients.

Le signal à prédire est une suite de 2 signaux : )2sin(sin twt et wtsin . On ajoute à ce signal, un bruit blanc gaussien d’écart-type 0.02.

Le VI AFT Linear Prediction.vi permet de renvoyer les coefficients du

modèle AR qui permet cette prédiction ainsi que l’erreur. Pour une valeur de 0.001 du gain d’adaptation (step size), nous obtenons les

résultats suivants :

Chapitre 21 / Traitement du signal déterministe

833

Nous remarquons que le signal prédit, se rapproche au fur et à mesure du signal à

prédire. La durée du régime transitoire peut être estimée à 2000 pas d’échantillonnage. L’erreur

de prédiction a une allure gaussienne. Avec un gain de 0.01, la durée du régime transitoire peut être estimée à 500 pas, soit le

quart de la valeur de l’exemple précédent.

Après un certain régime transitoire, le signal prédit coïncide parfaitement avec le signal

à prédire. L’erreur de prédiction possède une moyenne et une variance très faibles. De plus

l’histogramme de cette erreur est gaussien. Le VI Error Cluster From Error Code.vi, de la palette Dialogue et

Interface Utilisateur, permet de transformer un code d’erreur en cluster d’erreur.

La fonction Fusionner les erreurs, de cette même palette, permet d’obtenir un même cluster d’erreur à partir de plusieurs erreurs du même VI.

Partie III / Applications

834

Lorsqu’on choisit un gain de 0.1, la durée du régime transitoire est négligence, la variance de l’erreur de prédiction a été divisée par 10, ce que nous pouvons remarquer sur la courbe de l’erreur et sur l’histogramme.

Partie III. Chapitre 22 - Traitement numérique des signaux aléatoires

I. Filtre FIR moyenneur I.1. Réponse indicielle I.1.1. Utilisation du nœud de rétroaction I.1.2. Palette Conception de contrôle et simulation I.2. Statistiques des bruits d’entrée et de sortie I.3. Réponse en fréquences II. Filtres IIR et FIR III. Signaux stochastiques monodimensionnels III.1. Corrélation et intercorrélation III.1.1.Utilisation des nœuds MathScript III.1.2.Utilisation des VIs LabVIEW III.2. Densité spectrale énergétique IV. Systèmes et signaux stochastiques multidimensionnels IV.1. Evolution des états x1, x2 et signal de sortie du système IV.2. Evolution des variances des composantes d’états et celle de la sortie V. Estimation de signaux et de modèles de systèmes discrets V.1. Algorithme des moindres carrés récursifs V.2. Filtrage de Kalman V.2.1. Estimation d'une constante V.2.2. Estimation de l'état d'un processus dynamique VI. Régime permanent du filtre de Kalman VII. Prédicteur de Kalman VII.1. Génération du signal par la fonction de transfert - Nœud MathScript VII.2. Génération du signal par l’équation de récurrence - Boite de calcul VII.3. Génération du signal par le modèle d’état VII.4. Génération du signal par le prédicteur de Kalman

835DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 _22,N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Partie III / Applications

836

I. Filtre FIR moyenneur

Nous considérons un filtre à réponse impulsionnelle finie (FIR) de fonction de transfert :

)1(21)( 11 zzF

Ce filtre peut aussi être défini par cette équation aux différences :

)1()(21)( kxkxky

Le filtre n’étant pas récursif, sa sortie )(ky ne dépend que des échantillons du signal d’entrée )(kx .

I.1. Réponse indicielle

I.1.1. Utilisation du nœud de rétroaction

Dans le diagramme suivant, nous appliquons un signal carré à l’entrée de ce filtre. Le signal carré est généré par le VI Basic Function Generator.vi de la sous-palette Traitement du signal Génération de waveforms. Le signal est de type waveform. Pour ramener le signal entre les valeurs 0 et 1, à partir de l’ensemble [-1 1], nous avons ajouté 1 et divisé par 2. Le filtre FIR est réalisé grâce au nœud de rétroaction qu’on initialise par une waveform dont on fixe le même dt=0.001 et de valeur Y=0. Nous traçons, dans un graphe, les waveforms d’entrée et de sortie du filtre.

Chapitre 22 / Traitement des signaux aléatoires

837

A partir de l’équation de récurrence précédente, la sortie du filtre possède les valeurs suivantes :

0 0.5 1 . . . 1

Que ce soit au front montant ou descendant, la sortie est nulle tandis que les valeurs constantes se retrouvent à la sortie avec les mêmes valeurs, soit un gain statique unité ; ce qui valide la nature passe-bas de ce filtre moyenneur. Dans le panel suivant, nous retrouvons les valeurs précédentes du régime transitoire.

I.1.2. Palette Conception de contrôle et simulation

Dans le diagramme suivant, nous utilisons un nœud MathScript pour spécifier le filtre sous forme de la fonction de transfert suivante :

zzzH2

1)(

Nous définissons le numérateur et le dénominateur de cette fonction de transfert qu’on transmet à la commande tf pour obtenir cette fonction de transfert. La valeur ‘-1’ signifie que c’est une fonction de transfert discrète dont la période d’échantillonnage n’est pas définie.

L’équation de cette fonction de transfert est affichée dans Equation grâce au VI CD

Draw Transfer Function Equation.vi de la sous-palette Conception de contrôle et simulation Control Design Model Construction.

Partie III / Applications

838

La réponse indicielle est obtenue par le VI CD Step Response.vi. Ses valeurs sont affichées dans le cluster Step Response Data dans lesquelles nous retrouvons les mêmes valeurs transitoires que précédemment.

Dans le panel, nous affichons les valeurs de la réponse impulsionnelle, l’équation de la fonction de transfert indicielle et la courbe de cette réponse.

I.2. Statistiques des bruits d’entrée et de sortie

Dans le diagramme suivant, nous allons déterminer les statistiques du signal de sortie en appliquant, à l’entrée, un signal gaussien, centré et réduit. Le filtre est réalisé comme dans l’exemple précédent. Nous calculons la moyenne et la variance du bruit d’entrée que nous affichons dans le cluster bruit d’entrée. Nous vérifions que la moyenne est nulle et la variance unité. L’histogramme est bien gaussien. Nous filtrons, par ce filtre moyenneur, un bruit blanc gaussien. Comme ce signal est de type waveform, le noeud de rétroaction est initialisé par une constante waveform. Nous calculons les caractéristiques statistiques des signaux en entrée et en sortie ainsi que nous traçons leurs histogrammes. En sortie du filtre, le signal reste gaussien comme en entrée. Le filtre étant de type passe-bas, la variance a été divisée par 2. Sur le panel, nous traçons les bruits temporels en entrée et sortie du filtre ainsi que leurs histogrammes. La moyenne en sortie est égale au produit de celle en entrée par le gain statique du filtre donc nulle.

Chapitre 22 / Traitement des signaux aléatoires

839

La variance du signal du signal de sortie est donnée en fonction du signal d’entrée par l’expression suivante :

2222

21)(

41

xxxy

Nous retrouvons bien cette valeur dans le cluster bruit de sortie 2. L’histogramme en sortie reste gaussien comme le signal d’entrée. Dans le cluster signal en sortie, nous affichons la waveform du signal d’entrée.

I.3. Réponse en fréquences

Pour réaliser le tableau des pulsations normalisées de – à , nous utilisons une boucle For dans laquelle on fait la transformation linéaire suivante :

iN

wT 2

Nous utilisons ensuite un nœud MathScript dans lequel on calcule la fonction de transfert complexe du filtre. Comme pour le script MATLAB, avec le nœud MathScript, pour ajouter une entrée ou une sortie, on fait un clic droit sur le bord du nœud et on choisit l’option « Ajouter une entrée » ou sortie. Les sorties seront choisies dans une liste des valeurs calculées à l’intérieur du nœud.

Partie III / Applications

840

On affiche ensuite le module de cette fonction de transfert complexe ainsi que des clusters de l’erreur en entrée ou sortie du nœud MathScript.

La réponse en fréquences est tracée dans un graphe XY. La réponse en fréquences théorique de ce filtre est donnée par l’expression suivante :

2cos

21)( wTejwH

jwT

Nous retrouvons bien cette forme dans le panel suivant.

Nous allons calculer cette réponse en fréquences par une autre expression en utilisant des blocs élémentaires de LabVIEW.

Nous calculons l’expression suivante : )2cos( tN

Chapitre 22 / Traitement des signaux aléatoires

841

Dans le panel suivant, nous retrouvons bien la même forme que le résultat précédent.

La réponse en fréquences d’un filtre peut être obtenue à partir de ses entrées/sorties. Le filtre moyenneur précédent est réalisé par le VI FIR Filter.vi de la sous-palette Traitement du signal Filtres RIF Avancé. Les coefficients du filtre sont spécifiés par le tableau FIR coefficients. L’entrée du filtre est un bruit blanc uniforme d’amplitude unité. Ce bruit, sous la forme d’une waveform, est généré par le VI Uniform White Noise Waveform.vi de la sous-palette Traitement du signal Génération de Waveforms. Pour obtenir le même type de waveform, en sortie du filtre, que celle du signal d’entrée, on utilise la fonction Construire une waveform qui reçoit le même dt (pas de temps) et le même instant initial t0 que la waveform d’entrée. Le signal d’entrée Y est celui de la

Partie III / Applications

842

sortie du filtre FIR. Cette waveform est affichée dans l’indicateur waveform en sortie. Pour obtenir les courbes du module et de la phase, nous utilisons le VI Frequency Response Function (Mag-Phase).vi de la sous-palette Traitement du signal Mesures sur waveform.

Dans le panel suivant, nous affichons les courbes du module et de la phase de la fonction de transfert de ce filtre. Nous avons vu que le module sous forme du cosinus :

2cos)( wTeH jwT ,

2)( Tjwjw

Le filtre, de type passe-bas est dit filtre à phase linéaire, de 0 (w=0) à – /2 (w ).

Le filtre correspond à une sommation de 2 variables uniformes.

Chapitre 22 / Traitement des signaux aléatoires

843

La variable résultante suit alors, en théorie, une distribution triangulaire, ce que montre la courbe de l’histogramme de la variable de sortie du filtre moyenneur.

II. Filtres IIR et FIR

Considérons le filtre IIR (Infinite Impulse Response) suivant :

9.01)( 1

zzzH

En effectuant la division euclidienne du numérateur sur le dénominateur de cette fonction de transfert, nous obtenons le quotient Q(z) et le reste R(z) suivant si l’on fait la troncature de la réponse impulsionnelle par une fenêtre rectangulaire de largeur 4.

4321 0009.0009.009.09.01)( zzzzzQ

500009.0)( zzR En négligeant le reste R(z), nous obtenons un filtre FIR équivalent au filtre RII ci-dessus. Dans le diagramme suivant, nous définissons ces 2 filtres par une fonction de transfert constante pour laquelle, nous spécifions uniquement le numérateur, le dénominateur et la période d’échantillonnage. Ce filtre est échantillonné à fe=10 KHz, soit une période d’échantillonnage Te=10-4s. Pour chacune des 2 fonctions de transfert, nous traçons le diagramme de Bode par le VI CD Bode.VI de la sous-palette Conception de contrôle et simulation Control Design Frequency Response. Nous traçons également, leurs équations en z en utilisant le VI CD Draw Transfer Function Equation.vi. Dans le nœud MathScript, nous déterminons la réponse de sortie de ces 2 filtres lorsqu’on leur applique le même signal gaussien centré d’écart-type 5. Le numérateur et dénominateur de ces 2 filtres sont des entrées du nœud MathScript. La fonction de transfert constante est un cluster formé des 2 autres clusters properties et transfer function(s) sous de tableau de clusters. En indexant ce tableau, nous récupérons le 2ème élément, à savoir le cluster transfer function(s). En désassemblant ce cluster nous obtenons le numérateur et le dénominateur de la fonction de transfert du filtre. Dans le langage G de LabVIEW, les polynômes sont spécifiés par un ordre croissant des puissances contrairement au langage MathScript. Pour utiliser ces polynômes dans le nœud MathScript, nous devons les inverser avant de les envoyer dans le nœud par la fonction Inverser un tableau 1D comme nous le faisons pour le numérateur Numerator ou dans le nœud par la commande fliplr (flip left right), ce que nous faisons pour le dénominateur Denominator. Pour filtrer le signal gaussien, nous utilisons la commande filter du langage MathScript.

Partie III / Applications

844

Dans le panel, nous traçons les 2 diagrammes de Bode ; celui du filtre RII et celui du RIF obtenu par la division euclidienne avec troncature par une fenêtre rectangulaire. La nature de filtre passe-haut est conservée par la troncature même si la bande passante s’est rétrécie par cette opération. Pour approcher la bande passante du filtre RII il faut prendre un nombre important de coefficients.

Nous affichons également les fonctions de transfert en z des 2 filtres.

La variance en sortie est plus grande en sortie qu’en entrée.

En notant h(k) le coefficient de puissance k du filtre FIR, la variance 2s en sortie est

donnée par : 222 ))(( es kh

Nous vérifions la quasi-similitude de ce résultat avec celui obtenu par le VI Std Deviation and Variance.VI.

Chapitre 22 / Traitement des signaux aléatoires

845

III. Signaux stochastiques monodimensionnels

III.1. Corrélation et intercorrélation

III.1.1. Utilisation des nœuds MathScript

On considère un filtre numérique du premier ordre de fonction de transfert générale :

)1A(z

)1B(zH(z)

L’entrée de ce filtre est un bruit x(t) gaussien, blanc, centré et de variance x2 .

On se propose d'étudier les caractéristiques du bruit en sortie (moyenne, variance, autocorrélation, intercorrélation avec le bruit en entrée, densité spectrale énergétique etc.). Les signaux discrets x(t) et y(t), de même longueur, sont respectivement l'entrée et la sortie du filtre numérique. Nous utilisons les notations suivantes :

x y, : Moyenne de x et y, Rxy k Ryx k( ), ( ) : Échantillon n° k des fonctions d'intercorrélation de x à y et de y à x, Rxx k Ryy k( ), ( ) : Échantillon n° k des fonctions d'autocorrélation de x et de y, Sxx w Syy w( ), ( ) : Densités spectrales de puissance de x et de y, Sxy w( ) : Interspectre de puissance des signaux x et y.

Nous rappelons les relations permettant le calcul de ces différents paramètres, dans le cas du filtrage d'un signal x(t) par un filtre numérique de fonction de transfert H(z) et de sortie y(t). La valeur moyenne du signal de sortie est égale à celle de l'entrée multipliée par le gain statique du filtre :

y H x( )1

L'échantillon n° k de la fonction de corrélation de x à y est donné par :

kN

1jk)y(jx(j)

1kN1(k)xyR

La densité spectrale énergétique d'un signal est la transformée de Fourier de sa fonction d'autocorrélation :

(k)xyRF(w)xyS

C'est la réponse en fréquences du filtre RIF de réponse impulsionnelle (k)xyR dans le

domaine ππ, des pulsations normalisées. Comme exemple d'utilisation de cette fonction, on se propose de calculer les fonctions de corrélation des signaux d'entrée et de sortie du filtre moyenneur :

)z(121H(z) 1

Partie III / Applications

846

Le diagramme suivant permet de calculer les corrélations relatives aux signaux x d’entrée et y de sortie de ce filtre moyenneur. Ce diagramme est constitué de séquences dans lesquelles on utilise des nœuds MathScript. La séquence 0 permet de définir le numérateur et le dénominateur du filtre, la taille des signaux temporels et celle des corrélations.

III.1.1.1. Séquence 0 – Filtrage d’un bruit blanc

Le calcul du signal de sortie du filtre moyenneur se fait en filtrant (commande filter) un bruit blanc gaussien.

Les autres séquences ont besoin des signaux et paramètres définis ou calculés dans cette séquence. Pour cela, ces derniers sont transférés aux autres à travers des tunnels orientés. Pour créer un tunnel, on choisit l’option « Ajouter une variable locale de séquence » par un clic droit sur le bord de la séquence.

Chapitre 22 / Traitement des signaux aléatoires

847

III.1.1.2. Séquence 1 – scripts des autocorrélations et intercorrélations

Dans cette séquence, nous calculons les intercorrélations entre l’entrée x et la sortie y ainsi que leurs autocorrélations respectives. Pour cela, nous utilisons la commande xcorr pour calculer ces corrélations et intercorrélations.

Nous utilisons 4 nœuds MathScript qui se passent les paramètres n et N ainsi que les signaux x et y reçus de la séquence 0. Les erreurs sont fusionnées en une seule que nous affichons dans le cluster d’erreur de sortie.

III.1.1.3. Autocorrélation Rxx du signal d’entrée x

Avec un nombre d'échantillons de 500, le signal généré par la fonction randn est proche d'un bruit blanc vu que sa fonction d'autocorrélation est quasiment une impulsion de Dirac.

Partie III / Applications

848

Les différentes courbes des corrélations et intercorrélations sont tracées dans les onglets correspondants et sont aussi tracées dans les nœuds MathScript en utilisant la commande plot. Tous les échantillons Rxx(k) pour 0k sont plus petits que 0.1 ; on peut donc aisément assimiler le signal généré par la commande randn à un bruit blanc.

III.1.1.4. Calcul de l’intercorrélation Rxy et Ryx

Le calcul de cette intercorrélation donne :

)1()(21)()(

21

)1()()(21)()(

ktxtxEktxtxE

ktxktxtxEktytxERxy

où :

)1(21)0(

21)( 22 kkkRxy xx

C’est ce qu’on trouve dans la courbe suivante. Les échantillons sont tous nuls sauf celui à l’instant k=0 et celui à l’instant k=-1. Les échantillons plus petits que 0.1 sont considérés nuls (règle du 10ème).

Tous les échantillons sont nuls sauf Rxy(0) = Rxy(-1) = 0.5. Lorsqu'on filtre un bruit blanc, on obtient toujours un bruit coloré. Dans ce cas particulier, en raisonnant dans le domaine temporel, nous avons :

k)1x(tx(t)21k)]x(tx(t)E

21

k)1x(tk)x(tx(t)E21k)y(tx(t)E(k)yxR

Chapitre 22 / Traitement des signaux aléatoires

849

ce qui vérifie bien les valeurs obtenues dans le graphique précédent.

(k)yxR 2xσ2

1 (pour k = 0) + 2xσ2

1 (pour k = 1)

III.1.1.5. Calcul de l’autocorrélation Ryy du signal de sortie y

Nous obtenons ces résultats par le calcul dans le domaine temporel.

Ryy k E y t y t k E x t k x t k x t k x t k( ) ( ) ( ) ( ) ( ) ( ) ( )14 1 1

Cette autocorrélation peut se réduire à l’expression suivante :

Ryy k( ) 12

2x (pour k = 0) + 14

2x (pour k = 1) + 14

2x (pour k = -1)

On vérifie bien ces valeurs dans la courbe ci-dessous. Tous les échantillons sont nuls sauf Ryy(1) = Ryy(-1) = 0.25 et Ryy = 0.5. Nous trouvons ces résultats dans la courbe suivante.

Partie III / Applications

850

Toutes ces courbes sont affichées dans des graphiques LabVIEW qu’on affiche dans le panel comportant 4 onglets. Dans ces onglets, nous traçons les autocorrélations des signaux d’entrée/sortie et leurs intercorrélations. Dans la fenêtre suivante, nous traçons l’autocorrélation du signal d’entrée x qui ressemble à une impulsion de Dirac qui signifie que ce signal est un bruit blanc. Nous affichons ensuite une intercorrélation qui vérifie les calculs théoriques précédents.

Chapitre 22 / Traitement des signaux aléatoires

851

III.1.2. Utilisation des VIs LabVIEW

Dans le diagramme suivant, nous utilisons des VIs du langage G pour calculer les corrélations et intercorrélations.

Ces différents VIs se trouvent dans la sous-palette Traitement du signal Time Series Analysis Correlation and Spectral Analysis.

Dans le diagramme suivant, le filtre moyenneur précédent est réalisé par le VI FIR Filter.vi de la sous-palette Traitement du signal Filtres Filtrage FIR Avancé.

Le signal d’entrée du filtre est un bruit blanc uniforme sous la forme d’une waveform.

Nous utilisons les VIs TSA Autocorrelation Function.vi pour calculer la fonction d’autocorrélation d’un signal, et TSA Crosscorrelation Function.vi pour l’intercorrélation entre 2 signaux.

Les histogrammes des signaux d’entrée et de sortie du filtre sont obtenus par le VI de type Express Create Histogram.

Partie III / Applications

852

L’histogramme du signal d’entrée est unifome tandis que celui de la sortie est gaussien du fait du théorème central limite.

L’autocorrélation du bruit d’entrée est bien une impulsion de Dirac du fait que c’est un bruit blanc

III.2. Densité spectrale énergétique

D’après le résultat précédent :

Ryy k( ) 12

2x (pour k = 0) + 14

2x (pour k = 1) + 14

2x (pour k = -1)

Cette autocorrélation est la réponse impulsionnelle du filtre :

G(z) 12

14 z 1

Nous allons obtenir cette autocorrélation par cette méthode. La fonction de transfert de ce filtre est réalisée dans un nœud MathScript, sa réponse impulsionnelle sera réalisée par le VI CD Impulse Response.vi de la sous-palette Conception de contrôle et simulation Control Design Time Response.

Chapitre 22 / Traitement des signaux aléatoires

853

Nous retrouvons bien la même autocorrélation, sans l’échantillon dans le temps négatif qui correspond à une avance qui est non causale.

La réponse en fréquences de ce filtre constitue la DSP du signal de sortie. Dans le diagramme suivant, la fonction de transfert de l’autocorrélation Ryy(k) du signal de sortie du filtre est spécifiée dans un nœud MathScript. Grâce au VI CD Impulse Response.vi, nous obtenons la réponse impulsionnelle du filtre correspondant qu’on trace dans un graphe XY. Les valeurs de cette réponse impulsionnelle sont obtenues par désassemblage du cluster de Impulse Response Data. Après une indexation, une transposition et une autre indexation, nous calculons la FFT du tableau obtenu. Nous affichons le module de cette FFT dans un graphe et affichons ses valeurs dans le tableau abs(FFT). Nous calculons le minimum et le maximum de ce tableau afin de les comparer à ceux des autres méthodes de calcul de cette DSP.

Partie III / Applications

854

Dans le panel, nous affichons l’autocorrélation du signal de sortie, Ryy(k) et la DSP.

Nous allons calculer, dans le diagramme suivant, la réponse en fréquences, directement, à partir de la fonction de transfert. On considère un intervalle de pulsations normalisées wT allant de – à + dans lequel nous évaluons le module de la fonction de transfert correspondant à l’autocorrélation du signal de sortie du filtre. La DSP est calculée en évaluant la fonction de transfert du filtre dont Ryy(k) est la réponse impulsionnelle aux valeurs des pulsations précédentes.

Nous obtenons bien la même réponse en fréquences. Nous calculons quelques valeurs dont le minimum de 0.25 et le maximum de 0.75 qui sont les mêmes que précédemment. Nous trouvons la même courbe de la densité spectrale de puissance.

Chapitre 22 / Traitement des signaux aléatoires

855

La puissance du signal de sortie du filtre moyenneur, maximale pour w = 0, décroît avec la pulsation pour s'annuler à w .

IV. Systèmes et signaux stochastiques multidimensionnels

Un système discret d'ordre n, peut être décrit par le modèle d'état suivant :

x t A x t B u t w t( ) ( ) ( ) ( )1

y t Cx t v t( ) ( ) ( )

où x(t), u(t) et y(t) sont respectivement les vecteurs d'état, de commande et de sortie. Les vecteurs w t( ) et v t( ) représentent les bruits de modélisation et de mesure, leurs matrices de variances sont notées Q et R. On désire déterminer les caractéristiques statistiques de l'état x(t) et d'en déduire celles de la mesure y(t), dans le cas particulier où l'entrée est déterministe et centrée. D'après l'équation d'état, les valeurs moyennes de l'état et du signal de sortie sont :

x I A w( ) 1

y C I A w v( ) 1

La matrice de variances du vecteur du vecteur d'état étant :

Px t A Px t AT R( ) ( )1

celle du vecteur de sortie est : Py C Px CT R

Considérons le système discret suivant :

Il est décrit par le modèle d'état :

)()()()()1(

kxCkykwBkxAkx

avec

A05 10 02.

.,

10

B , 11C .

Les bruits de mesure v k( ) et de modélisation w k( ) , supposés gaussiens et centrés, possèdent respectivement les variances 0 et 2.

Partie III / Applications

856

IV.1. Evolution des états x1, x2 et signal de sortie du système

Dans le diagramme suivant, il s’agit de tracer l’évolution, dans le temps, des composantes d’état et de la sortie du système. Les matrices d’état A, B, C, sont spécifiées dans le cluster A-B-C. Le bruit de modélisation w est blanc, gaussien, centré. Pour suivre l’évolution dans le temps, des composantes x1 et x2 de l’état et de la sortie y, nous avons utilisé un nœud de rétroaction pour retarder le vecteur d’état.

Nous utilisons le VI AxB.vi pour effectuer le produit A x(k-1) auquel nous ajoutons la quantité B w(k).

La sortie y(k) est obtenue par un produit scalaire des tableaux C et x(k), réalisé par le VI Dot Product.vi. Ces 2 VIs d’opérations matricielles, se trouvent dans la sous-palette Mathématiques Algèbre linéaire. En dehors de la boucle, nous récupérons, par indexation, les 2 composantes d’état que nous traçons dans un même graphe XY.

Chapitre 22 / Traitement des signaux aléatoires

857

IV.2. Evolution des variances des composantes d’états et celle de la sortie

Dans ce diagramme, nous utilisons un nœud MathScript dans lequel nous utilisons les différentes opérations matricielles. La matrice P est initialisée à une valeur nulle. Le bruit de modélisation w, gaussien, blanc, centré et de variance 2, est généré par le VI Gaussian White Noise Waveform.vi. Le signal de sortie de ce VI est de type waveform. Pour récupérer le signal, nous utilisons la fonction Obtenir les composantes d’une waveform.

Dans le panel suivant, les valeurs, en régime permanent de ces différentes variances sont affichées dans les tableaux Px et Py.

V. Estimation de signaux et de modèles de systèmes discrets

V.1. Algorithme des moindres carrés récursifs

La méthode des moindres carrés récursifs est utilisée pour rechercher, en temps réel, un modèle numérique d'un processus physique ou d'un signal.

Partie III / Applications

858

Le principe consiste à minimiser un critère quadratique correspondant au carré de l'erreur, à l'instant courant, soit la différence entre la sortie du modèle et la valeur de la sortie du processus ou celle du signal que l'on veut modéliser. L'objectif est de minimiser un critère quadratique correspondant à la somme des carrées de l'écart entre la sortie réelle du processus à identifier et celle du modèle obtenu à chaque instant d'échantillonnage. Si un processus se comporte comme un système du premier ordre et présente un retard pur, il peut être modélisé par la fonction de transfert suivante :

y tu t

z b b za z

( )( )

( )11 2

1

11 1

La sortie à l'instant courant t est liée aux entrées-sorties précédentes par l'équation de récurrence suivante :

)2(2)1(1)1(1)( tubtubtyaty

que l'on peut exprimer sous forme d'un produit scalaire d'un vecteur paramètres ( )t et du vecteur des mesures précédentes ( )t 1 :

y t T t t( ) ( ) ( )1 avec

Ttututyt

bbat

)]2()1()1([)1(

]211[)(

Le critère quadratique à minimiser a pour expression :

Jt y k k T kk

t( ) ( ) ( ) ( )1

2 12

1

Le minimum du critère J est obtenu par le jeu de paramètres qui annule sa dérivée dans l'espace paramétrique.

dJtd y k k T k k T

k

t( )( ) ( ) ( ) ( )1 1

10

Ceci donne :

( ) ( ) ( ) ( )k y k kt

k Tt

kk1 1 1

11

soit

( ) ( ) ( ) ( ) ( )

( ) ( ) ( )

t k k Tk

tk y k

k

t

P t k y kk

t

1 11

11

1

11

La matrice P(t) correspond à la matrice de variances de l'erreur d'estimation.

P t k k T P t t t Tk

t( ) ( ) ( ) ( ) ( ) ( )1 1 1 1 1 1 1

1

Chapitre 22 / Traitement des signaux aléatoires

859

Le lemme d'inversion matricielle :

( ) ( )A BC D A A B C D A B D A1 1 1 1 1 1 1

permet d'obtenir la relation récursive de P(t).

P t P t P t t t T P tt T P t t

( ) ( ) ( ) ( ) ( ) ( )( ) ( ) ( )

1 1 1 1 11 1 1 1

A partir de l'expression précédente du vecteur paramètres ( )t , on peut aboutir à sa forme récursive.

( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )t P t k y k P t t y t k y kk

t

k

t1 1 1

1

1

1

d'où :

( ) ( ) ( ) ( ) ( ) ( )t P t P t t t y t1 1 1 1

or P t P t t t T( ) ( ) ( ) ( )1 1 1 1 1

On obtient l'expression finale de remise à jour du vecteur paramètres :

( ) ( ) ( ) ( )( ) ( ) ( )

( ) ( ) ( )t t P t t

y t T t t

t T P t t1 1

1 1

1 1 1 1

Pour exciter tous les modes du processus, on lui applique un signal riche en fréquences, proche d'un signal blanc. On choisit pour cela une séquence pseudo-aléatoire de longueur L. On décide d’appliquer cette méthode pour identifier le modèle du 1er ordre suivant :

y tu t

z b b z

a zz z

z( )( )

( ) ( . ).

11 2

1

1 11

1 1 05 1

1 08 1

Pour bruiter ce modèle, nous ajoutons un bruit blanc, gaussien, de variance unité, au signal de sortie de ce modèle afin de simuler un processus réel. Dans le diagramme suivant, les paramètres du processus sont mis dans le cluster Param_a1_b1_b2. Le calcul de la sortie du processus, par l’équation de récurrence suivante, est réalisé dans un nœud MathScript.

)2()1()1()( 211 kubkubkyaky Le signal qu’on ajoute à la sortie, est généré par le VI Gaussian White Noise Waveform.vi sous la forme waveform.

Partie III / Applications

860

Le signal pseudo-aléatoire qu’on applique au processus est généré par le VI SI Generate Pseudo-Random Binary Sequence.vi de la sous-palette Conception de contrôle et simulation System Identification Utilities. Pour avoir les valeurs retardées du signal de commande u et de sortie y, nous avons utilisé 2 registres à décalage. En sortie de la boucle For, nous avons assemblé les signaux de commande ou d’entrée u et de sortie y afin de les tracer dans le même graphe. Les signaux SBPA (Séquence binaire pseudo-aléatoire) d’entrée et le bruit en sortie sont entrés dans la boucle For avec le mode indexation afin qu’ils deviennent scalaires à l’intérieur de la boucle. Ce n’est pas le cas pour les paramètres a1, b1 et b2 qui ne changent pas de valeur dans le temps.

Dans le panel suivant, nous affichons le cluster des paramètres et traçons, dans le même graphe, le signal de commande binaire pseudo-aléatoire (SBPA) ainsi que le signal de sortie.

Chapitre 22 / Traitement des signaux aléatoires

861

Nous pouvions utiliser uniquement les nœuds MathScript qui aura comme entrés, les valeurs des paramètres a1, b1 et b2, le bruit v et le nombre N d’échantillons. Nous pouvons également utiliser une boite de calcul. Le signal SBPA sera généré à l’intérieur de ce nœud MathScript ou boite de calcul. Dans le diagramme suivant, nous utilisons le nœud MathScript pour générer la séquence SBPA de longueur 1023. Ce signal, binaire, riche en fréquences et de valeur moyenne nulle, permet de représenter un bruit blanc. La boucle For qui permet de générer cette séquence simule un registre à décalage dont le nombre de cellules N est lié à la longueur L de la séquence par L=2N-1. Avec N=10, nous avons une longueur de 210-1 = 1023, soit un registre à 10 cellules. On considère les valeurs suivantes des paramètres :

5.0,1,8.0 211 bba du modèle ARMA suivant :

11

121

11

1)()(

zazbbzzH

La matrice P de variances est initialisée à la valeur :

8

8

100010

P

et le vecteur paramètres est initialisé à 0. Le bruit v de mesures est un bruit blanc gaussien de variance unité.

Pour afficher les valeurs finales du vecteur, nous faisons l’indexation du tableau correspondant avec un indice correspondant à sa taille -1. Dans le panel, nous affichons le signal d’entrée SBPA et le signal de sortie correspondant. Les paramètres sont définis dans le cluster Param_a1_b1_b2.

Partie III / Applications

862

L’évolution des paramètres identifiés, à partir des valeurs initiales nulles, est représentée par le graphe Graphe_paramètres. Nous affichons dans l’indicateur valeurs_finales les dernières valeurs du vecteur paramètres.

Le diagramme suivant permet uniquement de tracer l’évolution des paramètres et le signal de sortie du modèle ARMA. L’intérêt de ce diagramme est uniquement académique en ce sens qu’il utilise un nœud MathScript pour effectuer l’identification des paramètres. Les séquences SBPA sont calculées dans une boite de calcul. Le bruit de mesure v est défini dans un nœud de script MATLAB.

Chapitre 22 / Traitement des signaux aléatoires

863

Dans le panel, nous affichons la commande cluster dans lequel on spécifie les valeurs des paramètres à identifier, la courbe du signal de sortie et celle de l’évolution des paramètres à identifier ainsi que l’indicateur des valeurs finales de ces paramètres.

Nous allons identifier un modèle du 2nd ordre de gain statique unité. Ce modèle a été

vérifié en utilisant le module Conception de contrôle et simulation.(Il est conseillé de consulter la partie II).

Pour définir ce système, nous utilisons la fonction de transfert discrète avec Discrete Tranfer Function.

La valeur de cette fonction de transfert est définie dans un nœud MathScript grâce à la commande tf qui reçoit le numérateur, le dénominateur et la période d’échantillonnage de 0.01s.

Nous appliquons un échelon à cette fonction de transfert. Ce signal d’entrée et celui de sortie sont tracés dans le même graphe XY grâce au bloc Collector qui leur associe le temps de simulation.

Avec le VI CD Draw Transfer Function Equation.vi, nous affichons cette fonction de transfert.

Pour tracer plusieurs signaux, nous les assemblons grâce à la fonction Construire

un tableau.

Partie III / Applications

864

Le panel affiche les signaux d’entrée/sortie et l’équation de la fonction de transfert que nous allons identifier.

Dans le diagramme suivant, la matrice de variances P est spécifiée dans le panel. Le VI s’adapte automatiquement au nombre de paramètres pour peu que le modèle soit stable. En effet, le nombre de paramètres, défini par l’entrée np du nœud MathScript est la taille du tableau qui provient de la transformation du cluster a1_a2_b1_b2 par la fonction Cluster en tableau. Le bruit blanc gaussien centré est généré par le VI Gaussian White Noise Waveform.vi, le VI PRBS produit une séquence SBPA de longueur 127. La matrice de variance P, initialisée à la matrice carrée 4x4 de valeur 108 I, avec I la matrice identité.

Le panel affiche le signal d’entrée SBPA, la sortie du modèle ainsi que l’évolution des paramètres identifiés. Nous affichons la matrice P et le cluster des paramètres du modèle ainsi que les paramètres en fin d’identification qui sont très proches de ceux qu’on a spécifiés.

Chapitre 22 / Traitement des signaux aléatoires

865

Dans ce diagramme, nous nous intéressons à l’étude des statistiques (moyenne, variance, histogramme, etc.). Comme précédemment, la génération des séquences SBPA et l’estimation des paramètres se font dans le nœud MathScript. Les sorties de ce nœud MathScript (la sortie y du modèle ARMA, les séquences SBPA d’entrée et le nombre d’échantillons N) sont transmises à la boucle For. Dans la boucle For nous disposons d’une boite de calcul dans laquelle nous calculons la sortie du modèle final identifié. L’entrée de ce modèle est formée des mêmes séquences SBPA qui ont servi à l’identification. Les valeurs finales proviennent de la lecture d’une variable locale dans laquelle nous avons enregistré ces valeurs finales, obtenues par l’indexation du vecteur theta. Nous avons calculé la différence entre les 2 sorties et pour laquelle nous allons définir les statistiques.

Avec le VI Std Deviation and Variance.vi, nous calculons la moyenne et la variance de cette erreur, que nous affichons dans le cluster moy_var. L’histogramme est obtenu par le VI, de type Express, Créer un histogramme. La matrice d’autocorrélation, dont l’élément (1,1) correspond à la variance, est obtenue par le VI AutoCorrelation Matrix.vi. La fonction d’autocorrélation, permettant si l’erreur peut être assimilée à un bruit blanc, est obtenue par le VI TSA Autocorrelation Function.vi de la sous-palette Traitement du signal Time Series Analysis Correlation and Spectral Analysis.

Le coefficient du Kurtosis (applatissement) et du Skewness (asymétrie) sont calculés par le VI Skewness and Kurtosis.vi de la sous-palette Probabilités et Statistiques.

Partie III / Applications

866

Dans le panel, nous affichons la courbe de l’évolution des paramètres, l’histogramme de l’erreur ainsi que sa fonction d’autocorrélation. Nous déduisons que cette erreur est proche d’un bruit blanc et qu’elle est d’une distribution gaussienne. Nous affichons également les valeurs finales des paramètres, le cluster de la moyenne et de la variance. La variance est bien le 1er élément de la matrice d’autocorrélation. La valeur du coefficient du Kurtosis, de 2.77913 est proche de 3, la valeur significative d’une distribution gaussienne. La dissymétrie de -0,0623354 montre que cette distribution est bien symétrique telle la loi de Gauss.

V.2. Filtrage de Kalman

Le filtre de Kalman permet de déterminer l'état x t( ) d'un système dynamique à partir de ses entrées-sorties (connaissance a posteriori) et de son modèle d'état (connaissance a priori). L'estimation de l'état s'effectue en minimisant la variance de l'erreur d’estimation ~( )x t .

E x t T x t E x t x tT

x t x t~( ) ~( ) ( ) ( ) ( ) ( )

Le modèle d'état est décrit par les 2 équations suivantes :

x t Ax t Bu t w ty t C x t v t( ) ( ) ( ) ( )( ) ( ) ( )

1

w t( ) est le bruit d'état ou de modélisation et v t( ) celui de la mesure. Ces bruits traduisent respectivement l'incertitude que l'on a sur le modèle et le bruit du capteur de mesure. Ces bruits sont supposés gaussiens, blancs, centrés et décorrélés.

Chapitre 22 / Traitement des signaux aléatoires

867

E w t T w t k Q t k( ) ( ) ( ) ( ) ( )k : symbole de Kronecker

Q t( ): Matrice de variances du vecteur w t( )

E w t T v t( ) ( ) 0 , E v t Tv t k R t k( ) ( ) ( ) ( )

R t( ) : Matrice de variances du bruit. Si les bruits sont stationnaires, leurs matrices de variances, notées Q et R., sont indépendantes du temps. L'estimation récurrente de l'état peut se décomposer en 2 étapes, comme le montre le dessin suivant.

TU

t-1 t

MU

/xt t1 1 /xt t 1 /xt tPt t1 1/ Pt t/ 1 Pt t/

Etape TU (Time Update)

Correspond à l'évolution de l'état entre 2 périodes d'échantillonnage.

/ / ( )xt t A xt t Bu t1 1 1

En l'absence de mesures, l'incertitude augmente, en effet, la matrice P de variance de l'erreur d'estimation augmente.

Pt t E x t xt tT

x t xt t A Pt t AT Q/ ( ) / ( ) / /1 1 1 1 1

Etape MU (Measurement Update)

L'état est remis à jour à la suite de la lecture de la sortie du système.

/ / ( ) ( ) /xt t xt t K t y t C xt t1 1

L'écart, entre la sortie mesurée et celle prédite par le modèle, est multiplié par le gain K(t) pour s'ajouter à l'état précédent pour sa remise à jour. La matrice de variances de l'erreur d'estimation décroît pendant cette étape de remise à jour puisque l'apport d'une nouvelle information se traduit par une meilleure connaissance de l'état.

Pt t Pt t Pt t CT R C Pt t CT C Pt t/ / / / /1 1 11

1

Partie III / Applications

868

Le gain d'adaptation K(t) est donné par

K t Pt t CT R C Pt t CT( ) / /1 11

V.2.1. Estimation d'une constante

Une grandeur constante x est mesurée au moyen de deux capteurs 1 et 2 qui mesurent les 2 composantes du vecteur y. Les mesures délivrées par les capteurs 1 et 2 sont de qualités différentes, de variances 1 et 4 respectivement. Le modèle d'état correspondant est alors

x(k 1) x(k)y(k 1) C x(k) v(k)

avec C11

.

Les bruits v1 et v2 sont considérés blancs, gaussiens, centrés et indépendants.

E v(k)

E v(k) vT(k) R

01 00 4

La matrice de transition A étant une matrice identité, il n'y a pas dans ce cas d'étape TU pour l'état. Comme il n'y a pas de bruit de modélisation, la matrice P de variances ne varie pas dans l'étape TU.

Dans le diagramme suivant, les 2 mesures bruitées, de la même constante à estimer, sont des bruits blancs gaussiens, respectivement de variance 1 et 4 auquels on ajoute la même constante 5.

Les 2 variances sont recalculées par le VI Std Deviation and Variance.vi. Les calculs de l’étape MU du filtre de Kalman sont effectués dans un nœud MathScript. La matrice de variance P est initialisée à la valeur 1, l’état à 0. Les sorties du nœud MathScript sont la matrice P que nous affichons dans l’indicateur P. La valeur finale de l’état estimé est obtenue par indexation comme étant la dernière valeur du tableau (indice égal à taille -1), l’état estimé x, les sorties bruitées et la constante initiale à estimer. L’erreur d’estimation, que nous affichons dans l’indicateur erreur et que nous traçons dans le graphe Erreur, est calculée comme étant la différence entre l’état estimé et la constante. Le VI Std Deviation and Variance.vi permet de calculer la moyenne et la variance de cette erreur. L’histogramme est obtenu par le VI, de type Express, Créer un histogramme. Nous affichons également les valeurs finales des paramètres, le cluster de la moyenne et de la variance.

Chapitre 22 / Traitement des signaux aléatoires

869

Dans le panel, nous affichons la courbe de l’évolution de l’état et l’histogramme de l’erreur. Nous déduisons que cette erreur est proche d’un bruit blanc et qu’elle est d’une distribution gaussienne. Nous affichons également les 2 mesures bruitées, l’évolution de l’état, la variation de la matrice P, l’histogramme de l’erreur et la courbe de cette erreur. Les valeurs de cette dernière sont affichées dans le tableau erreur. Sa moyenne et sa variance sont très faibles.

V.2.2. Estimation de l'état d'un processus dynamique

V.2.2.1. Modèle d’état continu et discret d’un moteur à courant continu

On suppose que l'on dispose du modèle du processus discrétisé, c'est-à-dire que l'on connaît les matrices A, B et C du modèle interne suivant :

x t Ax t B u t w tt C x t v t

( ) ( ) ( ) ( )( ) ( ) ( )

1y

Partie III / Applications

870

On a besoin d'estimer l'état du processus pour différentes raisons, entre autres, parce que les différentes composantes sont intéressantes du point de vue physique et que l'on ne connaît pas de capteurs susceptibles de fournir l'information ou bien que les capteurs sont trop chers ou peu fiables. On considère un processus constitué d'un moteur à courant continu pour lequel on dispose d'un capteur pour mesurer la position angulaire. Le filtre de Kalman servira à estimer en temps réel la vitesse angulaire sans avoir à utiliser de capteur spécifique. On considère le modèle analogique du moteur à courant continu, ayant comme entrées-sorties, la position angulaire ( )t et la tension u t( ) appliquée à son induit.

( )( ) ( )p

U pk

p p a

Avec a = 1 et k = 0.32, le modèle suivant permet de ressortir la vitesse et la position de l'arbre moteur.

En posant,

x t t1( ) ( ) : Vitesse

x t t2( ) ( ) : Position

On en déduit le modèle d'état analogique :

)()()(32.0)()(

12

11

txtxtutxtx

.x (t)

x (t)

x (t)

x (t) u(t) Ax (t)

x (t) B u(t)1

2

1 0

1 01

2

0 32

01

2

Le signal de sortie étant identique à la 2ème variable d'état, l'équation d'observation est :

)()()(

)(0)()(

10)()(

2

1

2

12

tuDtxtx

C

tutxtx

txty

Dans le nœud MathScript, nous définissons la fonction de transfert continue précédente en utilisant la commande tf.

Chapitre 22 / Traitement des signaux aléatoires

871

A l’aide du VI CD Draw Transfer Function Equation.vi nous affichons l’équation de cette fonction de transfert. Cette fonction de transfert est convertie en modèle d’état par le VI CD Convert to State-Space Model.vi de la sous-palette Conception de contrôle et simulation Control Design Model Conversion. Nous obtenons un modèle d’état dont la matrice A est identique à celle que nous avons calculée précédemment mais dont les matrices B et C sont différentes. Pour un même système, le modèle d’état n’est pas unique mais plusieurs modèles d’état sont similaires. A l’aide du VI CD Similar State-Space Models.vi, nous déduisons que ces 2 modèles d’état sont similaires par l’état (valeur logique 1) de la LED Similar ?. La discrétisation de ce modèle d’état à la période d’échantillonnage T=0.2s se fait à l’aide du VI CD Convert Continuous to Discrete.vi. Ce VI polymorphe peut être utilisé également pour discrétiser une fonction de transfert en affichant TF.

Dans le panel, nous affichons les équations de la fonction de transfert et du modèle d’état continus ainsi que le modèle d’état discret obtenu par discrétisation à T=0.2s ainsi que la fonction de transfert discrète équivalente. La LED indiquant la similitude des 2 modèles d’état s’allume en recevant la valeur binaire ou logique 1. Les modèles d’état similaires ne sont pas égaux mais ils ont la même matrice d’évolution A car ses valeurs propres qui sont les pôles du système doivent être les mêmes.

Partie III / Applications

872

Dans la suite, on appliquera au système un signal de commande carré. On suppose que l'on dispose d'un capteur de position qui fournit la valeur du signal de sortie à chaque période d'échantillonnage. Le filtre de Kalman permettra de fournir une estimation de la vitesse angulaire. Pour simuler la mesure de la position, on a besoin du modèle discret du processus. Dans le diagramme suivant, nous utilisons une boucle For pour générer le bruit gaussien de mesures ainsi que la tension d’induit du moteur. Dans la boucle For du nœud MathScript, nous calculons la sortie (position angulaire) non bruitée en utilisant la fonction de transfert discrète. On ajoute le bruit généré dans la boucle For à ce signal pour obtenir la sortie bruitée utilisée dans l’algorithme de Kalman. Nous calculons la position estimée par le filtre de Kalman à partir de l’état estimé. Nous traçons, dans le même graphe, la position bruitée, celle non bruitée et celle estimée par le filtre de Kalman.

V.2.2.2. Extraction d'une sinusoïde noyée dans du bruit

Un signal sinusoïdal est généré par une équation différentielle du 2nd ordre dans les domaines, analogique et discret. Le modèle d'état est ainsi du second ordre. La première composante d'état x t1( ) est le signal à estimer. Le choix de la seconde composante d'état n'est pas imposé.

Chapitre 22 / Traitement des signaux aléatoires

873

Considérons le signal sinusoïdal suivant : y t a wt( ) cos La deuxième composante d'état est du type : x t a wt2( ) sin Ce choix n'est pas limitatif, mais une fois imposé, la matrice de transition est unique. Si T désigne la période d'échantillonnage, nous avons, avec a = 1 :

wtwTwtwTTtwTtxwtwTwtwTTtwTtx

sincoscossin)(sin)(sinsincoscos)(cos)(

2

1

Le modèle d'état est alors :

x t Ax ty t C x t( ) ( )( ) ( )

1 ,

avec

wTcoswTsinwTsinwTcos

A , 01C

Il n 'y a pas de bruit de modélisation car on cherche un type de signal déterminé dont on connaît parfaitement la valeur de la pulsation. On considère dans ce cas particulier, un signal sinusoïdal de pulsation w 2 5/ , échantillonné à la cadence T s01. .

Dans le 1er nœud MathScript, nous spécifions la sinusoïde de pulsation 5/2w , échantillonnée à la période 1.0T et à laquelle on ajoute un bruit blanc gaussien de variance unité.

Dans le 2ème nœud, nous mettons en œuvre le filtre de Kalman avec les matrices d’état ci-dessus et les équations du filtre de Kalman avec sa seule étape TU.

Nous affichons l’état x et la sinusoïde non bruitée pour comparaison. En utilisant la fonction Sous-ensemble d’un tableau, nous affichons les 20 dernières valeurs de ces signaux. Ces 2 signaux sont affichés en régime transitoire (0-100) et permanent (4080-5000).

Partie III / Applications

874

Nous affichons également l’erreur entre le signal estimé par le filtre de Kalman et la sinusoïde non bruitée. Nous calculons sa moyenne et sa variance en utilisant le VI Std Deviation and Variance.vi de la sous-palette Mathématiques Probabilités et Statistiques.

Les coefficients du Kurtosis (applatissement) et du Skewness (asymétrie) sont calculés par le VI Skewness and Kurtosis.vi de la sous-palette Probabilités et Statistiques. La fonction d’autocorrélation de cette erreur est calculée par le VI TSA Auto-correlation Function.vi de la sous-palette Traitement du signal

Time Series Analysis Correlation and Spectral Analysis.

Dans le panel suivant, nous affichons la sinusoïde bruitée, la sortie du filtre de Kalman (sinusoïde estimée) avec son régime transitoire (0 à 100) et son régime permanent (4080 à 5000). En régime permanent, la sortie estimée suit, de façon quasi-parfaite, la sinusoïde non bruitée.

L’erreur d’estimation, sinusoïdale de même fréquence que la sinusoïde à estimer, n’est pas vraiment un bruit blanc au vu de son corrélogramme. L’erreur n’est pas gaussienne au vu de la valeur de son Kurtosis, différent de 3 qui est la valeur significative d’une gaussienne. La moyenne et la variance de cette erreur sont nulles.

Chapitre 22 / Traitement des signaux aléatoires

875

V.2.2.3. Extraction d’une exponentielle noyée dans du bruit

V.2.2.3.1.Filtre de Kalman sans bruit de modélisation

Prenons le cas d’une exponentielle amortie :

tetx )(

Lorsqu’on échantillonne ce signal à une cadence T, sa transformée en z a pour expression :

111)(

zezX T

Ainsi, le modèle d’état est :

)()()()()()1(

tvtxtytwtxatx

avec Tea Dans le cas scalaire du filtre de Kalman, les équations régissant les 2 étapes successives TU et MU sont :

Rttxattx )1/1(ˆ)1/(ˆ

QttPattP )1/1()1/( 2

La remise à jour du gain K est donnée par :

RttPttPtK

)1/()1/()(

La matrice de variance est mise à jour comme suit :

)1/()()1()( ttPtKtPtP

La matrice P décroît au fur et à mesure que les nouvelles mesures sont exploitées. L’état est mis à jour à chaque acquisition d’une mesure y(t) à laquelle on retranche l’état estimé pour constituer l’innovation )1(ˆ)( txty que l’on multiplie par le gain )(tK .

)1(ˆ)()()1(ˆ)(ˆ txtytKtxtx Dans le diagramme suivant, nous spécifions l’exponentielle amortie avec un coefficient d’amortissement de 0.2. Cette courbe est échantillonnée à la période T=0.1s. Nous lui ajoutons un bruit blanc gaussien de variance unité qui est le bruit de mesure v(t).

Partie III / Applications

876

Nous affichons l’exponentielle bruitée, l’état du filtre de Kalman et l’exponentielle non bruitée pour comparaison. L’état du filtre, après un régime transitoire, suit l’exponentielle non bruitée. La moyenne et la variance de l’erreur entre le signal estimé par le filtre de Kalman et l’exponentielle non bruitée sont calculées en utilisant le VI Std Deviation and Variance.vi de la sous-palette Mathématiques Probabilités et Statistiques.

A part, lors du régime transitoire, l’erreur est toujours positive. Pour cela, la valeur du Kurtosis montre qu’elle n’est pas gaussienne et celle du Skewness indique qu’elle n’est pas symétrique car toujours positive.

La fonction d’autocorrélation de cette erreur est calculée par le VI TSA Auto-correlation Function.vi de la sous-palette Traitement du signal Time Series Analysis Correlation and Spectral Analysis.

Dans le panel suivant, nous affichons l’exponentielle bruitée et la sortie du filtre de Kalman (l’exponentielle estimée). A partir de l’instant discret 10, la courbe estimée par le filtre coïncide avec l’exponentielle non bruitée. L’élément P(1,1) de la matrice de variances P décroît très rapidement vers 0. La moyenne et la variance de l’erreur d’estimation sont très faibles. Les valeurs du Kurtosis et du Kurtosis montrent que sa distribution n’est ni gaussienne ni symétrique. Le corrélogramme de cette erreur ressemble à une impulsion de Dirac qui signifie que cette erreur est proche d’un bruit blanc.

Chapitre 22 / Traitement des signaux aléatoires

877

V.2.2.3.2. Modèle d’état et fonction de transfert équivalents

Dans le diagramme suivant, créons, dans le nœud MathScript, la fonction de transfert suivante :

111)(

zezX T

ainsi que le modèle d’état équivalent :

)()()()()1(

txtytutxatx

Les matrices de ce modèle d’état sont alors les scalaires suivants :

0,1,1, DCBaA La courbe exponentielle précédente correspond à la réponse impulsionnelle d’un système défini par la fonction de transfert ou le modèle d’état ci-dessus. Grâce au VI CD Draw Transfer Function.vi ou CD Draw State-Space Equation.vi, nous affichons l’équation de la fonction de transfert discrète ou du modèle d’état. La réponse impulsionnelle est obtenue à la sortie Impulse Response Graph du VI CD Impulse Response Graph.vi. Nous devons choisir Transfer Function (TF) ou State-Space (SS) dans le menu polymorphe de ce VI.

Partie III / Applications

878

Nous obtenons, dans les deux cas, la même courbe exponentielle amortie que l’exponentielle non bruitée dans l’exemple du filtre de Kalman.

V.2.2.3.3. Filtre de Kalman avec bruit de modélisation

Si le modèle exponentiel n’est pas certain, on lui associe un bruit de modélisation avec sa matrice de variance Q. Dans l’étape TU, la remise à jour de la matrice de variance P, dans notre cas scalaire, se fait selon l’expression suivante :

QiPaiP )1()( 2 Dans le nœud MathScript du diagramme, nous générons un bruit blanc ainsi qu’une exponentielle amortie à laquelle on ajoute ce bruit. La matrice scalaire Q de variances du bruit de modélisation est choisie égale à 0.001. La matrice du bruit de mesure R est la variance du bruit de mesure. Dans une boucle For, nous programmons les étapes TU et MU.

Chapitre 22 / Traitement des signaux aléatoires

879

La courbe estimée par Kalman oscille de part et d’autre de l’exponentielle non bruitée.

VI. Régime permanent du filtre de Kalman

Le filtre de Kalman possède un régime permanent qui correspond à un filtre numérique à coefficients invariants. Le régime permanent consiste à poser :

PttPttP )1/1()/( (matrice après la mesure)

et

PttPttP )2/1()1/( (matrice avant la mesure)

Dans le cas du modèle du 1er ordre précédent, on obtient :

PRPRP

QPaP 2

Partie III / Applications

880

En substituant P par son expression dans celle de P qu’on notera P , nous obtenons l’équation :

0222 QRaRQRPPa

C’est une équation du 2nd degré dont la solution positive est donnée par l’expression :

2

2222

24))1(()1(

aQRaQaRQaR

P

Cette solution n’existe que s’il y a une incertitude sur le modèle à savoir 0Q . Dans le cas contraire la solution serait :

2

2

2)1(

aaRP

Ceci n’est pas réaliste car la matrice serait négative puisque pour les signaux et systèmes stables on a toujours .1a On se propose de déterminer l’équation de récurrence liant l’état )/( ttx à l’état précédent )1/1( ttx . Etape TU : )1/1()1/( ttxattx

Etape MU : )1/()()1/()/( ttxtyKttxattx

Si l’on note )/()( ttxtx et )1/1()1( ttxtx et si on élimine )1/( ttx dans l’équation de l’étape MU par son expression donnée par celle extraite de l’étape TU, nous obtenons :

)1()()1()( txatyKtxatx

Nous obtenons ainsi la fonction de transfert liant l’état estimé )(tx au signal bruité )(ty :

1)1(1)()(

zKaK

zYzX

C’est un filtre du premier ordre de type passe-bas. Avec le fichier kalman_permanent.m, on refait l’estimation du même signal exponentiel décroissant. fichier kalman_permanent.m close all T=0.1; % période d'échantillonnage de 0.1 s t=0:T:30; % temps d'estimation % bruit de mesure de variance 1 v=randn(size(t)); % variance du bruit de mesure R=std(v)^2; % signal à extraire alpha=0.2; y1=exp(-alpha*t); % mesure bruitée y=y1+v; a=exp(-alpha*T); % matrice d'évolution

Chapitre 22 / Traitement des signaux aléatoires

881

Q=0.001; % variance du bruit de modélisation non nul % ====================filtre de Kalman % matrice de variance en régime permanent P=(R*(a^2-1)-Q+sqrt((R*(a^2-1)-Q)^2+4*a^2*R*Q))/(2*a^2); % gain d'adaptation permanent K=(a^2*P+Q)/(a^2*P+Q+R); % programmation du filtre à coefficients invariants num=K; den=[1 -a*(1-K)]; z=filter(num,den,y); % affichage de l'état estimé et du signal pur h=plot(t,z); set(h,'linewidth',2), hold on, plot(t,y1) title('Exponentielle non bruitée et sortie du filtre de

Kalman permanent') xlabel('temps discret');

Les valeurs des paramètres P et K sont :

La sortie du filtre oscille autour de l’exponentielle non bruitée à partir de l’instant t=6 environ.

Partie III / Applications

882

VII. Prédicteur de Kalman

L’algorithme permet de prédire l’état de l’instant t avant la mesure, soit )1/(ˆ ttx , à partir de l’état de l’instant (t-1) avant la mesure )2/1(ˆ ttx . Le prédicteur de Kalman réalise successivement les opérations MU puis TU. Dans le cas d’un système régi par des équations d’état, nous avons :

Etape MU

Remise à jour de l’état à l’instant (t-1), étape MU de l’instant (t-1)

)2/1(ˆ)1()2/1(ˆ)1/1(ˆ 1 ttxCtyKttxttx t

Calcul du gain K(t-1)

11 )2/1()2/1( CttPCRCttPK T

t

Mise à jour de la matrice de variances P

)2/1()2/1()2/1()2/1()2/1()2/1()1/1(

1

1

ttPCKttPttPCCttPCRCttPttPttP

Tt

TT

Etape TU

Evolution de l’état x

)2/1(ˆ)1()1/1(ˆ)1/(ˆ 1 ttxCtyKttxAttx t

Evolution de la matrice P

TAttPAttP )1/1()1/(

Considérons un cas scalaire d’un cosinus amorti wte ta cos , échantillonné à la cadence T. Sa fonction de transfert en z est :

)(cos21

)cos1()( 221

11

zezwTez

wTezzzX aTaT

aT

)(z = 1 : transformée en z de l’impulsion de Dirac.

Avant d’utiliser le prédicteur de Kalman, nous allons étudier plusieurs méthodes déterministes pour générer le cosinus amorti en sortie de cette fonction de transfert lorsqu’on lui applique une impulsion de Dirac à l’entrée.

Chapitre 22 / Traitement des signaux aléatoires

883

VII.1. Génération du signal par la fonction de transfert - Nœud MathScript

La fonction de transfert ci-dessous relie le signal de sortie à l’impulsion de Dirac d’entrée. Dans le diagramme suivant, nous utilisons un nœud MathScript dans lequel nous calculons la réponse impulsionnelle discrète de cette fonction de transfert. Nous définissons le numérateur et le dénominateur en fonction des paramètres a, T et w qu’on a spécifiés auparavant et on détermine la réponse impulsionnelle discrète grâce à la commande dimpulse.

Dans le panel, nous traçons cette réponse impulsionnelle ainsi que l’enveloppe exponentielle dans le même graphe XY.

VII.2. Génération du signal par l’équation de récurrence - Boite de calcul

Partir de la fonction de transfert précédente, nous pouvons déduire l’équation de récurrence suivante :

)2()cos()1()2()1()(cos2)( 2 nwTennxenxwTenx aTaTaT Nous avons utilisé une boite de calcul dans laquelle nous avons programmé cette équation de récurrence. Nous avons créé 2 registres à décalage afin d’obtenir les valeurs précédentes de l’instant courant,, soit x(n-1), x(n-2) du signal de sortie ainsi que )1(n et )2(n de l’impulsion de Dirac du signal d’entrée. Ces registres à décalage sont créés dans une boucle For allant de 0 à 300. Le pas i, entier, a été divisé par 10 afin d’obtenir le même pas égal à T=0.1s. Dans une boite de calcul, nous devons définir, comme en langage C, le type des variables utilisés dans les calculs, qui ne soient pas des variables d’entrée du nœud, comme a, T ou w. Nous avons appliqué, à l’entrée uk, une impulsion de Dirac d’amplitude 1.

Partie III / Applications

884

Nous avons obtenu, comme précédemment, un cosinus amorti.

VII.3. Génération du signal par le modèle d’état

Dans cet exemple, nous allons utiliser l’outil Conception de contrôle et simulation pour programmer le modèle d’état qui modélise le même système qui permet de générer un cosinus amorti. A partir de l’équation de récurrence précédente, nous avons:

)1()cos()*exp()()1()(cos2)1( 2 nwTTantxetxwTetx aTaT

En posant : )()(1 nxnx et )()(2 nnx

Chapitre 22 / Traitement des signaux aléatoires

885

Le système d’état devient :

)()*cos()()1(

)()()()cos(2)1(

12

2

211

nTwenxenx

nnxnxwTenx

aTaT

aT

d’où les matrices d’état suivantes :

01)cos(2

2aT

aT

ewTe

A , )()*cos(

1n

TweB Ta , 01C , 0D

Dans le diagramme suivant, nous avons spécifié les matrices d’état et utilisé ensuite la commande ss, dans un nœud MathScript, pour créer le système d’état discret avec une période d’échantillonnage T=0.1s. Dans la boucle de simulation, nous avons utilisé le bloc Discrete State-Space pour définir le modèle d’état discret. En double cliquant sur ce bloc, nous spécifions la valeur Terminal pour Parameter source. Ceci permet de créer l’entrée supplémentaire State-Space à laquelle nous appliquons le modèle d’état créé dans le nœud MathScript. Nous utilisons le VI Impulse Pattern.vi pour appliquer une impulsion à ce modèle d’état pour obtenir, comme précédemment, la réponse impulsionnelle. Le bloc Collector permet d’associer au signal de sortie, le temps de simulation. Ce qui permet d’afficher le signal de sortie, en fonction du temps, dans un graphe XY. Dans le nœud d’entrée, Input Node, nous avons spécifié la valeur 30 pour le temps final ainsi que la valeur 0.1 pour le pas de temps.

Partie III / Applications

886

Nous obtenons, comme dans les cas précédents, un signal sous la forme d’un cosinus amorti. Dans ce panel, nous affichons les valeurs du modèle d’état grâce au VI CD Draw State-Space Equation.vi.

VII.4. Génération du signal par le prédicteur de Kalman

La matrice d’évolution est la suivante :

01cos2

2aT

aT

ewTe

A

Celle d’observation est : ]01[C . Dans le script suivant, nous programmons les étapes TU et MU du prédicteur de Kalman, étudié précédemment. fichier pred_cos_amorti.m close all % période d'échantillonnage de 0.1 s et pulsation T=0.1; w=2; t=0:T:30; % temps d'estimation % bruit de mesure de variance 1 v=randn(size(t)); R=std(v)^2; % variance du bruit de mesure % y1 : non bruité, y : signal bruité y1=cos(w*t).*exp(-a*t); y=y1+v; % affichage du signal avec et sans bruit figure(1) plot(t,y), hold on h=plot(t,y1) set(h,'linewidth',2), title('Cos bruité et non bruité'); % matrice d'évolution A = [2*exp(-a*T)*cos(w*T) 1; -exp(-2*a*T) 0];

Chapitre 22 / Traitement des signaux aléatoires

887

C = [1 0]; n=2; % ordre du système % initilalisation de la matrice P P = [100 0;0 100]; % initialisation de l'état x=zeros(n,length(t)); for i=2:length(t) % Prédicteur de Kalman % Etape MU K=P*C'/(R+C*P*C'); x(:,i)=x(:,i-1)+K*(y(i)-C*x(:,i-1)); P=P-K*C*P; % Etape TU x(:,i)=A*x(:,i); P=A*P*A'; end figure(2) h=plot(t,x(1,:)); set(h,'linewidth',2); hold on, plot(t,y1) axis([0 30 -2 2]) title('Cos non bruité et sortie du prédicteur') % Traitement de l'erreur err=y1-x(1,:); figure(3), stem(err) title('erreur de prédiction') correl=xcorr(err); figure(4), stem(correl) title('Autocorrélation de l''erreur') figure(5), hist(err,100) title('histogramme de l''erreur') La figure Tracé 1 montre le cosinus amorti et celui auquel on a ajouté un bruit blanc gaussien de variance unité. Dans Tracé 2, nous affichons l’évolution de l’état du prédicteur de Kalman et le cosinus non bruité. Le signal prédit se confond au fur et à mesure avec le signal non bruité.

Partie III / Applications

888

La figure Tracé 3 affiche l’erreur de prédiction. Dans Tracé 4, nous traçons l’autocorrélation de cette erreur.

La fonction d’autocorrélation est proche de celle d’un bruit blanc.

L’histogramme qu’on trace ci-après est gaussien. Ceci valide une bonne qualité de l’estimation du signal par le prédicteur de Kalman.

Références bibliographiques

A. Angot, “ Compléments de mathématiques ”, Editions de la revue d'optique, 1952

A. Angot, “Compléments de mathématiques”, Editions de la revue d'optique, 1952

A. V. Oppenheim, “Digital signal processing”, Prentice Hall International, 1975

B. Porat, “Digital Processing of Random Signals, Theory & Methods”, Editions Prentice Hall Information and system sciences series, 1993

C. Burgat, “Automatique, Problèmes résolus d’automatique”, Ed. Ellipses, 2001. C. Johnson, “Process control instrumentation technology”, Ed. Prentice-Hall International, 1988

C. Marven & Gillian Ewers, “A simple approach to Digital Signal Processing”, Texas Instruments, 1993

C. S. Burrus, “Computer-Based Exercises for Signal Processing using MATLAB”, Ed. Prentice Hall International, 1994.

D. Stamps, “Learn LabVIEW 2010/2011 Fast, A Primer for Automatic Data Acquisition”, Ed. SDC Publications, 2012

E. Angel, “Computer Graphics”, Addison-Wesley, 1990

F. Cottet, “Traitement des signaux et acquisition de données”, Ed. Dunod, 1997

F. Cottet, “LabVIEW Programmation et applications”, Ed. Dunod, 2001

F. Cottet, M. Pinard, “LabVIEW Programmation et applications”, Ed. Dunod, 2009

G. Asch et al., “Les capteurs en instrumentation industrielle”. Dunod, 1991

G. Baillargeon, “Méthodes statistiques”, Editions SMG, 1984

G. Johnson, “LabVIEW Graphical Programming, Practical Applications in Instrumentation and Control”, Ed. McGraw Hill, 1997

H. Anton, “Elementary Linear Algebra”, Wiley, 1984

H. T. Nguyen, “Theoritical Aspects of Fuzzy Control”, Editions John Willey & Sons, Inc., 1995

J. C. Gille, M. Clique, “Systèmes linéaires, équations d'état”, Ed. Eyrolles, 1990

J. Jerome, “Virtual Instrumentation Using LabVIEW”, PHI Learning Pvt. Ltd., 2010

DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 ,889N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

890 Références bibliographiques

J. Y. Beyon, “Hands-on Exercise Manual for LabVIEW Programming, Data Acquisition and Analysis with CD-ROM”. Ed. Prentice Hall, 2000

J.P. Benzécri, “Pratique de l’analyse des données”. Analyse des correspondances, exposé élémentaire, Dunod, Paris, 1980.

K J. Aström, B. Wittenmark, “Computer-controlled systems”, Theory and design, Prentice-Hall International Editions, 1984

L. B. Jackson, “Digital Filters and Signal Processing”, Third Edition, 1996

L. Jézéquel, “Active control in mechanical engineering”, Hermès, 1995

M. Bellanger, “Traitement numérique du signal, Théorie et pratique”, Ed. Masson, 1996

M. Bonvalet, Les principes de la mécanique, Ed. Masson, 1992

M. Brown, “Neurofuzzy Adaptive Modelling and Control”, Ed. Prentice Hall International, 1994.

M. J. Grimble and Michael A. Johnson, “Optimal control and stochastic estimation, Theory and applications”, John Wiley & Sons, 1988

M. Mokhtari, A. Mesbah, “ Apprendre et maîtriser MATLAB ”, Ed. Springer Verlag, 1998

M. Mokhtari, “MATLAB 5.2 & 5.3 et SIMULINK 2 et 3 pour étudiants et ingénieurs”, Ed. Springer-Verlag Berlin Heidelberg New York, USA, 2000

M. Mokhtari, M. Marie, “Applications de MATLAB 5 et SIMULINK 2. Contrôle de procédés, Logique floue, Réseaux de neurones, Traitement du signal”, Ed. Springer, 1998.

M. Mokhtari, M. Marie, “Engineering Applications of MATLAB 5 and SIMULINK3”, Ed. Springer-Verlag Berlin Heidelberg New York, USA, 2000

N. Martaj, M. Mokhtari, “MATLAB R2009, SIMULINK et STATEFLOW pour Ingénieurs, Chercheurs et Etudiants”, Ed. Springer Verlag, 2010

P. A. Blume, “The LabVIEW Style Book”, Ed. Prentice Hall, 2007

R. H. Bishop, “LabVIEW Programming, Data Acquisition and Analysis”, Ed. Prentice Hall, 2000

R. W. Larsen, “LabVIEW for Engineers”, Ed. PEARSON, 2010

T. W. Anderson, “An introduction to multivariate statistical analysis”, John Wiley, New York, 1958

Références bibliographiques 891

Ressources Internet

http://france.ni.com/

http://www.ni.com/labview/f/

http://www.ni.com/academic/learn_labview/f/

http://www.ni.com/academic/f/

http://www.ni.com/academic/lv_training/

http://www.ni.com/gettingstarted/labviewbasics/f/environment.htm#Block Diagram

Index

1 1D

table, 482 tableau, 68, 74, 76, 104, 148, 151, 288, 324, 396, 397, 403, 410, 416, 461,462, 533, 758, 838, 845

2 2D

graphiques, 360 tableau, 50, 68, 73, 143, 147-151, 173, 194, 244, 396, 397, 401, 402, 410, 461, 499, 500, 723, 742

3 3D

graphiques, 360 surfaces, 329, 331, 333 tracé, 331, 332

A adaptatif (filtre), 787, 832-836, 838, 842 Advanced

palette, 814 PID, 611, 614

ajustement, 305, 308, 313, 314 algorithme

RLS, LMS, 824, 832, 833 MCR, 859 TFR, 255 MC, 262 factorielle récursive, 201

analogique filtre , 813 modèle d'état, 288, 289, 294 modèle, 478, 481, 504, 505, 872, 874 PI, 132, 272, 615, 618 PID, 605, 614 processus, 763, 768, 769, 776, 780, 781 signal, 817 système, 334, 353, 355, 662

angulaire position, 290 vitesse, 289, 294 antibruit (filtre), 830 anticipative, 783

appartenance (fonction d'), 643-654, 657-661, 670-674

AR (autorégressif), 561, 573, 574, 582, 793, 806, 844

Arithmetic, 769, 777 ARMA, 561, 863, 864, 867 ARMAX, 561, 571-575, 584, 600, 601 ARX, 563, 573, 574, 583, 585-587, 601, 602, assembler, 282 autocorrélation, 301, 560, 566-574, 577, 585,

586, 591, 592, 601, 843, 847, 849, 851-856, 867, 868, 876, 878, 889, 890

B BELLMAN, 780 Bernoulli, 734, 735, Bessel (filtre), 135, 807, 808, 817 binaire, 350, 395, 396, 407-409, 418, 468, 826, 826, 863, 864, 875 binomiale, 735 bobine, 278 Bode, 106, 541, 564, 565, 580, 581, 596, 597, 802, 803, 807, 814, 815, 845, 846 boucle, 276, 280, 282, 289, 292 boite de calcul, 21, 200, 203, 213-221, 252, 269, 270, 349, 608, 622, 742-746, 759-

766, 773, 774, 814, 864- 868, 888 booléen, 72 , 93, 118, 190, 223, 494 Butterworth (filtre de), 21, 22, 225, 256, 257, 438, 439, 579, 788, 805, 807, 811-819 C capteur, 136, 138, 494, 507, 516, 556, 867, 870, 872, 874 centile, 715-718 Chebyshev (filtre de), 135-137, 805, 807, 809 chemin, 55-64, 68, 350, 391, 399-409, 421-425, 432-439, 442, 499, 500, 582, 585, 660, 670 cluster, 289, 294, 295, 299, 307,366, 377 Collector, 272, 499, 563, 599, 609, 616, 624,

638, 693, 701, 804, 865, 887 commande, 274-290, 297, 308, 312, 318, 319 concaténation, 57, 59, 60, 61, 62, 71, 139, 148, 151, 155, 184, 401 configuration, 278 connecteur, 277, 278, 281 consigne, 274, 282, 283 contour, 7 contrôle, 274, 278

DOI 10.1007/978-3-642-45335-9 © Springer-Verlag Berlin Heidelberg 2014 ,893N. Martaj and M. Mokhtari, Apprendre et maîtriser LabVIEW par ses applications,

Index 894

contrôleur, 274 convergence, 828 corrélation, 721, 722-724, 737, 738, 847-853 couple, 288, 623 courant, 277, 287-290, 294, 302, 303, 304, 305,

623, 715 curseurs, 820 D date, 57, 58, 68, 84-87, 401, 402, 406, 439, 653 DC, 294 débit, 634, 637, 638, 639 défuzzification, 649, 654, 659, 660, 662 degré, 313, 315, 318 densité, 716, 717, 729-731 densité spectrale de puissance, 856 densité spectrale énergétique, 847, 854 dérivateur, 794-796 dérivée, 292 diagrammes

en bâtons, 470 en camembert,472

différentielle, 292 diode, 302, 305 Dirac (impulsion de), 301, 302, 560, 566, 569,

572, 574, 577, 833,849, 852, 854, 878, 884, 885

Discrete filter, 806 Integrator, 501, 619 Kalman filter, 858 PID, 607 Random, 734, 735 State-Space, 565, 578, 823, 873, 887 transfer function, 804, 805, 865

dissymétrie, 725, 728, 729, 732, 743-745 distribution, 310, 715-721, 725-734, 743, 746 divergence, 316 dynamique, 289

E électrique, 287, 288, 303, 305, 623 Elliptique (filtre), 811 équation

de récurrence 279, 280, 289 d'état), 288, 289, 295 différentielle, 292 du moteur DC, 288

Equations différentielle méthode d’Euler, 35 méthode de Runge-Kutta, 36

Estimation, 837, 860, 871, 873 Euler, 683-686, 690,-695, 708, 710 Excel, 393 exponentielle, 297, 303, 304, 306, 307 Export, 317, 327, 395, 410, 412, 414, 416, 429

F FFT, 335, 572, 790, 796-800, 812, 813, 855 fichier

ASCII, 398, binaire, 47 , 398, 409-411 de mesures, 52 tableur,47, 50, 398, 399-402, TDMS, 398, 419-434, 439-443 texte,48, 53, 398, 402-409 waveforms, 412-419 XML, 436-438 ZIP, 398, 434-436

filtrage (adaptatif), 824 filtrage (elliptique et Butterworth), 811, 820 filtrage (Butterworth), 22 filtrage (passe-bande, 255 filtrage (IIR), 438 filtrage (Kalman), 514, 868 filtrage (filtre FIR), 847, 848, 853 FIR, 23, 24, 26, 336, 414, 415, 791-794,

797- 830, 833, 838, 843, 844, 845, 846, 853 Fisher, 727 flou (régulateur), 645, 646, 654, 662 fonction

sigmoïde, 307 Ajustement polynomial général, 308 polyval, 307

For (boucle), 19, 20, 27, 40, 48-50, 78, 80, 81, 137 142, 143, 188-202, 205, 208-221, 280, 282, 289, 350, 403, 454, 455, 461-463, 678-695, 698, 744, 749, 765, 774, 775, 794, 828, 841, 862, 867, 874, 880- 889 force (électromotrice), 288 formatage, 68 Formula, 274 Fourier, 255, 335, 336, 570, 571, 573, 796-801, 812, 847 freinage, 298 fréquentielle

réponse, 541, 583, 801 périodicité, 256

freqz, 810 frottements, 623 FTBF, 770, 772 fuzzification, 645, 646, 649, 652, 659

G gabarit, 796, 810, 817 Gamma, 730, 731, 733 Gauss, 309, 714, 729, 730 gaussien (bruit blanc), 11, 25, 40, 46, 124, 297, 310-315, 349-515, 524, 554, 562-566, 574, 578-585, 592, 601, 714-721, 725- 733, 737-746, 820, 821, 833-835, 371- 381, 840-854, 857-877, 889, 868-890

Index 895

graphe waveform, 55, 404, 407, 552 mixte, 467-469 numérique, 459, 468, 469,

graphe 3D, 465, 472 H heure, 58, 84, 86, 87, 402 histogramme, 307-312, 714, 721, 725-732, 742- 745, 832-836 horodatage, 57, 81, 84, 86, 87 HTML, 639, 653 I Icon, 275, 276, 292, 608, 626, 632, 633, 636-771 identification, 562-587, 592, 593, 599-602, 635, 825, 827, 830, 832, 833 IIR (filtre), 438, 439, 575, 576, 744, 788-809, 824, 845 Import, 317, 322 Impulse, 792, 794, 802, 808, 814 impulsionnelle (réponse), 792-798, 802, 804, 808, 814, 821, 823 indexation, 289 indicielle (réponse), 282, 624, 758, 795, 809, 811, 814 inférence, 646-649 intégrateur, 615-624, 628, 631, 776-780 Integrator, 619, 769 interp1, 314, 315 interpolation, 298, 300, 302, interquartile, 716, 718

K Kalman

filtre, 515, 516, 868, 874 estimation d’une constante, 516 estimation courant et vitesse, 526, 871 estimation de l’état, 554, 872 critère de, 546 régime permanent, 881-883 prédicteur, 884, 888

Kelvin, 303 khi-2, 733 Kurtosis, 720, 725-729, 732, 743-746 L Lemniscate de Bernoulli, 455 Levenberg-Marquardt, 306 linéaire, 297, 298, 316, 319 Lissage, 313 Lissajous, 195, 443, 452, 453, 457 LMS, 824 logarithme, 15, , 105, 92,-95, 110, 155, 158,

163, 263, 264, 305, 819 LQI, 759, 762 LU, 309

M MA (moving average), 563, 791 MathScript, 297, 302, 308, 312-318, 796, 798, 803- 812, 818, 819, 823, 827 MATLAB, 298, 299, 302 matrice

de transfert, 636 d'état, 489-493, 496, 500, 513, 530, 534, 544-546, 550, 553, 557, 566, 597, 629, 630, 632, 633, 635

mécanique (équation), 287-291 médiane, 716, 732 mesures

E/S sur fichiers 441, 396-408, 418, 438, 439 modèle linéaire, 299, 300, 301-306, 311, 316 processus bruité, 501, 513, 514, 515, 581, 582 vitesse bruitée, 524, 554 statistiques, 718, 724, 726, 741-746 signal à prédire, 790, 792, 793, 835 Kalman, 857-864, 869-872, 874, 877-889 modèle exponentiel, 16, 52, 158-161, 164, 166

méthode, 304, 306, 311 MIMO (Multi Input Multi Output), 289, 635, 636, 758 mode, 714, 719, 720 moment, 720, 721, 727, 731, 735 moteur, 287- 295, 623, 624, 628, 634, 638 moyenne, 310-315 moyenneur (filtre), 24, 26, 797-824, 838-840, 843, 845, 847, 848, 853, 857 multivariable, 634, 635, 637, 638, 639, 640 Newton-Raphson, 1, 34-38, 139, 163, 164, 676, 679, 680 N Newton, 263 nœud

Access Model Hierarchy, 504 Assembler, 242, 245 d’expression, 49, 99, 135, 194, 292, 350, 520, 615, 678, 695 de bordure, 241 de méthode, 393, 431, 78 de propriété), 64, 65, 72, 75-77, 262, 366- 368, 375-382, 386-393, 429, 440, 456, 494, 566, 618, 788 de rétroaction, 20, 25, 204-214, 252, 280,

284, 663, 744, 794, 795, 821, 838, 858, 840

de script MATLAB, 864 Désassembler, 242, 244 Diviser, 242 Indexer, 242, 243

Index 896

Input Node, 478, 485, 552, 606, 607, 616, 618, 693, 702

MathScript, 7-104, 107, 114-129, 158-175, 193, 200-204, 216-233, 255-267, 284- 475, 489-548, 565, 566, 624-633, 666-684, 692-701, 704, 717, 736, 750, 754, 767, 773, 780-784, 796- 823, 827, 839-864 Output Node, 606, 618 Script MATLAB, 106, 110

Nyquist, 541, 597, 598, 806, 807 numérique, 1, 31, 34, 108, 139, 142, 184, 187, 189, 195, 196, 223, 225, 252, 259, 263, 272, 275, 295, 300, 675, 682, 710, 711, 736, 742, 745- 794, 801, 813, 837, 847, 848, 860, 883 P palette

Algèbre linéaire, 161, 168 Chaîne et chemin, 60, 399 Cluster, 163, 177, 179, 283, 285, 307, 454, 457 Complexes, 90 Continuous Linear systems, 493, 496, 504, 605, 614, 617, 624, 701,769 Contrôle d’applications, 367, 391 Control Design, 544, 582, 803 Dialogue et interface utilisateur, 232, 235, 383, 394, 466, 711, 712 Discrete Linear Systems, 272, 608, 619, 574 E/S sur fichiers, 350, 396, 400, 410, 441 Express, 274, 725, 748, 762, 789 Fuzzy Logic, 642 Génération de waveforms, 374, 452 Graphe 3D, 469 Graphisme et son, 8, 463 Implementation, 551 Indicateurs texte, 366 Informations temporelles, 246 Linear Algebra, 9 Mathématiques, 98, 114, 125, 130, 155, 156, 265, 298, 307, 456, 546, 707, 714, 723, 794, 858, 867, 876, 878 Matrice, 153-156 Menu déroulant et énum, 224, 234 Model Analysis, 544, 591, 596 Model Validation, 574 Numérique, 407, 461, 468 PID, 604, 633, 756 Probabilités et statistiques, 714, 444, 729, 734 Recursive Model Estimation, 577 RGB, 232-235 Signal Arithmetic, 614, 639 Signal Generation, 272, 505, 606, 617, 638, 701 Stockage/DataPlugin, 437 String, 58 Structures, 200, 205, 227, 241, 280, 318

Tableau, 140, 141, 153, 156, 177, 320, 624 TD en continu, 420 Traitement de signal, 282, 350, 367, 418, 571, 575, 714, 725, 727, 788- 790, 794, 798, 838, 843- 845, 853, 867- 878 Utilities, 618, 701, 771 waveform, 468, 790

paramétrique, 861 passe-bande (filtre), 224-226, 255-258, 277, 583, 590, 788-811 passe-bas (filtre), 108, 225, 226, 336, 414, 438, 439, 581, 590, 758, 805, 808- 811, 839, 840, 844, 882 passe-haut, 224, 225, 796-800, 805, 809, 846 pendule

amorti, 291, 292 inversé, 643-650, 665-672

PI, 274, 275, 276, 277, 283, 615, 618, 619, 633, 748, 750, 752 PID, 276, 278, 492, 503, 504, 518, 604, 605- 611, 614-621, 633-640, 748, 750-758, 763, 768, 769 polyfit, 307, 310 polynôme, 307-314 polynomial, 308, 309 pondération, 311 position, 281, 288, 290 prédicteur, 759, 763, 764 prédiction, 586, 587, 825, 834-836, 889, 890 proportionnel (gain), 274 Q quadratique, 311, 317, 318 quartile, 716, 717, 718 R récurrence, 279, 289, 610, 744, 748, 752, 753, 759, 763, 773, 791, 794 récursif, 792, 802, 838, 859 registre (à décalage), 19, 188, 202-210, 218, 268, 270, 279, 289, 748, 828, 829, 862, 863, 885 règle (floue), 647, 648, 652-654, 658 Régression

linéaire, 11-17, 31-46, 82, 158, 230-242, 298- 302, 721-724 exponentielle, 15 spline,17 Polynomiale, 17 moindres carrés, 123

régulateur, 283, 284, 610-619, 625-627, 639 Régulation

analogique, 26 asymptotique, 772 compensation de pôles, 770 discrète, 282, floue,665-675

Index 897

intégrale, 498, 499 LQI, 762 optimale, 772 par le choix de la FTBF, 772 PI avec pondération de la consigne, 522 PI, 28, 132, 133, 268, 272, 500, 523, 615 PID, 130, 253, 271, 492, 610-615, 617-623, 633, 639 placement de pôles, 627 proportionnelle, 481 retour d’état, 555-558 RST, 763-769

répartition, 716, 717, 730-733 résidu, 311 résistance, 36, 347, 348, 356, 548, 690, 703, 814 RICCATI, 780-782 Ring, 234, 583, 788 RLC, 97, 106, 545, 547, 699, 700, 707, 710, 711, 813 rotor, 287 RST, 763, 764 Runge-Kutta, 292, 617, 683-689, 696-700, 706, 711 S SBPA, 350, 427, 467, 827, 828, 830, 862-867 script (Fenêtre MathScript), 338, 358, 360 script (MATLAB), 6, 13-15, 39, 46, 298, 299, 301, 322, 340, 779 séquence (condition), 384, 385 séquence (structure), 383 sigmoïde, 307, 310, 311 signal, 315 simulation (boucle de), 253, 272, 573, 578, 590,

600, 803, 805, 814, 823 SISO, 758 skewness, 720, 725-732, 743-746 sous-VI, 27, 105, 106, 169, 269-271, 274-278, 386, 387, 414, 415, 429, 467, 580, 605, 607, 659, 666-671, 748, 754, 765, 832, 833 Spline, 313, 314 ss, 489, 521, 540, 565, 566, 632, 693, 699, 704, 780, 814, 823, 879, 887 State-Space, 288, 294, 490, 493, 521, 529, 530, 535, 544-551, 565, 566, 578-580, 589, 592-597, 667-670, 693, 699, 814, 823, 873- 888 statique

erreur, 271, 272 gain, 23, 26, 28, 251-254 , 344, 355, 358, 359, 505, 513, 518-523, 533-543, 552, 556, 615-619, 620, 623-627, 745, 757-760, 764, 769-773, 821, 839, 840, 847, 865 régime, 251, 504, 556, 706, 750, 758 valeur, 346

statistique, 714-716, 720, 723, 725, 734 stem, 225, 469, 812, 889 step, 283, 334, 803, 811, 814, 825, 828, 831, 834

stimulus, 539, 562-572, 574, 578, 582-602, 827-832 structure

Condition, 292 Evénement, 227-240

surface, 649 ,654, 717 surface 3D, 462-459 symbolique, 814, 815 système

à réguler, 279, 282, analogique, 478, 493, 505, 513 bouclé, 132, 134,626 , 628, 758, 772, 777 commandable, 544 d’équations linéaires, 2, 156, 162, 167 d’équations, 681-701 d’état, 534, 543, 544, 547, 667, 884 d’exploitation, 387, 388, 392 de régulation PID, 253 déterminé, 2, 4, 5, 169, 175, 341 du 1er ordre analogique, 132, 280, 282, 490, 523, 769, du 1er ordre discret, 282, 354, 610, 753, 759, 860 du 2nd discret, 26, 523, 774 du 2nd ordre analogique 353, 355, 358, 523, 540, 623, 626 analogique, 115, 252, 283, 334, du 2nd ordre discret, 344, 619 du 2nd ordre sous amorti, 107, 344-346 en boucle fermé, 251, 252, 276 flou, 642-646, 650-664, 669 linéaire, 5, 259, 322, 323, 341, 347, 776 masse-ressort, 495 matriciel, 174, matricielle, 349 mécanique, 703, multivariable, 634-640 observable, 544 analogique sous déterminé, 4, 5, 627 surdéterminé, 157, 170, 173, 174, 259 MIMO, 289 Zéro-Pôle-Gain, 543

T table, 368-371 table (Express), 366, 367 tableur, 1, 52, 54, 56, 58, 61, 69, 350, , 395-404, 412-416 température, 621, 634-640 tension, 288-290, 295, 302-306 tf, 119, 134, 344, 345, 489, 540, 553, 701, 704, 803, 804, 811, 814, 839, 865, 872 thermodynamique, 303-306 toolkit (contrôle et simulation), 397, 403, 478, 552, 693, 699, 701, 703, 756, 757, 758, 770, 839, 854, 862, 873

Index 898

U uniforme

bruit, 397, 404, 408, 427, 434, 438, 564, 566, 843, 853, distribution, 22, 39, 50, , 84, 142, 265, 215, 220, 371, 372, 725, 726, 736, 742, 743, 824, 844 variables aléatoires, 444-446

unimodal, 719, 720 Utilities, 292, 293

V véhicule, 298 W waveform, 86, 241-247, 282, 286, 312, 374, 396,

404, 410-418, 429-431, 446-459, 468, 480, 486, 503, 513, 568, 578, 591, 714- 790, 801, 805, 806 While (boucle), 217,445, 462,728, 749, 754, 757, 818, 819 X XML, 396, 434, 435, 436 Y Yulewalker, 810, 811 Z Zip, 432, 433