Discussion :

[marco_acmfan]

Hourra!

J'arrive enfin à afficher mes résultats dans mon tableau, et ce grâce à tes précieux conseils!
Voici mon code d'affichage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
% --- Executes on button press in simul_button.
function simul_button_Callback(hObject, eventdata, handles)
% hObject    handle to simul_button (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
answer=questdlg('Voulez-vous lancer la simulation avec les paramètres actuels?',...
    'Lancer simulation','Oui','Non','Non');
if strcmp(answer,'Oui')
    simout=sim('mon_modele','SrcWorkspace','current');
    results=transpose(simout.get('yout'));
    setappdata(gcf,'Resultats',results);
    l2=length(results);
    S2res=cellstr(num2str(results));
    S2new=getappdata(gcbf,'Tableau_sorties');
    for i=1:l2
        S2new{i,2}=S2res{i,1};
    end
    h=findobj('parent',gcbf,'tag','uitable2');
    set(h,'Data',S2new);
end

Après avoir compris la différence entre "String" et "Cell", indiqué que c'était "Data" qu'il fallait changer, et trouvé mon tableau via findobj, tout fonctionne!
Il me reste donc à faire la même chose pour gérer les entrées... Ce n'est pas encore fini.
Une petite idée pour arriver à lire ce que l'utilisateur entre dans la 2e colonne de mon tableau et à le rentrer dans mon modèle (dans les "Constant")?

[duf42]

Une petite question: pourquoi utiliser FINDOBJ plutôt que de récupérer le handle de la table dans la structure HANDLES (handles.uitable2)?

Je vois pas bien où est ton problème , il faut récupérer la valeur dans la propriété Data du tableau puis régler la constante avec SET_PARAM.

[marco_acmfan]

Réponse : car c'était comme ça dans le tuto... Mais ton autre solution est tout aussi bonne et fonctionnelle, d'ailleurs je viens de modifier mon code...

Pour la partie des entrées, la difficulté (selon moi) est la suivante :
je vais utiliser la commande

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

set_param('mon_modele/Constant1','value','valeur_lue')

Le problème, c'est que je vais devoir lire le nom de la constante dans le tableau, aller chercher le nom dans le modèle et modifier la valeur. Mais les noms et l'ordre du modèle et du tableau ne sont pas parfaitement identiques, donc soit je me casse la tête à essayer de reformater les noms dans le code, soit je change les noms de manière à ce qu'ils soient uniformes...
De toute façon, je devrai à un moment ou un autre utiliser un strcat ou qqch de genre pour accéder à la constante dans le modèle vu que je dois à chaque fois mettre 'mon_modele/...'.
Pour être honnête, c'est plus un difficlté de temps et de motivation que de code...

[duf42]

Il y a je pense une solution beaucoup plus simple (reste à savoir si elle est adaptée à ton usage): tu définis les valeurs des constantes comme des paramètres (des variables), qui peuvent être contenues dans une structure ou un tableau de cellules...

Il te suffit ensuite de récupérer toutes tes variables (ou ta variable si tous tes paramètres sont dans une seule variable) juste avant de lancer la simulation et le tour est joué.

En plus de ca ca te permet de stocker des fichiers de paramètres facilement...

[marco_acmfan]

En fait, c'était plus rapide que je ne le pensais... Mon interface est totalement opérationnelle!
Merci beaucoup pour tes conseils!
Mais ce n'est pas fini, j'aurai probablement encore besoin de toi en ce qui concerne la création d'un exécutable avec RTW. Je vais réessayer et je te tiens au courant.
Encore merci!

P.S. : voici mon code final pour la simulation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
% --- Executes on button press in simul_button.
function simul_button_Callback(hObject, eventdata, handles)
% hObject    handle to simul_button (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
answer=questdlg('Voulez-vous lancer la simulation avec les paramètres actuels?',...
    'Lancer simulation','Oui','Non','Non');
if strcmp(answer,'Oui')
    h1=handles.uitable1;
    S1new=get(h1,'Data');
    l1=length(S1new);
    %S1new=char(S1new);
    mod='mon_modele/';
    for i=1:l1
        chem=strcat(mod,char(S1new(i,1)));
        set_param(chem,'value',char(S1new(i,2)));
    end
    simout=sim('mon_modele','SrcWorkspace','current');
    results=transpose(simout.get('yout'));
    setappdata(gcf,'Resultats',results);
    l2=length(results);
    S2res=cellstr(num2str(results));
    S2new=getappdata(gcbf,'Tableau_sorties');
    for i=1:l2
        S2new{i,2}=S2res{i,1};
    end
    h2=handles.uitable2;
    set(h2,'Data',S2new);
end

[marco_acmfan]

Me revoilà.

Bon. J'ai essayé de créer l'exécutable avec deploytool en lui entrant comme fichier principal le fichier *.m de mon IG et en lui entrant en fichiers supplémentaires le fichier *.fig de mon IG, le fichier *.mdl de mon modèle et le fichier *.m des petites fonctions annexes. Il compile bien tout et je peux lancer l'exécutable. Ma fenêtre s'affiche, je rentre des paramètres et je lance une simulation. Rien. Pas d'affichage de résultats, le processeur ne bronche pas...
Pourtant, quand je le fais depuis le *.m de l'IG via ML, tout fonctionne à merveille!

J'ai lu sur le net que deploytool ne gère pas les *.mdl en fichiers principaux et qu'il faut le transformer en *.m. Je l'ai essayé mais pas de résultat.

J'ai regardé pour la RTW toolbox, mais il semble que je ne l'aie pas dans ma version de ML (R2011a sous Win7 64).

Une idée...?

[duf42]

Oula

RTW et le Compiler sont 2 choses distinctes: le Compiler (que tu utilises avec le DEPLOYTOOL) te permet de packager du code MATLAB donc tes interfaces et tes fonctions MATLAB mais absolument pas un modèle Simulink.

RTW te permet de compiler le code de ton modèle (et donc d'obtenir un exécutable), cela se passe dans Simulink (Ctrl+B), par contre il faut avoir la toolbox qui pour toi doit s'appeler Simulink Coder.

Ensuite va se poser le problème du passage de paramètres et la ca se corse sérieusement , tu ne peux plus utiliser SET_PARAM et tu dois définir des paramètres dans ton modèle (comme décrit dans l'un de mes posts précédent)

[marco_acmfan]

Bonjour,

Merci pour l'explication. J'ai bien le Simulink Coder, et lorsque je fais Ctrl+B, j'obtiens bien mon exécutable. Maintenant, il faudrait que je puisse créer un exécutable qui contient le modèle et l'IG et qui peut être exécuté sur une machine quelconque, de manière à créer un vrai programme à partir du modèle.

Pour ce qui est des paramètres, pourrais-tu me redonner l'explication ou le lien vers ton ancien post?

D'avance merci.

[duf42]

Pour l'explication des paramètres:

Il y a je pense une solution beaucoup plus simple (reste à savoir si elle est adaptée à ton usage): tu définis les valeurs des constantes comme des paramètres (des variables), qui peuvent être contenues dans une structure ou un tableau de cellules...

Il te suffit ensuite de récupérer toutes tes variables (ou ta variable si tous tes paramètres sont dans une seule variable) juste avant de lancer la simulation et le tour est joué.

En plus de ca ca te permet de stocker des fichiers de paramètres facilement...

Pour créer ton application complète, tu as plusieurs solutions, l'une d'entre elle consiste à compiler séparément le modèle et l'interface graphique (avec Simulink Coder et MATLAB Compiler), tu obtiendras 2 exécutables et tu peux lancer ton modèle via ton interface.

Une autre méthode, mais je pense qu'il te faut Embedded Coder pour cela, consiste à générer une DLL depuis ton modèle ce qui permet de le contrôler plus précisément.

[marco_acmfan]

Donc si je comprends bien, je dois créer une structure qui va contenir les informations de chaque entrée sous la forme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
entree1=
   designation='nom_entree_1'
   valeur=0
   unite='kg'

et utiliser ce fichier comme base pour les entrées lorsque je lance la simulation.
Mais comment dire que mes blocs "Constant" sont des variables? Je dois entrer un 'var' à la place de la valeur lors du double clic sur le bloc?
Ou changer de bloc?

P.S. : d'après la commande ver, j'ai aussi le Embedded Coder donc il semble que ce soit bon...

[duf42]

De façon très simple, tu peux déjà définir tes paramètres simplement en créant les variables correspondantes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
param1 = 2;
param2 = 5;
...

Ensuite il te suffit de mettre le texte 'param1', 'param2', etc dans les valeurs des Constantes (ou n'importe quel autre bloc Simulink)

[marco_acmfan]

Ok donc je remplace toutes mes constantes par le nom que j'ai assigné au paramètre correspondant.
Mais tu m'as dit que je ne pourrai plus utiliser set_param. Je suppose que c'est toujours dans le code de mon bouton de simulation que je lance le modèle avec les paramètres. Donc comment faire pour lire ou écrire ces paramètres sachant que pour l'exécutable je n'aurai pas accès au Workspace de ML?
(Désolé si ce sont de bêtes questions, mais je commence à nager... Il ne me faut pas grand chose pour m'en sortir je pense mais là je sèche!)

[duf42]

Justement c'est ici que ca se corse sérieusement

Je vais essayer de prendre le temps de te faire un petit topo là-dessus cette apm

[marco_acmfan]

Oki un énorme merci pour ton aide et ton temps!
Pour ma part, je vais essayer de voir comment gérer la partie Embedded Coder pour créer mon fameux exécutable...

[duf42]

Voilà, après m'être un peu battu avec MATLAB et Simulink, voici une méthode qui permet de générer une DLL depuis un modèle Simulink permettant ensuite de l'appeler depuis une fonction MATLAB (ou une fonction C).

Configuration du modèle pour la simulation

• Paramétrage: Les données qui sont des paramètres du modèle doivent être définies comme des variables, créées dans le workspace de MATLAB et appelée par leur nom (de variable) dans les blocs Simulink.
• Entrées/sorties: Utiliser des blocs Inport/Outport pour les signaux d'entrée/sortie du modèle
• Import/Export des données: Dans l'interface de configuration "Simulation Configuration Parameters", dans l'onglet "Data Import/Export" définir les vecteurs à charger depuis le workspace MATLAB (pour les entrées, dans le champ "Load from workspace/Input" et les variables à créer pour les signaux de sortie (pour les sorties, par défaut le temps est sauvegardé dans "tout" et les sorties dans "yout", c'est très bien comme ca)

A ce niveau là le modèle doit fonctionner en simulation, il est possible de le lancer directement ou en utilisant la fonction SIM, depuis le Command Window, un script ou une fonction.

Génération de la DLL (en utilisant Embedded Coder)
Toutes les opérations suivantes se déroulent dans la fenêtre de configuration "Configuration Parameters" accessible depuis le menu "Simulation" ou via le raccourci "Ctrl+E"

• Solveur à pas fixe: Dans l'onglet "Solveur", sélectionner un solveur à pas fixe.
• Inline parameters: Dans l'onglet "Optimization/Signals and Parameters", cocher l'option "Inline parameters"
• Tunable parameters: Toujours dans l'onglet "Optimization/Signals and Parameters", cliquer sur le bouton "Configure", dans la fenêtre qui s'ouvre les variables définies dans le workspace doivent apparaitre dans le champ de gauche, s'assurer que tous les paramètres que l'on souhaite utiliser sont présent et les ajouter à la table des "Global (tunable) parameters" avec le bouton "Add to table"
• Cible pour générer le code: Dans l'onglet "Code Generation", sélectionner le System Target File: ert_shrlib.tlc (utilisation du bouton "Browse")

Maintenant il est possible de générer la DLL en cliquant sur le bouton "Build" qui est disponible dans l'onglet "Code Generation" ou en utilisant le raccourci "Ctrl+B" dans le modèle. Pour pouvoir générer la DLL toutes les variables que vous utilisez dans Simulink (comme paramètres) doivent être définies dans le workspace de base de MATLAB.

Appel de la DLL depuis une fonction MATLAB

• Copie des fichiers d'entête: Copier les fichiers <modèle>.h, <modèle>_types.h et rtwtypes.h, qui se trouvent dans le répertoire <modèle>_ert_shrlib_rtw, dans le même répertoire que la DLL générée précédemment qui doit porter le nom <modèle>_win32.dll
• Charger la librairie: Dans le code MATLAB, charger la librairie en utilisant la fonction LOADLIBRARY, il faut préciser le nom de la librairie (sans l'extension .dll) ainsi que le nom du fichier d'entête <modèle.h>: loadlibrary('<model>_win32', '<model>.h').
  On peut utiliser la fonction LIBISLOADED pour vérifier si la librairie est déjà chargée.
• Appel des fonctions de la librairie: Pour appeler les fonctions de la librairie, il faut utiliser la fonction CALLLIB, en précisant le nom de la librairie, le nom de la fonction à appeler et, éventuellement, les paramètres de la fonction.
  Les principales fonctions utilisées dans la librairie (avec leur syntaxe d'appel) sont:
  
  
  

  • Initialisation du modèle: La fonction dans la DLL s'appelle <modèle>_initialize, il faut l'appeler avec 1 paramètre qui doit être un UINT8 nul, ce qui donne calllib('<model>_win32', '<model>_initialize'], uint8(0));
  • Calcul d'un pas: La fonction <modèle>_step permet d'effectuer un pas de calcul, pour faire une simulation on peut donc utiliser une boucle FOR-END qui appelle cette fonction de la façon suivante: calllib('<model>_win32', '<model>_step']);
  • Finalisation: Une fois que la simulation est terminée, on peut appeler la fonction de terminaison: calllib('<model>_win32', '<model>_terminate']);
  • Paramètres: Pour accéder à la structure de paramètres, on utilise la commande suivante: param = calllib('<model>_win32', '<model>_P'); où la variable "param" est un pointeur vers la structure de paramètres. Pour accéder et modifier les valeurs des paramètres, on utilise la syntaxe suivante: param.Value.<nom_du_parametre>
  • Entrées: Le fonctionnement est le même que pour les paramètres à la différence que la structure se nomme "_U" ce qui donne: inputs = calllib('<model>_win32', '<model>_U');. Les noms des champs sont définis par les noms des ports d'entrée.
  • Sorties: Le fonctionnement est le même que pour les paramètres à la différence que la structure se nomme "_Y" ce qui donne: outputs = calllib('<model>_win32', '<model>_Y');. Les noms des champs sont définis par les noms des ports de sortie.

Pour l'appel, celà donne un code MATLAB de la forme suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
% Définition du nom de la librairie
lib_name = [model_name, '_win32'];
 
% Chargement de la librairie si elle n'est pas encore chargée
if ~libisloaded(lib_name)
    loadlibrary(lib_name, [model_name, '.h']);
end
 
% Initialisation du modèle avec la fonction "<modèle>_initialize"
calllib(lib_name, [model_name '_initialize'], uint8(0));
 
 % Récupération du pointeur vers la structure de paramètres "<modèle>_P"
param = calllib(lib_name, [model_name '_P']);
 
% Mise à jour des valeurs des paramètres
param.Value.param_source = param_source;
param.Value.param_gain = param_gain;
 
% Définition des vecteurs de temps et des sorties
tout = 0:0.01:10;
yout = nan(size(tout));
 
% Boucle pour chaque pas de temps
for i = 1:numel(tout)
 
    % Appel de la fonction "<modèle>_step"
    calllib(lib_name, [model_name '_step']);
 
    % Récupération d'un pointeur vers la structure des sorties
    output = calllib(lib_name, [model_name '_Y']);
 
    % Récupération de la sortie du modèle (port de sortie "Out1")
    yout(i) = output.Value.Out1;
 
end
 
% Finalisation de la simulation
calllib(lib_name, [model_name '_terminate']);

Voilà en espérant que c'est complet et surtout que ca fonctionne (en tous cas chez moi ca marche).

Pour intégrer ca dans ton interface tu as tout ce qu'il te faut, tu auras peut-être besoin de la fonction ISDEPLOYED pour déterminer si tu es en mode déploié ou non...

[marco_acmfan]

Wouaw...
Je suis bouche bée...
Un tout grand merci pour cette marche à suivre très claire.
Je vais l'essayer et je te dis quoi.
Encore merci pour ton temps!

[marco_acmfan]

Bonjour,

J'ai suivi ton tuto à la lettre et tout semble fonctionner, un tout grand merci. Pourtant, lorsque je lance mon appel à la dll qui se trouve dans un *.m, je reçois un message :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
??? Error using ==> Appel_dll at 3
Error due to multiple causes.
 
Caused by:
    Error using ==> Appel_dll at 3
    Errors occurred during parsing of MATLAB function 'Flux libre'(#30)
    Error using ==> Appel_dll at 3
    Error in port widths or dimensions. Output port 1 of 'Modele_1c/Flux
    libre/Mach' is a one dimensional vector with 1 elements.

J'ai beau regarder dans les aides et FAQ, je ne vois pas d'où elle vient...
As-tu une idée?

[duf42]

Qu'y a t-il dans ta fonction Appel_dll, principalement à la ligne 3?

[marco_acmfan]

Voici ma fonction Appel_dll.m :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
%Test appel dll pour le modèle
 
lib_name=[Modele_1c, '_win64'];
 
if ~libisloaded(lib_name)
    loadlibrary(lib_name, [Modele_1c, '.h']);
end
 
calllib(lib_name, [Modele_1c '_initialize'], uint8(0));
 
param=calllib(lib_name, [Modele_1c '_P']);
 
param.Value.param_source=param_source;
param.Value.param_gain=param_gain;
 
tout=0:0.01:0.01;
yout=nan(size(tout));
 
for i=1:numel(tout)
    calllib(lib_name, [Modele_1c '_step']);
 
    output=calllib(lib_name, [Modele_1c '_Y']);
 
    yout(i)=output.Value.Out1;
end
 
calllib(lib_name, [Modele_1c '_terminate']);

J'ai simplement recopié ton exemple en spécifiant mes noms et en changeant le win32 en win64 puisque je suis en Windows 7 64 bits.

Lorsque je rentre dans ma fonction 'Flux libre' du modèle après l'erreur, il y a un point d'arrêt à la ligne de l'erreur...

[duf42]

A tout hasard, ton modèle s'appelle 'Modele_1c' ou c'est le nom de la variable qui contient le nom du modèle?