SUJET DE PROJET DE LE205

I. CONSIGNES : Pour mener à bien ce projet, suivez l'ordre de l'énoncé pas à pas, ce sera plus facile. • Suivez les indications et les consignes qui vous sont fournies dans chaque partie. Il

s'agit d'un cahier des charges, il doit donc être suivi scrupuleusement. • Utilisez systématiquement le menu d'aide (menu Help/Demos et onglet Index) pour vous

aider à utiliser les fonctions internes Matlab. • Lors de la correction, une grande importance sera attachée à la programmation des

3 fonctions de calcul : la première fonction caclul2 (partie V.A) puis son amélioration avec calcul1 (partie V.E) et calcul (partie V.F). Ne les négligez surtout pas. L'aspect interface avec l'utilisateur est de moindre importance : ne vous perdez pas dans de l'esthétique.

II. PRINCIPE PHYSIQUE : Soit le circuit électronique suivant (Figure 1):

Figure 1 : Schéma électronique de base

Ce circuit est formé d'un générateur de tension cosinusoïdale d'amplitude Vg et de fréquence f . La résistance interne du générateur est Zg. Ce générateur débite du courant dans une impédance de charge Zl située au bout d'un circuit composé de fils électriques de longueur l . Ces fils électriques forment ce que l'on appelle une ligne de transmission, dans la mesure où ils transmettent une tension du générateur vers la charge. Lorsque la fréquence du signal cosinusoïdal délivré par le générateur augmente, il apparaît un phénomène de déphasage de la tension selon la position z considérée sur la ligne, déphasage négligé lorsque la tension est débitée à basse fréquence. La physique nous explique que ce déphasage en fonction de z est dû à un effet de propagation de la tension (appelée par conséquent onde de tension) sur la ligne de z=-l à z=0.

1

En effet, l'écriture mathématique générale d'une onde de tension V qui se propage dans la direction z>0 s'écrit :

)cos(),( ztAztV βω −= où est l'amplitude de l'onde de tension en volts, A fπω 2= est la pulsation de l'onde en radians par seconde, t est le temps en seconde, β la constante de propagation qui dépend des propriétés physiques de la ligne en radians par mètre et la position sur la ligne où l'on mesure la tension V . La variable

zzβ amène donc un déphasage de V en fonction de et

c'est cela qui caractérise la propriété propagative de l'onde de tension. z

Cet effet de propagation, négligeable à basse fréquence, a une conséquence inhabituelle illustrée sur la Figure 2: Le générateur émet une onde de tension qui parcourt la ligne de transmission de z=-l jusqu'à z=0. Arrivée sur la charge Zl une partie de l'onde de tension incidente (notée ) est réfléchie vers le générateur. Cette réflexion est caractérisée par un coefficient de réflexion, noté et la tension réfléchie est notée . Ce qui signifie qu'à chaque position

z, la tension .

)(zV+

Γ )()( zVzV+−

Γ=

=Γ++

)()( VzVz ( )Γ+⋅=+=++−+

1)()()()( zVzVzVzV

Figure 2 : Ondes de tension incidente et réfléchie sur la ligne de longueur l

2

III. OBJECTIF DU PROJET : Le but de ce projet est de fabriquer un outil numérique capable de simuler en fonction du temps, la tension , pour plusieurs fréquences et plusieurs charges . ),( tzVt Zl Les équations à utiliser pour le programme sont indiquées ci-dessous : • L'impédance caractéristique Zc en Ohm de la ligne qui représente l'impédance d'un tronçon de ligne de un mètre lorsque les pertes par effet Joule sont négligées.

CLZc = (Équation 1)

avec l'inductance linéique en Henry par mètre et la capacité linéique en Farad par mètre. L C • Le coefficient de propagation β en radians par mètre qui permet de prendre en compte le comportement physique (inductif et capacitif) de fils électriques parcourus par une tension haute fréquence.

LCfπβ 2= (Équation 2)

avec la fréquence en Hertz. f • L'impédance "ramenée" Zin en Ohm qui représente l'impédance équivalente que "voit" le générateur lorsque la charge Zl et la ligne de longueur l d'impédance caractéristique Zc sont prises en comptes.

⎟⎠⎞

⎜⎝⎛

++⋅= )tan(

)tan(lZliZclZciZlZcZin β

β (Équation 3)

• Le coefficient de réflexion Γ sans unité qui représente la réflexion de l'onde de tension incidente

+V sur la charge Zl lorsque la ligne a une impédance caractéristique Zc .

ZcZlZcZl

+−=Γ (Équation 4)

• L'amplitude de l'onde de tension

+V en volts qui représente l'amplitude complexe de

l'onde de tension incidente sur la charge en 0=z .

lilieeZgZin

ZinVgV ββ −

+

Γ+⋅+= 1 (Équation 5)

avec Vg l'amplitude de la tension délivrée par le générateur et l'impédance du générateur telle que :

Zg

ZcZg = (Équation 6)

avec les termes exponentiels qui sont l'écriture complexe des termes de propagations en zβ présents dans le cosinus calculés pour une distance lz −= .

3

• L'amplitude de l'onde de tension )(zV en volts qui représente l'amplitude complexe de l'onde de tension à la côte z quelconque entre 0=z et lz −= .

( )zizieeVzV

ββ +−+Γ+=)( (Équation 7)

où le terme en représente la propagation vers les donc l'onde incidente et où le terme en représente la propagation vers les

zie

β−0>z

zie

β+0<z après une réflexion représentée par le

terme Γ . • L'amplitude réelle de l'onde de tension ),( tzV en volts, qui représente la tension qui serait observée en fonction du temps par un oscilloscope dont la sonde serait positionnée à une côte z sur la ligne.

( )tiezVtzVt

ω+⋅ℜ= )(),( (Équation 8)

IV. DONNEES DE TEST Dans le tableau ci-dessous sont regroupées les valeurs que vous utiliserez pour tester votre programme :

VARIABLES VALEUR(S) Longueur de la ligne (m) 1 Capacité linéique (F/m) 1e-10

Inductance linéique (H/m) 2.5e-7 Tension du générateur (V) 12

Fréquences (Hz) [500:100:1200]*1e6 Impédances de la charge Zl (Ohm) [10:10:100]

Tableau 1 : tableaux de données de test pour plusieurs fréquences et plusieurs charges

V. CAHIER DES CHARGES

A. Première fonction de calcul : calcul2.m Dans un m-file nommé calcul2.m, calculer [équation 7] selon l'algorithme de la )(zVFigure 7 (ANNEXE 1) en utilisant les données d'entrée fournies dans le Tableau 1:

Consignes : • Les variables portent le suffixe _2 pour signifier qu'elles appartiennent à la

fonction calcul2 . • Les variables fréquence_2 et Zl_2 sont des tableaux de dimensions différentes.

beta_2 dépend de frequence_2, il ont donc la même dimension. La boucle sur frequence_2 est remplacée par une boucle sur beta_2.

• Attention, le calcul de la variable "t" dépend de la période T et donc de la fréquence. "t" est donc une matrice qui contient autant de colonne qu'il y a d'échantillons de temps et autant de ligne qu'il y a de fréquences. Il s'agit donc

4

d'un produit entre deux vecteurs qui donne une matrice (lignes=périodes, colonnes=échantillons de temps). Ne pas oublier que fT 1= en s.

• Par commodité d'écriture lors de la programmation, la variable +

V sera appelée V0 dans les programmes de calcul et V0_2 dans ce programme ci : calcul2.

• Zin_2 est donc une matrice à deux dimensions avec beta_2 qui change quand on change de ligne et Zl_2 qui change quand on change de colonne. Il en est de même pour Gamma_2 et pour V0_2.

• V_2 est une matrice à trois dimensions où z grandit avec l'indice de la ligne, où beta_2 change selon les colonnes et Zl_2 selon la profondeur comme l'indique la Figure 3. Avec les données entrées, size(V_2)=[1001,8,10] .

Figure 3 : matrice ),,( ZlzV β de l'équation 7 en 3 dimensions

Consignes : Transformer le code du m-file calcul2.m pour qu'il devienne une fonction nommée calcul2, qui puisse être appelée par un autre programme. Les arguments d'entrée sont :

• un tableau de longueur 4, nommé "param" qui contient, dans l'ordre, la longueur de la ligne, la capacité linéique, l'inductance linéique et la tension du générateur.

• Une variable "frequence" qui contient un tableau de fréquences comme indiquées dans les données de test du Tableau 1 et qui sera affecté à frequence_2.

• Une variable "charge" qui contient un tableau d'impédances de charge comme indiquées dans les données de test du Tableau 1 et qui sera affecté à Zl_2.

Les arguments de sortie sont : • La matrice en trois dimensions V_2, le tableau des positions z et le tableau du

temps t .

5

B. Interface d'affichage : affichage.m Dans un nouveau m-file nommé affichage.m, programmer une fonction qui va permettre à l'utilisateur de piloter l'affichage des résultats calculés par la fonction calcul2. Pour cela, suivre le synoptique de la Figure 8 (ANNEXE 2) et les indications suivantes. Les arguments d'entrée sont :

• "V", la matrice 3D contenant V(z) de l'équation 7 calculée, pour l'instant par la fonction calcul2, soit V_2.

• "z" le tableau d'abscisses calculées dans la fonction calcul2 • "t" la matrice d'échantillons temporels calculés dans la fonction calcul2 • "charge" le tableau des impédances de charge Zl de 10 valeurs, pour le cas du Tableau

1. • "frequence" le tableau des fréquences de 8 valeurs, pour le cas du Tableau 1.

Il n'y a aucun arguments de sortie. Consignes :

• Afin de choisir une fréquence dans la liste des fréquence entrées, il faut utiliser la fonction listdlg('ListString',liste,'SelectionMode','single') où liste doit être remplacé par le tableau de fréquences ou de charges, mis à la verticale (attention la charge peut être complexe) et transformé en chaîne de caractères, voir Figure 4. La fonction listdlg renvoie le numéro de la ligne sélectionnée ("num_frequence") ou un tableau vide si rien n'a été choisi. Il faut donc tester si "num_frequence" est vide afin de vérifier l'entrée.

• lorsque une fréquence a été choisie, celle-ci est transformée en chaîne de caractères (nommée "s_frequence") afin d'être indiquée dans le MENU, à côté du titre "Sélection du paramètre fréquence", voir Figure 4. C'est pour cela que cette variable doit être initialisée par une chaîne de caractère vide.

• Il en est de même pour le choix de la charge dont la chaîne de caractère associée se nomme "charge" et le numéro de ligne choisi "num_charge", voir Figure 4.

• Avant de tracer, il faut vérifier que "num_frequence" et "num_charge" ont bien été affectés et si l'un ou l'autre est vide, il faut en informer l'utilisateur à l'aide de la fonction errordlg('qui prend une chaîne de caractère comme argument').

• Pour le tracé, il faut d'abord extraire de la matrice V en 3D, la colonne en fonction de z pour une fréquence et une charge choisies par l'utilisateur. Il s'agit ensuite de programmer l'équation 8. Attention, fπω 2= , et "t" est une matrice dont il faut choisir la ligne en fonction de la fréquence pour avoir les échantillons temporels adaptés à la période du signal fT 1= (voir la fonction calcul2)

• Le tracé se fait en fonction de z. Attention :Vt est une matrice fonction de z et de t, il s'agit d'en extraire Vt(z,t) pour le "t" qui correspond à la boucle.

• Les bornes des axes sont adaptées aux valeurs de z en abscisse et de Vt(z,t) en ordonnée. La fonction Matlab axis(abscisse_min, abscisse_max, ordonnée_min, ordonnée_max) permet de choisir les bornes en abscisse et en ordonnées. Dans notre cas les abscisses vont du premier au dernier élément de z, puisqu'ils sont dans l'ordre croissant. Quant aux ordonnées, puisque Vt est une matrice fonction de z et de t, on choisira pour l'ordonnée minimum, la plus petite valeur contenue dans la matrice Vt et la valeur maximum de la matrice Vt pour la borne maximum de l'ordonnée.

6

• Afin de rendre visible l'évolution temporelle générée par la boucle, une pause de 0.03 seconde est choisie entre chaque nouveau tracé en fonction du temps (voir l'exemple Figure 5).

• Lorsque l'utilisateur demande la fin de l'affichage, il s'agit de fermer la fenêtre active. Pour cela, il faut utiliser la fonction Matlab close(gcf) qui ferme l'objet dont le numéro est contenu dans la variable spécifique Matlab gcf, qui signifie "get current figure", autrement dit, prend le numéro de la figure courante.

Figure 4 : liste de choix de fréquences, de charges et MENU d'affichage

Figure 5 : affichage de . La variation temporelle n'est pas visible sur ce graphe. ),( tzV

7

C. Interface d'entrée : entree.m Dans un nouveau m-file nommé entree.m, programmer une fonction qui permette à l'utilisateur de fournir via un menu les valeurs des données d'entrées qui seront envoyées à la fonction calcul2 par l'intermédiaire des variables "param", "frequence", "charge". Pour cela, suivre le synoptique de la Figure 9 (ANNEXE 3) et les indications suivantes. Il n'y a aucun argument d'entrée. Les arguments de sortie sont :

• "param" qui est un tableau contenant dans l'ordre la longueur du circuit, la capacité linéique, l'inductance linéique et l'amplitude de la tension d'alimentation du générateur.

• "charge" qui est un tableau contenant toutes les valeurs des impédances de charge entrées par l'utilisateur.

• "frequence" qui est un tableau contenant toutes les valeurs de fréquences entrées par l'utilisateur.

Les consignes : • A chaque variable correspond une chaîne de caractère du même nom et précédée de

s_ : longueur et s_longueur , capa et s_capa , induc et s_induc , gene et s_gene , charge et s_charge , frequence et s_frequence. Variables et chaînes de caractères devront être initialisées. Les chaînes de caractères serviront à l'utilisateur pour distinguer via le menu les valeurs qui sont déjà entrées de celles qui ne le sont pas encore (voir l'exemple Figure 10 (ANNEXE 4) où les impédances de charge et les fréquences n'ont pas encore été entrées). C'est le même fonctionnement que pour l'interface d'affichage.

• Gestion des choix 2 à 5, entrée de la longueur, de la capacité linéique, de l'inductance linéique et de l'amplitude de la tension délivrée par le générateur. Afin de permettre à l'utilisateur de saisir des données, utiliser la commande suivante en respectant scrupuleusement la syntaxe. L'exemple est donné pour la longueur :

s_longueur=cell2mat(inputdlg('longueur du circuit (m) ?')) Cette expression renvoie, dans la chaîne de caractères s_longueur ce qui a été entré par

l'utilisateur dans l'interface ouverte par la fonction inputdlg, comme le montre la Figure 11 (ANNEXE 4). Il s'agit, ensuite, de vérifier si la chaîne de caractères est vide par la commande isempty( ). Si elle est vide, réinitialisez la variable correspondante (ici longueur) en lui affectant un tableau vide et indiquez à l'utilisateur que l'entrée n'est pas valide grâce à la fonction errordlg( ). Par contre, si la chaîne de caractères est pleine, il faut affecter la donnée entrée à la variable correspondante (de s_longueur à longueur) en considérant que l'utilisateur rentre bien un nombre. Ensuite, il faut vérifier que l'utilisateur n'a bien entré qu'une seule valeur, pas plus. Sinon les variables s_longueur et longueur sont réinitialisées respectivement à une chaîne de caractères vide et à un tableau vide. L'utilisateur doit être informé que son entrée n'est pas valide et qu'il ne doit fournir qu'une seule valeur en utilisant la fonction errordlg( ).

• Gestion des choix 6 et 7, entrée des impédances de charge et des fréquences. Pour ces deux cas et comme précédemment, les chaînes de caractères entrées par l'utilisateur seront collectées grâce à la fonction cell2mat(inputdlg(' ')) comme illustré par la Figure 12 (ANNEXE 4). Le contenu de la chaîne de caractères obtenue est testé pour savoir si elle est vide. Comme précédemment, si c'est le cas, la variable est réinitialisée et une information est communiquée à l'utilisateur. Si ça n'est pas le cas, la chaîne de caractères est transformée en valeur numérique pour être affectée à la variable correspondante. Si cette variable contient plus d'une seule valeur (comme cela

8

sera le cas), il faut réorganiser le tableau de valeurs dans l'ordre croissant puis réaffecter le tableau de valeurs réorganisé à la chaîne de caractères correspondante.

• Gestion du choix 8, sauvegarde des données. Afin que l'utilisateur ne soit pas obligé de rentrer les données manuellement chaque fois qu'il exécute le programme, il doit avoir la possibilité de sauvegarder les données qu'il a déjà entré. La première étape consiste donc en la vérification que les variables longueur , capa , induc , gene , charge et frequence ne sont pas vides. Si une seule d'entre elles est vide, la sauvegarde est annulée et l'utilisateur prévenu (fonction errordlg( ) ). Si aucune d'entre elles n'est vide, l'utilisateur doit choisir un nom de fichier ou un fichier déjà existant. Pour gérer cela, il existe une fonction Matlab uiputfile('extension') où "extension" est une chaîne de caractères qui précise l'extension des fichiers à ouvrir. Vous utiliserez des fichiers de type *.mat . Autrement dit, l'interface de choix de fichier invoquée par uiputfile( ) indiquera dans sa fenêtre, tous les fichiers (représenté par *) d'extension .mat (voir Figure 13 en ANNEXE 4). L'utilisateur peut alors donner lui-même un nom de fichier ou utiliser un fichier existant. Vous devrez ensuite vérifier si un nom de fichier a bien été choisi en testant la chaîne de caractère renvoyée par uiputfile : appelez cette chaîne de caractères s_fichier. Pour cela comparez la chaîne de caractères à 0 grâce à la fonction isequal( ) de Matlab. Si la chaîne de caractère est vide, indiquez à l'utilisateur que l'enregistrement des données est annulé, sinon sauvegardez les variables ainsi que leur chaînes de caractères respectives dans le fichier indiqué. Pour cela, utilisez la fonction save(nom de fichier , 'nom de variable 1' , 'nom de variable 2' , etc…). N'oubliez pas d'indiquer dans le menu d'entrée le nom du fichier utilisé (contenu dans la variable s_fichier) pour sauver les variables indiquées dans le menu, comme illustré par la Figure 10 (ANNEXE 4) avec le fichier "donnees.mat".

• Gestion du choix 1, entrée des données par fichier : pour ouvrir un fichier précédemment enregistré, il faut utiliser la commande Matlab uigetfile('extension'), de la même manière que pour la commande uiputfile( ) utilisée pour choisir le fichier à sauvegarder (voir Figure 14 en ANNEXE 4). Vous devrez vérifier si un nom de fichier a bien été choisi en testant la chaîne de caractère renvoyée par uigetfile. Pour cela comparez la chaîne de caractères à 0 grâce à la fonction isequal( ) de Matlab. Si la chaîne de caractères n'est pas vide, chargez les données contenues dans le fichier choisi en utilisant la commande load( ) en lui indiquant le nom du fichier à ouvrir.

• Gestion du choix 9, Finir : ce bouton permet à l'utilisateur de demander la fin des entrées de données. La première étape consiste donc à vérifier si toutes les données ont bien été affectées. Comme pour la sauvegarde des données, les variables longueur , capa , induc , gene , charge et frequence ne doivent pas être vides. Si au moins une d'entre elle est vide, il faut indiquer à l'utilisateur que toutes les variables ne sont pas affectées et lui demander s'il veut finir quand même en perdant toutes les données entrées. Pour interagir avec l'utilisateur, utilisez la fonction Matlab questdlg(' ') (voir Figure 15 en ANNEXE 4). Si l'utilisateur répond OUI (comparez la réponse à la chaîne de caractère 'YES' avec la commande strcmpi( ) ), réinitialisez toutes les variables ainsi que les chaînes de caractères correspondantes, sans oublier la variable s_fichier. Si l'utilisateur ne répond pas 'YES', faites en sorte qu'il puisse encore avoir accès au menu d'entrée des paramètres. Si toutes les variables ont bien été affectées, il faut ensuite être sûr que ce qui est vu par l'utilisateur est ce qui est mémorisé. Puisque le menu affiche en permanence la valeur contenue dans chaque variable à l'aide de la chaîne de caractère correspondante, l'ultime vérification consiste en la vérification que les chaînes de caractères et leurs

9

variables correspondantes contiennent bien la même chose. Il s'agit donc de tester si chaque chaîne de caractères transformée en valeur donne bien la même chose que les valeurs stockées dans les variables. Cela se fait grâce à la fonction isequal( ). Si ce test indique qu'au moins une variable ne contient pas la même valeur que sa chaîne de caractère correspondante, le programme doit générer un message d'erreur grâce à la fonction errordlg( ), demander à l'utilisateur de "VALIDER pour continuer" dans la "command window" de Matlab avant d'afficher toutes les variables (valeurs et chaîne de caractères correspondantes) afin que l'on puisse se rendre compte visuellement d'où vient l'erreur d'algorithme. S'il y a adéquation entre toutes les valeurs des variables et leur chaîne de caractères respectives, alors le tableau de sortie param est affecté. Le bouton choisi étant le 9ème, la fonction entree s'arrête donc.

• Attention, faites en sorte que tant que l'utilisateur n'a pas demandé explicitement la fin de l'entrée des paramètres, le programme ne quitte pas le menu d'entrée.

D. Interface principale : principal.m Une fois que les fonctions d'entrée des variables, de calcul et d'affichage des résultats sont opérationnelles séparément, il s'agit maintenant de les réunir dans une seule interface principale. Dans un nouveau m-file nommé principal.m, programmer une fonction qui permette à l'utilisateur de choisir l'action qu'il peut mener et lui interdire celles qui ne sont pas autorisées. Pour cela suivre le synoptique de la Figure 16 (ANNEXE 5) et les indications suivantes. Il n'y a aucun argument d'entrée. Il n'y a aucun argument de sortie. Les Consignes :

• Les variables de signalisation sont initialisées telles qu'il est indiqué sur la Figure 16 en ANNEXE 5.

• La convention sur les variables de signalisation est la suivante : Entrée confirmée : affichage de 'OK'. Entrée infirmée : affichage de 'VIDE'. Calcul interdit : affichage de 'IMPOSSIBLE'. Calcul autorisé : affichage de 'A FAIRE'. Calcul confirmé : affichage de 'OK'. Visualisation interdite : affichage de 'IMPOSSIBLE' Visualisation autorisée : affichage de 'A FAIRE' Ces informations doivent apparaître dans le menu principal comme l'illustre la Figure 6.

• Pour vérifier si la fonction "entree" a bien fonctionné, il s'agit de vérifier si les variables param , charge et frequence ne sont pas vides ( fonction isempty( ) ).

• Pour tester si les accès aux différentes fonctions sont autorisées ou non, testez les variables de signalisation en utilisant la fonction strcmpi( ) .

• Signalez les messages d'erreur grâce à la fonction errordlg( ) . • Confirmez le calcul par un message avec la fonction msgbox( ) .

10

Figure 6 : MENU principal à l'initialisation

E. Deuxième fonction de calcul : calcul1.m Avec la fonction calcul2, vous pouvez calculer [équation 7] en utilisant deux boucles imbriquées : une sur beta_2, l'autre sur Zl_2. Pour la fonction calcul1, il s'agit de modifier le programme de la fonction calcul2 afin de supprimer la boucle sur Zl. Il ne restera que la boucle sur beta_1. Pour cela, vous utiliserez la programmation vectorielle qui optimise le fonctionnement de Matlab. Le but est toujours de calculer , et .

)(zV

)(zV t zConsignes :

• Enregistrez le m-file calcul2.m sous le nom calcul1.m . Cela vous permet de conserver la fonction calcul2 et de modifier le programme directement dans le m-file calcul1.m .

• L'algorithme de la fonction calcul1 est le même que celui de la fonction calcul2 présenté sur la Figure 7 (ANNEXE 1), sans la boucle sur Zl_2.

• Dans la fonction calcul1, toutes les variables avec l'extension _2 ont maintenant l'extension _1.

• Pour les calculs de V0_1 et de V_1 vous aurez besoin de la fonction repmat(A,nlig,ncol). Cette fonction Matlab permet de répliquer la matrice A, nlig fois en ligne et ncol fois en colonne. Par exemple : A = 1 2 3 4 5 6 repmat(A,2,3) donne avec nlig=2 et ncol=3 :

1 2 3 4 5 6

1 2 3 4 5 6

1 2 3 4 5 6

1 2 3 4 5 6

1 2 3 4 5 6

1 2 3 4 5 6

Voyez l'exemple concret fournit ANNEXE 6.

• Voici une méthode qui facilite la programmation vectorielle : donnez les valeurs de test indiquées dans Tableau 1. A chaque étape du nouveau calcul vérifiez les dimensions des objets que vous manipulez et faites en sorte que les opérations se produisent entre objets dont les tailles sont compatibles. Pour vous aider à mieux matérialiser vos objets, il est plus facile de s'appuyer sur des schémas faits au brouillon où sont indiquées les dimensions. Testez chacune de vos étapes dans la fenêtre de commande de Matlab.

11

• Quand vous aurez terminé le calcul de V_1, vous pourrez le vérifier à l'aide de la fonction verification_V(V_1,V_2) que vous demanderez à vos responsables de projet. Une autre possibilité de vérification moins systématique est de comparer visuellement par affichage.

F. Troisième fonction de calcul : calcul.m Avec la fonction calcul1, vous avez supprimé la boucle sur Zl. Pour cela, vous avez utilisé la programmation vectorielle. Le but est toujours de calculer , t et mais en supprimant la dernière boucle, celle sur beta_1.

)(zV z

Consignes : • Enregistrez le m-file calcul1.m sous le nom calcul.m . Cela vous permet de conserver

la fonction calcul1 et de modifier le programme directement dans le m-file calcul.m . • L'algorithme de la fonction calcul est le même que celui de la fonction calcul2

présenté sur la Figure 7 (ANNEXE 1), sans la boucle sur Zl_2 ni la boucle dur beta_2. • Dans la fonction calcul, toutes les variables avec l'extension _1 n'ont maintenant plus

d'extension. • Pour les calculs de V0 et de V vous aurez besoin de la fonction repmat pour calculer

Zin , Γ et 0VV =+

. Vous aurez en plus besoin de la fonction permute(A,[lig,col,prof]) pour modifier Γ et V0 afin de calculer )(zV . Dans cette fonction, Γ est une matrice à 3 dimensions, et pour aboutir à un )(zV qui contient la variation en z sur les lignes, la variation en β (ou en fréquence) sur les colonnes et la variations en Zl en profondeur, il va falloir permuter la matrice Γ qui contient 8 lignes (échantillons de β ) et 10 colonnes (échantillons de Zl ). Le but sera " de coucher " cette matrice de telle sorte que β soit sur les colonnes et Zl sur la profondeur. Voyez l'exemple fournit en ANNEXE 6 après l'exemple repmat.

• Voici une méthode qui facilite la programmation vectorielle : donnez les valeurs de test indiquées dans Tableau 1. A chaque étape du nouveau calcul vérifiez les dimensions des objets que vous manipulez et faites en sorte que les opérations se produisent entre objets dont les tailles sont compatibles. Pour vous aider à mieux matérialiser vos objets, il est plus facile de s'appuyer sur des schémas faits au brouillon où sont indiquées les dimensions. Testez chacune de vos étapes dans la fenêtre de commande de Matlab.

• Quand vous aurez terminé le calcul de V, vous pourrez le vérifier à l'aide de la fonction verification_V(V,V_2) que vous demanderez à vos responsables de projet. Une autre possibilité de vérification moins systématique est de comparer visuellement par affichage.

12

13

VI. ANNEXES

A. ANNEXE 1

Figure 7 : Synoptique de la fonction "calcul2"

14

B. ANNEXE 2

Figure 8 : synoptique de la fonction "affichage"

15

C. ANNEXE 3

16

Figure 9 : synoptique de la fonction "entree".

17

D. ANNEXE 4

Figure 10 : exemple de MENU pour l'entrée des paramètres

Figure 11 : exemple de l'entrée manuelle de la

longueur du circuit

Figure 12 : exemple de l'entrée manuelle des

impédances de charge

Figure 13 : fenêtre de sélection de fichier pour la sauvegarde

18

Figure 14 : fenêtre de sélection de fichier pour le chargement de données

Figure 15 : boîte de dialogue pour forcer à quitter le menu d'entrée

19

E. ANNEXE 5

Figure 16 : Synoptique de la fonction "principal"

20

F. ANNEXE 6 %test repmat par un exemple où il faut calculer S=a+A+b a=[1 2 3]; b=[11 12 13 14]; %fabrication de A par 2 boucles imbriquées for ii=1:length(a) for jj=1:length(b) A(ii,jj)=a(ii)*b(jj); % A possede length(a) lignes et length(b) colonnes end end disp(A(:,:)) %fabrication vectorielle de A (sans boucle) appelé Av Av=a.'*b % a.' rend le tableau transposé sans conjugaison %et * opère un produit "matriciel" %S=a+A+b mais a,A et b n'ont pas la même dimension size(a),size(A),size(b) %pour faire la somme S=a+A+b, il faut que a et b aient la même dimension % que A puisque la somme se fait membre à membre. On remarque que : % dans A, a change de valeur quand on change de ligne % dans A, b change de valeur quand on change de colonne % c'est ce que font les deux boucles imbriquées qui calculent A(ii,jj) % C'est aussi ce que fait le calcul vectoriel de Av sans que cela soit % visible explicitement. % 1) Donc, si l'on veut ajouter a et A tout en respectant le fait que a ne % change pas sur une seule ligne de A il faut d'abord transposer a % (sans le conjuguer) pour en faire un tableau vertical afin qu'il % change d'une ligne à l'autre. Ensuite il faut le répliquer autant % de fois qu'il y a de colonnes dans A ou plus précisément autant de % fois qu'il y a d'éléments dans b comme on peut le voir dans les 2 % boucles imbriquées. Cela s'écrit comme suit : rep_a=repmat(a.',1,length(b)) % rep_a a la diemension de A, les valeurs sur ses lignes ne changent pas et % il s'agit bien de chaque valeurs de a répétées 1 fois en ligne et % length(b)=4 en colonne % 2) De la même manière on peut répliquer b pour obtenir une matrice de la % taille de A. Comme b change d'une colonne à l'autre mais pas d'une % ligne à l'autre b doit être répliqué autant de fois qu'il y a de % lignes dans A ou plus précisément autant de fois qu'il y a % d'éléments dans a, comme on peut le voir dans les 2 boucles % imbriquées. Cela s'écrit comme suit : rep_b=repmat(b,length(a),1) % rep_b a la dimension de A, les valeurs sur les colonnes ne changent pas % et il s'agit des valeurs de b répétées length(a)=3 fois en ligne et % 1 fois en colonne. On peut remarquer que comme b est déjà un tableau % horizontal qu'il faut répliquer en ligne, il n'y a pas besoin de le % transposer

21

22

% 3) on peut donc maitenant calculer S=a+A+b S=rep_a+A+rep_b; Sv=rep_a+Av+rep_b; isequal(S,Sv) % donne 1 si S et Sv ont la même dimension et contiennent les même valeurs % 4) on doit utiliser la même technique si l'on veut faire le produit % membre à membre P=a.A.b car P=a.*A.*b ne marche pas P=rep_a.*A.*rep_b; Pv=rep_a.*Av.*rep_b; isequal(P,Pv) ------------------------------------------------------------------------ %test permute %soit la même matrice A que dans l'exemple de repmat a=[1 2 3]; b=[11 12 13 14]; A=a.'*b % a.' rend le tableau transposé sans conjugaison %il s'agit maintenant de faire passer les lignes de A en colonnes, % les colonnes en profondeur et la profondeur (qui implicitement % était de dimension 1) en ligne. Aperm=permute(A,[3,1,2]) %ce qui signifie que Aperm a : % sur ses lignes : la troisieme dimension de A (la profondeur) % sur ses colonnes : la première dimension de A (les lignes) % sur sa profondeur : la deuxième dimension de A (les colonnes) size(A) size(Aperm)