Utilisation de Matlab, Octave ou Scilab pour les sciences...

Utilisation de Matlab, Octave ou Scilab pour les sciences expérimentales

Matlab, Octave et Scilab sont fondamentalement des logiciels de mathématique et de modélisation. Matlab est un logiciel commercial vendu par la société Mathworks. Octave et Scilab sont des logiciels librement utilisables et copiables.

Octave est disponible sur www.octave.org. Ce logiciel a une syntaxe très proche de Matlab, et les programmes sont fortement compatibles.

Scilab est disponible sur www.scilab.org. C'est un logiciel qui n'est pas un simple clone de Matlab, mais qui a diverses particularités, et une syntaxe quelque peu différente.

Ils sont très puissants pour la manipulation de données numériques sous forme de matrices de nombres, ainsi que pour la représentation graphique de ces matrices de nombres.On trouve facilement de la documentation sur ces capacités.

Ils ont été choisis comme support de l'enseignement de l'informatique dans les classes préparatoires scientifiques BCPST (B.O.N°3 26 juin 2003), et en particulier pour l'épreuve d'informatique à l'oral du concours commun INA-ENSA (note SCAV/06/158). Le programme officiel de ces classes demande « une introduction à la programmation élémentaire, orientée vers la présentation d'une algorithmique généraliste, et non pas seulement vers la résolution de problèmes numériques. »

Sans entrer dans le détail des contradictions entre les notes de service et l'arrêté ministériel, l'objet de ce texte est d'essayer d'utiliser ces logiciels pour une utilisation en informatique généraliste liée aux sciences expérimentales.

Ainsi, on peut utiliser Matlab, Octave et Scilab pour l'utilisation de fichiers de données, pour la communication entre matériels informatiques, pour l'acquisition de données, etc.

Les trois logiciels Octave, Matlab et Scilab existent pour Windows tout autant que pour Linux. Les méthodes indiquées ici pour ces logiciels sont en principe valables pour les deux systèmes d'exploitation, même si le détail des recettes peut concerner seulement l'un d'entre eux. Comme le système Microsoft-Windows est beaucoup plus répandu dans les lycées français que le système Linux, les recettes décrites ici concernent surtout Windows. Pour plus de détails sur l'utilisation de Linux, contactez l'auteur.

Contactez aussi l'auteur pour lui signaler les erreurs, ou de meilleures solutions de programmation, ou des changements dans les logiciels...

Pierre DIEUMEGARDprofesseur de SVTLycée Pothier45044 Orléanscourriel : [email protected]

Matlab-Scilab en sciences expérimentales (2)

Table des matières1Un algorithme peut-il savoir s'il est exécuté par Matlab, Octave ou Scilab ?................................................................................3

1.1Test de la différence (Matlab-Octave) et Scilab....................................................................................................................31.2Différences entre Matlab et Octave.......................................................................................................................................31.3Branchement des programme vers des parties différentes selon l'exécution par Matlab, Octave ou Scilab......................... 4

2Limites de Matlab et Scilab pour le calcul numérique rapide........................................................................................................52.1Un exemple des limites de Matlab et Scilab en calcul numérique : calcul de pi par convergence d'une suite.....................52.2Que faire quand on a beaucoup de calculs numériques ?...................................................................................................... 6

3Echange de données avec les tableurs-grapheurs...........................................................................................................................73.1Envoi de données de Matlab-Scilab vers les tableurs........................................................................................................... 7

3.1.1 Sauvegarde par Matlab-Scilab de fichiers numériques...............................................................................................73.1.2Sauvegarde par Matlab-Scilab de fichiers contenant des chaînes de caractères...........................................................83.1.3Chargement par un tableur............................................................................................................................................9

3.2Lecture de données par Matlab-Scilab.................................................................................................................................. 93.2.1Données numériques provenant de tableurs................................................................................................................. 93.2.2Lecture de fichiers de chaînes de caractères...............................................................................................................10

4Mesure du temps.......................................................................................................................................................................... 124.1 Mesures assez lentes : date et heure actuelle......................................................................................................................12

4.1.1Matlab et Octave : clock............................................................................................................................................. 124.1.2 Getdate en Scilab....................................................................................................................................................... 12

4.2 Mesures plus rapides : millisecondes................................................................................................................................. 124.2.1timer en Scilab............................................................................................................................................................ 124.2.2Matlab et Octave: cputime, tic, toc.............................................................................................................................13

4.3Attendre pendant un certain temps...................................................................................................................................... 134.3.1Scilab : sleep et xpause............................................................................................................................................... 134.3.2Matlab et Octave : pause, sleep et usleep................................................................................................................... 13

5lancement de logiciels extérieurs................................................................................................................................................. 145.1Scilab : commandes du groupe unix (même pour Windows)..............................................................................................14

5.1.1les différentes commandes unix..................................................................................................................................145.1.2Utilisation de unix_g pour envoyer directement des résultats dans une matrice de Scilab........................................ 145.1.3Problème : Scilab n'admet pas plusieurs paramètres pour un programme exécutable................................................155.1.4utilisation des fonctions unix pour envoyer les résultats dans un fichier, à lire par Scilab........................................ 15

5.2Matlab et Octave : commande dos (dans le système Windows)..........................................................................................155.3Transformation de la chaîne de caractères en nombre (si le résultat doit être numérique)................................................. 165.4Exemples de mini-programmes d'acquisition de données .................................................................................................. 16

5.4.1Scilab.......................................................................................................................................................................... 165.4.2Octave et Matlab.........................................................................................................................................................16

6communication avec des périphériques RS232 (voie « série »)...................................................................................................176.1Ce qu'est la liaison sérielle (RS232 = V24).........................................................................................................................176.2Utilisation de pilotes exécutables qui renvoient une chaîne de caractères à l'écran............................................................176.3Matlab peut utiliser directement la liaison RS232.............................................................................................................. 186.4Octave ne peut pas directement utiliser la voie sérielle RS232...........................................................................................186.5Emploi d'une bibliothèque spécifique pour Scilab.............................................................................................................. 19

6.5.1Bibliothèque serial.dll.................................................................................................................................................196.5.2Fonctions programmées en Scilab pour la communication avec Orphy.....................................................................196.5.3Mesures avec Orphy................................................................................................................................................... 19

6.6Emploi de programmes externes pour la communication sérielle (Matlab, Octave, Scilab) grâce à de petits fichiers de texte.......................................................................................................................................................................................... 19

6.6.1Un exemple en turbo-pascal de "pilote" gérant la communication RS232.................................................................206.6.2utilisation de ce pilote par Scilab et Matlab............................................................................................................... 21

7Lecture de ports............................................................................................................................................................................22


1 Un algorithme peut-il savoir s'il est exécuté par Matlab, Octave ou Scilab ?Si l'on veut essayer de mettre au point un programme qui s'exécute dans les trois logiciels, il faut que chaque logiciel ne bloque pas l'exécution parce qu'il est arrivé à une instruction compréhensible uniquement par l'autre logiciel.Les différences essentielles sont entre (Matlab-Octave) et Scilab. Les différences entre Matlab et Octave sont beaucoup plus ténues.

1.1 Test de la différence (Matlab-Octave) et Scilab On peut se baser sur l'interprétation différente entre Matlab-Octave et Scilab de la longueur d'un ensemble de deux chaines.En Matlab-Octave, l'instructionx=['bla' 'bla']aboutit à une valeur de x égale à la chaine 'blabla', donc de longueur 6 caractères.

Au contraire, en Scilab, la même instructionx=['bla' 'bla']aboutit à une valeur de x égale à un vecteur-ligne de deux chaines, l'une égale à 'bla' et l'autre égale à 'bla'. La longueur de x (par la fonction length) donne un vecteur-ligne de 2 entiers égaux chacun à 3.

Les instructions ci-dessous permettent au logiciel d'afficher s'il est exécuté sous Matlab-Octave ou sous Scilab :

long_test=length(['bla' 'bla']);if (long_test(1)==6) disp('exécution sous matlab ou octave'); matlab=(1==1);scilab=(1==0);else disp('exécution sous scilab'); matlab=(1==0);scilab=(1==1);end

1.2 Différences entre Matlab et Octave Les deux logiciels comprennent la fonction version qui renvoie une chaîne de caractères indiquant la version du logiciel.La chaîne renvoyée par Matlab est du type : 7.3.0.22078La chaîne renvoyée par Octave est du type : 2.9.13Donc Octave renvoie une chaîne plus courte que Matlab. On peut imaginer faire la différence sur la longueur de chaîne : if length(version) > 10

disp('exécution sous Matlab');octave=0;else disp('exécution sous Octave');octave=1;end;

Les différences de programmation entre Matlab et Octave sont ténues, et beaucoup de petits scripts conçus pour l'un fonctionnent directement sur l'autre.Mais une (grosse ?) différence au niveau de la programmation est dans la définition des fonctions. Normalement, en Matlab, chaque fonction doit se trouver dans un fichier particulier, portant le nom de la fonction, et d'extension .m. Comme chaque fichier ne contient qu'une seule fonction, il n'y a pas d'instruction indiquant la fin de définition d'une fonction : c'est simplement la fin du fichier.Cette syntaxe est valable aussi en Octave. Mais Octave permet aussi de faire des fichiers contenant à la fois des fonctions et le script qui les utilise. Ainsi, en un seul fichier, on a la totalité du programme, ce qui facilite l'impression sur papier.


1.3 Branchement des programme vers des parties différentes selon l'exécution par Matlab, Octave ou ScilabA la suite du test précédent, lorsque le programme s'exécutait sous Matlab, la variable matlab prenait la valeur "vraie", et la variable scilab prenait la valeur "faux" (et inversement pour l'exécution sous Scilab).On peut donc faire des programmes compatibles avec les deux environnements. Certaines instructions ne seront exécutées que si scilab est vrai, d'autres le seront si scilab est faux.


2 Limites de Matlab et Scilab pour le calcul numérique rapide Les fonctionnalités mathématiques de Matlab et Scilab sont basées sur un noyau de fonctions écrites en Fortran ou en C, qui sont compilées, c'est à dire déjà traduites en langage-machine. Ces fonctions préexistantes sont donc très rapides à exécuter.

Par ailleurs, Matlab et Scilab ont des capacités de langage de programmation interprétée, c'est à dire que chaque instruction est transformée en langage-machine au moment même de son exécution. La transformation des instructions au moment de l'exécution rend cette exécution assez lente.

2.1 Un exemple des limites de Matlab et Scilab en calcul numérique : calcul de pi par convergence d'une suite.On démontre que la suite1 -1/3 + 1/5 -1/7 +1/9....converge vers pi/4

Un exercice classique en algorithmique est donc de faire le calcul de cette suite, soit sur un nombre défini de termes, soit jusqu'à ce que la différence entre deux termes successifs soit inférieure à un seuil fixé.

Ici est présenté l'algorithme qui calcule les dix mille premiers termes, puis affiche la valeur de pi, considérée comme le résultat multiplié par 4.

//calculpi en Scilab;signe=-1;somme=1;disp('début des calculs :');for i=1:10000

somme=somme+signe/(2*i+1);signe=-signe;end;

disp('pi calculé vaut :'+string(somme*4));

L'algorithme en Matlab est très similaire :%calculpi en Matlabsigne=-1;somme=1;disp('début des calculs :');for i=1:10000

somme=somme+signe/(2*i+1);signe=-signe;end;

disp(strcat('pi calculé vaut :',num2str(somme*4)));

A titre de comparaison, voici le même algorithme en Pascal :(*calculpi en pascal*) program testpi;uses wincrt;var somme:real; signe:integer; i:longint;

begin somme:=1; signe:=-1; writeln('début du calcul '); for i:=1 to 10000 do begin Somme:=Somme+ signe/(i*2+1); signe:=-signe; end; writeln(' pi vaut :',somme*4:10:6); readln;end.


Résultat (ordinateur Pentium à 700 MHz) : - En Scilab, avec une boucle de seulement 10000 répétitions, il faut 3 secondes pour aboutir à 3.14169. On peut imaginer qu'il faudrait 300 secondes, soit 5 minutes, pour faire une boucle de 1000000 répétitions.- En TurboPascal, avec une boucle de 1000000 répétitions, il faut 3 secondes pour aboutir à 3.141594, soit une précision environ 100 fois meilleure.- Matlab et Octave donnent des résultats intermédiaires : la boucle de 1000000 répétitions est faite en une douzaine de secondes pour Matlab et en 112 secondes pour Octave.

Quelle est l'origine de la différence entre Pascal et les logiciels mathématiques ?Cette différence doit venir fondamentalement du fait que Pascal est un langage compilé, c'est à dire que toutes les instructions sont traduites en langage-machine AVANT leur exécution, ce qui permet une exécution beaucoup plus rapide.

Quelle est l'origine de la différence entre Matlab et Scilab, qui sont tous deux des langages interprétés ?Peut-être une meilleure programmation des fonctions internes de Matlab par rapport à Scilab ?Peut-être une meilleure utilisation du microprocesseur ? Normalement, d'après ce que j'ai cru comprendre, Matlab et Scilab codent toutes les valeurs numériques en "complexes double-précision", sur lesquels les calculs sont beaucoup plus longs que sur des entiers ou même des réels ("nombres à virgule flottante"). On peut donc imaginer que Matlab se rend compte que les calculs se font grâce à des entiers (ensemble des 1/n), et que le résultat est un réel, et non un complexe... ce qui aboutirait à un calcul plus rapide.

2.2 Que faire quand on a beaucoup de calculs numériques ? La réponse est simple : il faut utiliser au maximum les fonctions préprogrammées de Matlab et Scilab (qui sont compilées), et ne pas réécrire soi-même les algorithmes (puisqu'ils seraient interprétés).

C'est quand même dommage pour l'enseignement d'algorithmique de devoir minimiser les algoritmes !


3 Echange de données avec les tableurs-grapheurs Les tableurs-grapheurs sont des logiciels spécialisés dans la présentation de données sous forme de tableaux.Ils sont normalement capables de faire des calculs complexes et de belles représentations graphiques, ainsi que de sauvegarder les données dans des formats variés.

Les deux logiciels Matlab et Scilab permettent de créer des fichiers-textes plus ou moins compliqués, en ouvrant un fichier, puis en écrivant dans ce fichier, et enfin en fermant le fichier. Ici, il sera surtout question d'un fonctionnement simple : la sauvegarde "directe" et la lecture d'une seule matrice (ou vecteur, ou donnée) dans un fichier.

Le maniement des fichiers de nombres est simple. Le maniement des fichiers de chaînes de caractères beaucoup plus compliqué. Il faut essayer d'utiliser des chaînes de caractères ne contenant pas d'espace, et les sauvegarder ou les lire dans des fichiers ne contenant qu'une seule colonne de chaînes. On peut éventuellement remplacer, à l'aide d'un programme de traitement de texte, l'espace par le caractère 255, qui a l'aspect de l'espace, mais n'a pas le même code.

Quelques fonctions à connaître :En Scilab, ascii(car) et str2code(car) renvoient le code ASCII du caractère car, et code2str(num) renvoie le caractère correspondant au nombre num dans le code ASCII. Pour transformer une chaîne en nombre, utiliser eval(chaine) ou evstr(chaine) ; pour transformer un nombre en chaîne, utiliser string(nombre)

En Matlab, double(car) renvoie le code ascii du caractère car, et char(n) renvoie le caractère de code n. Pour transformer un chaîne en nombre, utiliser eval(chaine), comme en Scilab ; pour transformer un nombre en chaîne, utiliser num2str(nombre).

3.1 Envoi de données de Matlab-Scilab vers les tableurs

3.1.1 Sauvegarde par Matlab-Scilab de fichiers numériques

3.1.1.1 Sauvegarde par MatlabLa commande la plus simple pour sauver la variable A dans le fichier "monfich.txt" est save 'monfich.txt' A -ascii ou save -ascii 'monfich.txt' A(on peut ausi mettre -text au lieu de -ascii)Chaque ligne de "monfich.txt" correspond à une ligne de la matrice A. Les différents éléments de la ligne sont sous forme "mantisse + exposant", par exemple 4.000000e+000, séparés par des espaces.

Pour que le séparateur soit une tabulation (caractère ASCII 9), ce qui facilite souvent l'importation par d'autres logiciels, rajouter -tabs à la fin de la commande.

Pour sauvegarder la matrice M en format WK1 (format assez standard des tableurs), utiliser :wk1write('nomfich.wk1',M)

Une commande très pratique pour sauvegarder la matrice M en format "délimité" est dlmwrite :dlmwrite ('monfich.txt',M,'\t')Le dernier paramètre est le délimiteur. Ici, c'est la tabulation ; si on veut utiliser un caractère imprimable (, / ou \ par exemple), il faut l'indiquer à cette place : ',' ou '/' ou '\'...On peut compliquer cette commande en rajoutant le numéro de la ligne et le numéro de la colonne à partir de laquelle commencer la sauvegarde :dlmwrite(nomfichier,matrice,delimiteur,nl,nc);


3.1.1.2 Sauvegarde par Octavesave -text 'monfich.txt' M ou save ("-text","monfich.txt","M") sauvegarde la variable M dans le fichier monfich.txt.Le fichier résultant comporte quelques lignes de commentaire au début, ce qui peut gêner la lecture par d'autres logiciels. Les instructions save_header_format_string ('')

save -ascii 'monfich.txt' M ou save ("-ascii","monfich.txt","M") sauvegarde la variable M dans le fichier monfich.txt, mais avec un format un peu différent. Il n'y a pas de commentaires, mais les valeurs numériques sont sous la forme mantisse + exposant (4.40000000e+000), ce qui perturbe aussi d'autres logiciels.

dlmwrite('essai.txt',M) mets la variable M dans le fichier essai.txt (format .csv).Pour mettre le point-virgule comme séparateur, utiliser la syntaxe dlmwrite('essai.txt',M,';',0,0)

3.1.1.3 Sauvegarde par ScilabPour sauvegarder la variable A dans le fichier "monfich.txt", il suffit de frapper : write('monfich.txt', A)Chaque ligne de "monfich.txt" correspond à une ligne de la matrice A. Les différents éléments de la ligne sont séparés par des espaces.Les zéros sont écrits sous forme mantisse+exposant (0.000000000000000E+000), ce qui peut poser des problèmes à la lecture par les tableurs ou les autres logiciels. Une méthode simple est de supprimer le E+ par un éditeur de texte (recherche et remplacement automatique).

Heureusement, la fonction sci2excel permet de sauvegarder en format texte :sci2excel(var,fname,sep,dec)où var est la variable à sauvegarder, fname le nom du fichier, sep le séparateur de champs et dec le séparateur décimal.Par exemple sci2excel(A,'monfich.txt',',','.')

3.1.2 Sauvegarde par Matlab-Scilab de fichiers contenant des chaînes de caractères C'est moins simple, car ces logiciels sont fondamentalement conçus pour traiter des nombres, et non des chaînes de caractères.

3.1.2.1 sauvegarde directe par MatlabCette sauvegarde semble impossible en format ASCII.Il faut réaliser une fonction spécialisée :

function savetext(filename,s) fid = fopen(filename,'w'); [r c]=size(s); for i=1:r for j=1:c fprintf(fid,'%s',char(s(i,j))); if j<c fprintf(fid,'%s\t','');end; end fprintf(fid,'%s\r\n',''); end fclose(fid);

Ensuite, lorsqu'on a un vecteur de chaînes, par exemple VCH={'ligne 1' ; 'ligne 2' ; 'ligne 3'} à sauvegarder, il suffira de frapper :savetext('nomfich.txt',VCH);


3.1.2.2 sauvegarde directe par ScilabUn vecteur de chaîne peut être sauvegardé par Scilab par la commande write, comme pour les nombres.Malheureusement cette recette ne fonctionne pas pour les matrices de chaînes à 2 dimensions, car les éléments d'une ligne de la matrice sont écrits sur des lignes différentes dans le fichier.

Il faut donc d'abord concaténer les chaînes, puis sauvegarder la chaîne résultante.

3.1.3 Chargement par un tableur

3.1.3.1 fichiers venant de MatlabExcel version 5 : lecture facile, en prenant Fichier/ouvrir, puis Fichier-texte, et Largeur fixe (ou Délimité, puis Espace).

Lotus 123-97 : importe facilement et directement les fichiers-texte, avec analyse automatique.

QPW version 5 : comme les nombres sont sauvegardés en format "5.0000000e+000", ils sont importés comme des chaînes de caractères, et non comme des valeurs numériques !

3.1.3.2 fichiers venant de ScilabExcel version 5 : lecture facile, en prenant Fichier/ouvrir, puis Fichier-texte, et Largeur fixe (ou Délimité, puis Espace).

Lotus 123-97 : importe facilement et directement les fichiers-texte, avec analyse automatique.

QPW version 5 : ouvrir une table vierge, puis choisir Outils/importation. Sélectionner le nom du fichier, et choisir "expert reformatage".QPW version 7 : semble n'importer correctement que les fichiers où le séparateur est la tabulation.

3.2 Lecture de données par Matlab-Scilab

3.2.1 Données numériques provenant de tableurs

3.2.1.1 Lecture par MatlabC'est simple pour les fichiers-textes :A=load('qpw5.txt')

Pour d'autres formats de fichiers, on peut utiliser :- format Excel :A=xlsread('nomfich.xls')- format WK1A=wk1read('nomfich.wk1')- format texte délimité :A=dlmread('nomfich.txt','\t')(le deuxième paramètre indique le séparateur de champs, ici la tabulation ; pour les caractères normaux, on les mets simplement entre apostrophes : ',' ou ';' ou ' '...).

3.2.1.2 Lecture par Octaveload ("-text", "file.txt", "a") fait l'opération inverse de save : charge le fichier-texte "file.txt" dans la variable a.


Comme pour save, on peut utiliser l'option -text (avec en-tête) ou l'option -ascii (sans en-tête).La fonction la plus pratique est dlmread :Utiliser la syntaxe H=dlmread('essai.txt',',') pour lire un fichier à la norme csv. Si le séparateur n'est pas la virgule, il faut l'indiquer en deuxième paramètre (H=dlmread('essai.txt',';').Si l'on veut commencer la lecture à une certaine ligne nl (et à une certaine colonne nc), mettre :H= dlmread('essai.txt',',',nl,nc)(attention : la première ligne et la première colonne ont le numéro 0)

xlsread existe aussi.

3.2.1.3 Lecture par ScilabC'est presque aussi simple pour les fichiers-textes : simplement, il faut indiquer :- le nombre de lignes à lire (si on veut lire jusqu'au bout du fichier, mettre -1)- le nombre de colonnes à lire

Par exemple : B=read('qpw5.txt',-1,3)

Pour les fichiers de type .xls (Excel, Gnumeric, OpenOffice), les versions modernes de Scilab ont directement la fonction readxls : feuilles = readxls(nomfichier)

Tous les tableurs (Excel, OpenOffice, Gnumeric) peuvent utiliser les fichiers de type .csv, c'est à dire où les champs sont séparés par des virgules, et où le séparateur décimal est le point. Malheureusement, certaines versions francisées (Excel en particulier) utilisent une syntaxe différente, où les champs sont séparés par des points-virgules et où le séparateur décimal est la virgule, tout en gardant l'extension .csv. Dans ce cas, il faut remplacer les virgules par des points, et les points-virgules par des virgules à l'aide d'un éditeur de texte et des fonctions "rechercher/remplacer tout".Il est possible aussi de séparer les champs par des tabulations (extension en .tab ou autres).Les versions récentes de Scilab ont la fonction excel2sci, qui lit directement un tel fichier, sans qu'on ait à se soucier du nombre de lignes et du nombre de colonnes.tableau=excel2sci(nomfichier).Si le séparateur de champs n'est pas la virgule, on l'indique en deuxième paramètre :tab2 = excel2sci(nomfichier, ";");

3.2.2 Lecture de fichiers de chaînes de caractères C'est possible, mais ce n'est vraiment pas la spécialité de ces logiciels de calcul numérique.

3.2.2.1 Lecture par Matlab

X= textread('lignes.txt','%s')permet d'envoyer dans la matrice X le contenu de lignes.txt, à condition qu'il n'y ait qu'une seule colonne de texte, sans espaces, puisque par défaut le délimiteur entre les colonnes semble être l'espace...On peut rajouter le délimiteur (par exemple '\t' pour la tabulation :X= textread('lignes.txt','%s','delimiter','\t').Ceci doit permettre de lire des fichiers dont les lignes de texte sont "normales", c'est à dire avec des espaces entre les mots.

Si cela ne convient pas, on peut essayer la formule suivante :machaine=textread('fichres.txt','%c','whitespace','\t')'Quelques explications :l'instruction %c indique que l'on lit une chaîne de caractères.«whitespace» et «\t» indique que le caractère «espace» est la tabulation. Ceci peut paraître idiot, car il n'y a pas de tabulation dans le fichier, et que les espaces sont des vrais espaces entre les mots. Oui, mais si on ne met pas cette instruction, les espaces disparaissent dans la chaîne finale.


Enfin, le caractère «'» final permet d'avoir une chaîne en ligne, alors que lorsqu'on l'omet, la chaîne est affichée en colonne. Ce n'est pas simple !

3.2.2.2 lecture par ScilabB=read('lignes.txt',-1,1,'(A)')permet de lire dans la matrice B le contenu de lignes.txt, sur une colonne.Les espaces sont possibles dans les chaînes de caractères, mais des sauts de lignes dans la matrice sont ajoutés entre chaque ligne du fichier... On peut les enlever par l'algorithme suivant, qui transforme la matrice A (ayant des lignes vides) en matrice B (sans ligne vide) :B=A(1)for i=2:length(A)

if length(A(i))>1 then B=[B;A(i)];end;

end;


4 Mesure du temps Ces deux logiciels ont des fonctions de mesure du temps, ce qui est indispensable dans de nombreuses circonstances : soit pour évaluer l'efficacité d'un algorithme, soit pour faire l'acquisition de données...

4.1 Mesures assez lentes : date et heure actuelle

4.1.1 Matlab et Octave : clock La fonction clock donne une matrice-ligne de 6 nombres, qui sont dans l'ordre :- l'année- le mois- le jour- l'heure- la minute- la seconde

On peut donc donner les instructions :tabtemps=clock;annee=tabtemps(1);mois=tabtemps(2);jour=tabtemps(3);heure=tabtemps(4);minute=tabtemps(5);secondes=tabtemps(6);

Si l'on veut faire des calculs en une seule unité (par exemple uniquement des secondes, pour suivre le système international d'unités, ou en années ...), il faut faire des opérations assez complexes. Ce n'est pas très simple d'en faire des calculs, mais heureusement, il existe aussi la fonction etime qui renvoie l'intervalle en secondes entre deux dates au format renvoyé par clock : diff=etime(t2,t1)

now () renvoie un nombre dont la partie entière est la date d'aujourd'hui (à partir du 1er janvier 0000) et la partie fractionnaire est l'heure actuelle (en fraction de jour). Il paraît que l'heure est l'heure locale en Matlab, mais que c'est l'heure GMT (Temps Universel) en Octave.

time() renvoie le nombre de secondes (en principe depuis le 1er janvier 1970).cputime renvoie le nombre de secondes depuis le lancement du logiciel.

4.1.2 Getdate en Scilab Normalement, la fonction getdate() fait la même chose en Scilab que clock en Matlab-octave.

tabtemps=getdate();

Une variante est x=getdate("s"), qui renvoie le nombre de secondes de puis le 1er janvier 1970 à 00:00 h.

4.2 Mesures plus rapides : millisecondes

4.2.1 timer en Scilab timer() renvoie le temps en secondes écoulé depuis le dernier appel à cette même fonction timer. La précision affichée est la milliseconde, mais elle doit être très variable dans la réalité, en fonction des autres tâches effectuées par l'ordinateur.


pvm_get_timer() renvoie le temps écoulé depuis le dernier appel à pvm_get_timer ou à pvm_set_timer (en microsecondes). (pvm_set_timer() initialise le chronomètre).

4.2.2 Matlab et Octave: cputime, tic, toc cputime renvoie le temps en secondes écoulé depuis le lancement de Matlab.

Deux fonctions particulières permettent de chronométrer la durée d'un processus :tic déclenche un chronomètretoc arrête le chronomètre et affiche le résultat.

Par exemple, pour chronométrer la durée de l'opération ma_fonction, on lance la séquence suivante :ticma_fonctiontocet la durée consommée par mafonction est affichée à l'écran. On peut aussi faire t=toc, et la durée est envoyée dans la variable t.

4.3 Attendre pendant un certain temps

4.3.1 Scilab : sleep et xpause sleep(ms) interrompt l'exécution du programme pendant ms millisecondes.xpause(us) interrompt l'exécution du programme pendant us microsecondes.

4.3.2 Matlab et Octave : pause, sleep et usleep pause (s) et sleep(s) interrompent l'exécution du programme pendant s secondes.usleep(us) interrompt le programme pendant us microsecondes.

Attention aux fonctions de même nom et d'effet différent ! – sleep existe aussi bien en Matlab-Octave qu'en Scilab, mais le paramètre en est des

secondes pour Matlab-Octave et des millisecondes pour Scilab ! – pause en Matlab-Octave provoque l'arrêt pendant un certain temps fixé par le paramètre,

alors que pause en Scilab provoque l'arrêt jusqu'à un retour déterminé au clavier par "return".


5 lancement de logiciels extérieurs Scilab et Matlab sont des logiciels spécialisés dans le traitement de valeurs numériques, et ne sont pas directement capables d'exploiter toutes les ressources de l'ordinateur. D'autres logiciels, soit disponibles dans le système d'exploitation, soit réalisés dans un but particulier, ont des capacités différentes.

Prenons comme exemple un petit programme « thermo.exe » capable de lire une mesure sur un appareil (par exemple une température en degrés Celsius). Lorsqu'on le lance, il fait la mesure et affiche le résultat à l'écran, sous la forme d'une chaîne de caractères du type « 20.5 ».

Il faut que Matlab, Scilab et Octave puissent lancer le programme en question, et récupérer les informations qui auraient dû être affichées à l'écran, et finalement transformer la chaîne de caractères en valeur numérique.

5.1 Scilab : commandes du groupe unix (même pour Windows) Scilab a été apparemment développé fondamentalement pour le monde Unix, et ensuite porté sous Windows.Il a un groupe de commandes commençant par "unix", et qui lancent des commandes du système d'exploitation. En particulier, ces commandes unix permettent de lancer des programmes extérieurs, et de récupérer le résultat de ces programmes, soit dans des variables, soit dans des fichiers. Ainsi, Scilab peut profiter de la puissance de ces commandes ou de ces programmes extérieurs.Il faut le savoir : ces commandes "unix" ne sont pas réservées aux systèmes d'exploitations de type Unix ou Linux, mais elles fonctionnent aussi très bien dans le système d'exploitation Windows.

5.1.1 les différentes commandes unix unix(commande) : le résultat affichable éventuel de la commande est envoyé dans la fenêtre Scilex. Par exemple unix("dir") provoque l'affichage du contenu du répertoire courant dans la fenêtre Scilex.

unix_s(commande) : la commande est exécutée, mais son résultat affichable éventuel n'est pas affiché.

unix_w(commande) : la commande est exécutée, et son résultat affichable éventuel est affiché dans la fenêtre de commande Scilab.

unix_x(commande) : le résultat est envoyé dans une nouvelle fenêtre unix.out.

x=unix_g(commande) : le résultat de la commande (ou du programme) est envoyé dans la variable x. C'est la commande la plus intéressante en programmation.

5.1.2 Utilisation de unix_g pour envoyer directement des résultats dans une matrice de ScilabSi l'on veut utiliser la commande dir de MS-DOS qui donne la liste et les caractéristiques des fichiers du répertoire en cours, il suffit de l'instruction scilab :x=unix_g("dir");pour obtenir dans variable x le vecteur-colonne contenant la liste des fichiers.

Supposons qu'on veuille faire réaliser des mesures par Scilab toutes les x secondes sur un appareil extérieur.

On peut donc faire un mini-programme en Pascal qui fait une mesure sur un appareil chaque fois qu'on le lance,et affiche le résultat (de type writeln(mamesure)), puis se termine. Il faut simplement penser à un détail : ne pas utiliser l'unité crt pour l'affichage, car le résultat serait affiché dans une vraie fenêtre DOS, et ne serait pas renvoyé vers la variable Scilab.


Par exempleprogram mesure;begin (*mettre ici les instructions de mesure, éventuellement en fonction des paramètres de la ligne de commande... ; le résultat est envoyé dans la variable resultat*) writeln('résultat de la mesure :'); writeln(resultat);end.

Ensuite, la commandex=unix_g("mesure.exe 4") lancera le logiciel mesure.exe avec 4 comme ligne de commande (par exemple pour signifier qu'il faut faire la mesure sur la 4e voie...) et récupèrera l'affichage dans la variable x. x(2) contiendra donc le résultat.

5.1.3 Problème : Scilab n'admet pas plusieurs paramètres pour un programme exécutableLes exemples précédents lançaient un programme exécutable ("mesure.exe") avec un paramètre ("4"). Malheureusement, les versions actuelles de Scilab sous Windows (au moins) ne semblent pas accepter des paramètres multiples (par exemple "mesure.exe 4 1.24" qui pourrait signifier faire la mesure sur la voie 4 avec un coefficient de correction de 1.24). Que faire ?– Faire des programmes exécutables spéciaux qui reçoivent les divers paramètres en un seul, qui

serait découpé ensuite par le programme, par exemple "mesure.exe 4_1.24", si le programme mesure.exe est capable de découper la chaîne de caractères 4_1.24 en deux morceaux, 4 et 1.24. C'est compliqué.

– Regrouper les instructions exécutables dans un fichier .bat. Un petit problème est que le résultat renvoyé vers Scilab contient plusieurs lignes, dont il ne faut prendre que la dernière. Avec l'exemple précédent :- faire un fichier faitmesure.bat qui contient la ligne "mesure.exe 4 1.24"- lancer l'instruction Scilab resultat= unix_g('faitmesure.bat');- récupérer la mesure par chmesure=resultat(3);C'est le plus simple.

5.1.4 utilisation des fonctions unix pour envoyer les résultats dans un fichier, à lire par ScilabLa méthode précédente était utilisable lorsque le logiciel se termine en affichant quelque chose à l'écran.On peut aussi utiliser unix("dir >essai.txt");pour envoyer le résultat dans le fichier essai.txt, que l'on pourra ensuite charger par la commande B=read('essai.txt');

C'est un peu plus compliqué, mais plus universel.

5.2 Matlab et Octave : commande dos (dans le système Windows) La commande dos lance la commande passée en paramètre.dos('dir');provoque l'affichage de la liste des fichiers du répertoire courant.

Dans notre exemple, dos('thermo.exe') provoque l'affichage de la température.

Pour récupérer les valeurs affichées, il faut une syntaxe un peu plus complexe, avec un double résultat :[x, y] = dos('dir') : la variable y reçoit la liste des fichiers.[x,y] = dos('thermo.exe') : la variable y reçoit la chaîne de caractères indiquant la température.

Pour Octave, on peut aussi employer la commande system("thermo.exe"), qui devrait avoir l'avantage d'être utilisable aussi bien sous DOS/windows que sous Linux.


5.3 Transformation de la chaîne de caractères en nombre (si le résultat doit être numérique)Si chy est la chaîne de caractères reçue précédemment, par exemple 20.5, il faut la transformer en une valeur numérique :– Scilab : n=evstr(chy);– Matlab et Octave : n=str2num(chy);

5.4 Exemples de mini-programmes d'acquisition de données

5.4.1 Scilab //essai d'exao-démo pour Scilablines(0);A=[];nbmesures =input("nombre de mesures à faire ?")intervalle=input("nombre de secondes entre mesures ?")t0=getdate("s")for i=1:nbmesures t=getdate("s")-t0; while t<intervalle*i t=getdate("s")-t0; end; resultat=unix_g('faitmesure2.bat'); chmesure=resultat(3); y=evstr(chmesure); A=[A;t y]; disp(A); end;disp('fin du programme');

5.4.2 Octave et Matlab %exao_demo_matlab (valable aussi pour Octave)A=[];more off;nbmesures=input('nombre de mesures ? ');intervalle=input('nombre de secondes entre mesures ? ');t0=cputime;for i=1:nbmesures t=cputime-t0; while t<intervalle*i t=cputime-t0; end; [erreur,chmesure]=dos('pilexwzl_capman.exe ead 0'); y=round(str2num(chmesure)); A=[A;round(t) y]; disp(A); disp('');end;disp('fin du programme');


6 communication avec des périphériques RS232 (voie « série »)

En sciences, plusieurs sortes de périphériques sont utilisables : - des appareils de mesure ou des actionneurs- d'autres ordinateurs ou appareils informatiques.

Certains de ces périphériques sont connectables par liaison série (certaines imprimantes, modem, multimètre, oscilloscope, appareils de mesure...).

6.1 Ce qu'est la liaison sérielle (RS232 = V24) La communication entre les appareils (ordinateur d'une part, périphérique d'autre part) se fait par des fils électriques."Série" signifie que les signaux (les bits) sont envoyés en série, c'est à dire l'un derrière l'autre. Le contraire serait une liaison "parallèle", où les signaux seraient envoyés "en parallèle" sur des fils différents : c'est le cas de la plupart des imprimantes.

L'intérêt de la liaison RS232, c'est qu'il suffit de 3 fils pour assurer la communication entre deux appareils A et B. Il faut bien sûr un fil de référence électrique ("masse"), un fil pour envoyer les signaux dans un sens (A vers B), et un fil pour envoyer les signaux dans l'autre sens (B vers A).

La prise normalisée RS232 était une prise à 25 broches. Actuellement, elle est souvent réduite à une prise à 9 broches mâle, située à l'arrière de l'ordinateur.D'autres appareils ont des prises différentes : l'Apple IIc avait un prise DIN à 5 broches, le Macintosh une prise mini-din, certains multimètres une prise jack ...

Dans tous les cas, l'important est de connaître les trois fils importants : masse ("ground"), transmission de données ("TD" ou "TX") et réception de données ("RD" ou "RX").

Il suffit de relier les fils de masse des deux ordinateurs, de relier le fil TD de l'un au fil RD de l'autre, et inversement.

D'autres fils existent, mais sont moins indispensables. Ils servent à synchroniser les émissions de données, ou à indiquer l'état de l'appareil.

Dans les paragraphes qui suivent, il sera surtout question de la communication avec le boitier de mesure Orphy GTS. Celui-ci communique à 9600 bits par seconde, 8 bits de données, 1 bit de stop, sans parité. Lorsqu'on lui envoie le message "XEA 0" (suivi d'un retour-chariot, c'est à dire le caractère 13), il fait la mesure sur l'entrée analogique 0, et envoie le résultat sous la forme d'un nombre entre 0 et 255, suivi d'un retour-chariot.Pour Orphy Portable 2, la syntaxe est du type "ZEA 0", mais le principe est le même.

6.2 Utilisation de pilotes exécutables qui renvoient une chaîne de caractères à l'écranLe principe est celui décrit dans le paragraphe 5 (lancement de logiciels extérieurs). – Matlab, Scilab ou Octave lancent un programme exécutable– Ce programme exécutable envoie une chaîne de caractères vers l'appareil de mesure par

l'intermédiaire de la liaison RS232– L'appareil renvoie la valeur de la mesure sous forme d'une chaîne de caractère– Le programme exécutable renvoie cette chaîne vers Matlab, Scilab ou Octave.

Exemple : un programme en Delphi 5 pour utiliser Orphy Portable 2

program interroge_RS232_param; {$APPTYPE CONSOLE}


uses ucommw32,sysutils;

var fichenvoi,ficharrivee,fparam:text; carlu:char; nomarrivee,nomenvoi:string; chlue,chparam:string; t1,t2:double; i:integer;

begin chaineinit:='baud=9600 parity=n data=8 stop=1' + NUL; monport:='Com1:'; assignfile(fparam,'param_interroge.txt'); //lecture du fichier de configuration reset(fparam); readln(fparam,monport); //mettre en première ligne le port : Com1: if not eof(fparam) then readln(fparam,chaineinit); //mettre en 2e ligne les réglages for i:=1 to length(chaineinit) do if chaineinit[i]=',' then chaineinit[i]:=' '; chparam:=paramstr(1); //passer en paramètres la chaîne à envoyer, for i:=1 to length(chparam) do if chparam[i]=',' then chparam[i]:=' '; // les virgules sont transformées en espaces (pour Scilab essentiellement) initialise; envoiechaine(chparam+chr(13)); chlue:=''; chlue:=recoitchainerc; ferme; if length(chlue)=0 then chlue:='-777'; writeln(chlue);end.

6.3 Matlab peut utiliser directement la liaison RS232 Matlab a directement des fonctions de gestion RS232. Par exemple le programme suivant initialise le port sériel Com2: à 9600 bauds, 8 bits de données, 1 bit de stop, et avec le retour chariot ("CR" = caractère 13) comme terminateur de ligne d'instruction, ce qui permet la communication facile avec le matériel Orphy.

% essai d'orphy directement avec matlab

s=serial('com2','baudrate',9600,'databits',8,'stopbits',1,'Terminator','CR')% C'était l'initialisationfopen(s)fprintf(s,'XASC')%c'était pour indiquer à Orphy de communiquer en mode ASCIIfprintf(s,'XSA 200')%c'était pour fixer la sortie analogique à 200fprintf(s,'XEA 1')%on envoie les caractères comme on écrit dans un fichier : ici lecture de l'entrée analogique 1 x=fgetl(s)%c'était la lecture de la réponsedisp(strcat('l''entrée analogique 1 vaut :',x))disp(strcat('ce qui correspond à ',num2str(str2num(x)*5000/255),' millivolts'))fclose(s)delete(s)clear s

Par la même méthode, on doit pouvoir communiquer avec toutes sortes de multimètres, oscilloscopes, thermomètres, luxmètres, pHmètres... ayant une sortie RS232.

On doit aussi pouvoir faire communiquer deux ordinateurs entre eux, ou bien communiquer avec un minitel ou un modem...

6.4 Octave ne peut pas directement utiliser la voie sérielle RS232 Dommage : il faut donc soit utiliser des programmes lancés par la commande dos (ou exec) comme décrits ci-avant, soit utiliser un programme de surveillance qui utilise de petits fichiers (comme décrits ci-après).


6.5 Emploi d'une bibliothèque spécifique pour Scilab

6.5.1 Bibliothèque serial.dll Tel quel, Scilab ne permet pas la communication par RS232, mais il existe une bibliothèque dynamique (pour Windows) disponible sur http://www.gds-sw.de/goodies.htm : chargez le fichier serial.zip, et décompactez-le dans le répertoire de travail de Scilab. La bibliothèque serial.dll ajoute des fonctions de communication à Scilab.

6.5.2 Fonctions programmées en Scilab pour la communication avec Orphy – initialiseRS232 ouvre la voie Com1: avec les paramètres convenables pour Orphy– (ferme : pour fermer la voie en question lorsqu'on a fini)– envoiechainerc envoie la chaîne ch passée en paramètre, en terminant par un retour chariot

(caractère 13)– litchainerc lit la chaîne renvoyée par Orphy.

global monhandle;

function initialiseRS232;dll_link = c_link('serial');if ~dll_link, addinter('serial.dll','serial',[ 'opencom';'closecom'; 'writecom'; 'writebincom';'readbincom';'resetcom';'getcomhandles']);end;com_config = tlist(['Config';'port';'baudrate';'nbits';'parity';'stopbits';'protocol'],1,9600,8,0,1,0);monhandle = opencom(com_config); endfunction;

function ferme;ok = resetcom(handle);ok = closecom(handle);endfunction;

function ok=envoiechainerc(ch);ok = writecom(monhandle,ch);ok = writebincom(monhandle,[ 13]);endfunction;

function ch=litchainerc;[inbytes,ok,nbytes] = readbincom(monhandle,100);chloc=ascii(inbytes);pos=strindex(chloc,ascii([13]));if length(pos)>0 chloc=strsplit(chloc,pos); endch=chloc(1);endfunction;

6.5.3 Mesures avec Orphy Par exemple, avec Orphy Portable 2, envoiechainerc('ZEA 0') provoque la prise de mesure sur la première voie de mesure (voie 0), et chmesure=litchainerc récupère la réponse d'Orphy dans la chaîne chmesure.

6.6 Emploi de programmes externes pour la communication sérielle (Matlab, Octave, Scilab) grâce à de petits fichiers de texte

Par rapport aux vieilles versions de MS-DOS, Windows n'a pas comme seul avantage l'utilisation de polices de caractères de toutes les formes et de toutes les tailles. Un intérêt souvent méconnu de Windows (ou de Linux) est le fonctionnement en multi-tâches.


Ainsi, on peut lancer plusieurs programmes simultanément : Windows répartit le temps d'utilisation du microprocesseur entre ces divers programmes, qui s'exécutent en même temps. Bien sûr, lorsque plusieurs programmes fonctionnent simultanément, chacun d'eux travaille moins vite que s'il était seul.

On peut donc imaginer de petits programmes dont le rôle unique serait d'échanger des données avec un appareil extérieur par voie sérielle. Ils liraient les données à envoyer dans un fichier spécialisé (par exemple "envoi.txt"), et écriraient les données reçues dans un autre fichier spécialisé (par exemple "arrivee.txt").

Comme Scilab peut lire et écrire dans les fichiers, par cet artifice, il serait capable d'envoyer et de lire des données par la voie RS232.

6.6.1 Un exemple en turbo-pascal de "pilote" gérant la communication RS232 Le programme ci-dessous utilise l'unité ucomm, permettant la communication RS232. Il existe de nombreuses unités de ce type dans le domaine public.

program transfert;uses dos,crt,ucomm;var fichenvoi,ficharrivee:text; carlu:char; nomarrivee,nomenvoi:string;function fileExists(var s : string) : boolean;begin fileExists := fSearch(s, '') <> '';end;

begin {$I-} clrscr; nomarrivee:='arrivee.txt'; nomenvoi:='envoi.txt'; assign(fichenvoi,'envoi.txt'); assign(ficharrivee,'arrivee.txt'); commserinit(vitesse9600,donnee8,

stop1,sansparite,port2); repeat if fileexists(nomenvoi) then begin assign(fichenvoi,nomenvoi); reset(fichenvoi); if not eof(fichenvoi) then begin while not eof(fichenvoi) do begin read(fichenvoi,carlu); commserecrit(port2,ord(carlu)); end; close(fichenvoi); end; erase(fichenvoi); end (*traitement du fichier envoi*); if commserteste(port2) then begin if fileexists(nomarrivee) then append(ficharrivee) else rewrite(ficharrivee); carlu:=chr(commserlit(port2)); write(ficharrivee,carlu); if carlu=chr(13)

then begin writeln(ficharrivee); writeln; end; write(carlu); close(ficharrivee); end; until keypressed; commserfin(port2);end.


En permanence, il scrute le fichier envoi.txt. S'il existe, il envoie son contenu sur la ligne RS232, puis le détruit.Il scrute aussi l'arrivée de caractères sur la ligne RS232. Si des caractères arrivent, il les écrit dans le fichier arrivee.txt.

6.6.2 utilisation de ce pilote par Scilab et Matlab

6.6.2.1 ScilabPour envoyer la chaîne 'XEA 0', qui demande à Orphy de faire la mesure sur la voie 0, on peut utiliser les instructions suivantes :z='XEA 0'write('envoi.txt',z)

Ensuite, pour lire la réponse envoyée sur la ligne RS232, il suffit d'aller lire le fichier arrivee.txt :rep=read('arrivee.txt',-1,1)

Enfin, il est souhaitable de détruire le fichier arrivee.txt, par exemple par l'instruction :unix('del arrivee.txt')L'instruction unix (même dans l'environnement MS-DOS Windows !) permet l'exécution d'une commande du système d'exploitation, ici la commande del, qui détruit le fichier qu'on lui passe en paramètre.

6.6.2.2 MatlabBien que Matlab permette de gérer directement les lignes RS232, il peut aussi fonctionner avec ce système de pilotes.

%commande de la voie série par transfer.exefid=fopen('envoi.txt','wt')fprintf(fid,'XEA 0\n')fclose(fid)

Le bloc d'instruction ci-dessus (à mettre dans le fichier pourtransfer.m, par exemple) provoque l'envoi de 'XEA 0' suivi d'un retour à la ligne dans le fichier envoi.txt, dès qu'on donne au clavier l'instruction pourtransfer.

ensuite, l'instruction rep=load('arrivee.txt') mettra la réponse dans la variable rep.

Enfin, on détruit le fichier arrivee.txt pardelete('arrivee.txt');


7 Lecture de ports Les ports sont des adresses de l'ordinateur, où peuvent transiter diverses informations liées au matériel. Par exemple, la prise imprimante normale "Lpt1:" a comme adresse les ports 889 et voisins. La prise "manette de jeu" a comme adresse le port 513, etc.Divers appareils enfichables dans un connecteur de l'ordinateur transmettent leurs mesures via les ports (Jeulin-ESAO3, MEP-PMB, Candibus, Leybold-Cassy, Pierron-SMF10 et Expert...)

Les langages de programmation traditionnels sous DOS permettent la lecture et l'écriture des ports. En QBasic, ce sont les instructions INP et OUT. En TurboPascal, c'est le tableau port...

Ces logiciels préhistoriques étaient très puissants pour accéder à toutes les ressources du système. Ils étaient même trop puissants, et permettaient facilement de faire des erreurs qui pouvaient endommager l'électronique. Ces capacités ont disparu des logiciels modernes :– les versions récentes de Windows (Win NT et suivants : XP, Vista...) interdisent l'accès direct aux

ports. En principe, il faudrait donc utiliser les versions anciennes de type Windows 3.1 (de 1992...), ou Windows 95 ou 98, ce qui devient de plus en plus rare. Heureusement, certains programmeurs ont conçu des additifs aux langages de programmation classiques (Pascal, C, Basic) qui permettent d'accéder aux ports, mais le détail de la programmation est difficile à suivre. Pour la programmation en Pascal/Delphi, je conseille l'unité zlportio.pas (en combinaison avec zlportio.sys), disponible sur http://delphi.icm.edu.pl/ftp/d30free/ZLPortIO.zip

– Ni Scilab, ni Matlab, ni Octave ne permettent spontanément la lecture ou l'écriture dans les ports. Comment faire pour les rendre capable de ces opérations, que le vieux GW-Basic faisait parfaitement sous MS-DOS 3 ?

Il suffit, là encore, de faire de petits programmes spécialisés dans ce but, et appelables par Matlab et Scilab. On peut alors mesurer et actionner grâce à diverses interfaces de mesure (Jeulin ESAO, ADES, joystick, etc).

Utilisation de Matlab, Octave ou Scilab pour les sciences...

Documents

Transcript of Utilisation de Matlab, Octave ou Scilab pour les sciences...