Communication de Matlab/Scilab avec des périphériques

Le matériel informatique standard est très réduit : l'unité centrale, le clavier, l'écran.

Aussi bien Matlab que Scilab sont capables de recevoir des instructions frappées au
clavier, et d'afficher le résultat de leur calcul à l'écran.
Le programme officiel de BCPST (arrêté du 8-8-2000) prévoit que "l'environnement
de programmation utilisé par les étudiants en travaux pratiques ... comprend :
- l'exécution d'un programme avec saisie de données au clavier et affichage ou
impression des résultats".
En fait, l'impression des résultats n'est pas simple, ni avec Matlab, ni avec Scilab. Il
n'y a pas d'instruction simple permettant d'envoyer les résultats d'un calcul directement
à l'imprimante. Le plus simple, apparemment, est d'envoyer ces résultats vers un
fichier-texte, puis ensuite de charger ce fichier dans un éditeur de texte capable de
l'imprimer.
Une autre possibilité est d'utiliser le fait que l'imprimante porte le nom "lpt1:" dans le
système MS-DOS-Windows.
Donc :
- en Matlab, l'instruction save 'lpt1:' A -ascii peut imprimer la matrice A
- en Scilab, l'instruction write('lpt1:',A) fait de même.

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...), d'autres par
liaison parallèle sur la prise imprimante (imprimante, appareils de mesure...), ou bien
sur des connecteurs internes ("slots").
Il y a quelques années, les connecteurs des PC étaient de type "ISA", et de nombreuses
cartes de mesure y étaient connectables. Sur les ordinateurs PC actuels, les slots sont
de type PCI, et peu de cartes de mesure y sont adaptées.
Les ordinateurs actuels sont vendus avec d'autres branchements possibles : carte-son
(connexion possible d'un micro et de hauts-parleurs), connecteurs USB...
Utilisation des appareils RS232
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 et
d'autres encore pour les ordinateurs de poche Palm...
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
boîtier 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.
Matlab utilise facilement 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.
% essai d'orphy directement avec matlab
s=serial('com2','baudrate',9600,'databits',8,'stopbits',1,'Terminator
','CR')
% C'était l'initialisation
fopen(s)
fprintf(s,'XASC')
%c'était pour indiquer à Orphy de communiquer en mode ASCII
fprintf(s,'XSA 200')
%c'était pour fixer la sortie analogique à 200
fprintf(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éponse
disp(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...
Scilab a besoin de pilotes externes pour la communication sérielle
position du problème
Tel quel, Scilab est incapable de communiquer par voie RS232.
En regardant la documentation, il semblerait que Scilab puisse utiliser des fonctions
extérieures écrites dans un "vrai" langage de programmation, par exemple Fortran ou
C.
Malheureusement, cette documentation est très confuse, et je n'ai pas réussi à faire la
liaison avec des fonctions extérieures. En particulier, pour la version fonctionnant sous
Windows, il devrait être possible d'utiliser des bibliothèques à liaison dynamique
(DLL), que l'on peut programmer en C++ ou en Delphi, mais j'ai échoué.
Comment faire pour lui faire échanger des informations avec le monde extérieur, en
particulier avec des appareils de mesure ?

Principe général de la solution envisagée : des fichiers

La solution la plus simple que j'aie trouvé consiste à utiliser d'autres programmes, que
l'on pourrait qualifier de "pilotes" ou "drivers", qui font l'échange de données par fil à
la place de Scilab, et qui lui communiquent les informations par de petits fichiers.
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 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.
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.
utilisation de ce pilote par Scilab et Matlab
Scilab
C'est pour Scilab que ce système de pilote est le plus indispensable.
Pour 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.
Matlab
Bien 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.exe
fid=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 par
delete('arrivee.txt');
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...

Ni Scilab, ni Matlab 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 ?
Il suffit, là encore, de faire de petits programmes spécialisés dans ce but, et
appelables par Matlab et Scilab. Comme la documentation sur la liaison de
DLL est très absconse, il ne sera question ici que de "programmes complets",
exécutables.

utilisation des ports par Scilab

Ces programmes sont écrits en Pascal standard. Le logiciel TurboPascal 7 est
disponible gratuitement en version française sur le site www.borland.fr (dans
les rubriques "communauté" ou "museum"...) ; il suffit de s'enregistrer en
ligne.
Les mêmes instructions doivent être possibles dans les autres versions de
TurboPascal, ainsi que dans Borland Pascal pour Windows, et Delphi 1.

Par contre, pour les versions plus récentes de Delphi (2, 3, 4, 5, 6), le tableau
"port" n'existe pas, et il faut utiliser des fonctions spéciales en assembleur,
du type :

procedure SetPort(address,value:Word);
var bvalue:byte;
begin
bvalue:=trunc(value and 255);
asm
mov dx,address
mov AL,bvalue
out DX,AL
end;
end;

function GetPort(address:Word):Word;
var bvalue:byte;
begin
asm
mov dx,address
in aL,dx
mov bvalue,aL
end;
result:=bvalue;
end;

Un programme de commande de port en Pascal

Ce programme fixe le port correspondant au premier paramètre à la valeur
du deuxième paramètre.

program fixeport;
uses dos;
var adresse, valeur,nberr:integer;
begin
val(paramstr(1),adresse,nberr);
val(paramstr(2),valeur,nberr);
port[adresse]:=valeur
end.

Un programme de lecture de port en Pascal

Ce programme lit la valeur du port envoyé en paramètre.
program litport;
uses dos;
var n,nberr:integer;
begin
val(paramstr(1),n,nberr);
writeln(port[n]);
end.

utilisation des ports par Matlab

Comment Matlab peut communiquer avec des programmes extérieurs ?
Matlab semble moins souple que Scilab.
La documentation Matlab indique donc la méthode suivante :
- sauvegarder les variables à envoyer dans un fichier, par exemple
monfich.txt. En fait ceci n'est pas obligatoire, puisqu'on peut envoyer les
instructions en ligne de commande, ce qui est plus rapide.
- lancer le programme, qui fait son travail, et sauvegarde les résultats dans un
fichier, par exemple fichresult.txt. Ceci semble indispensable lorsqu'on veut
récupérer dans Matlab les résultats de l'exécution de monprog.exe.
- lire par Matlab le fichier-résultat fichresult.txt. Il faut donc que ce fichier
soit lisible par Matlab...
un programme d'écriture de port pour Matlab, en Pascal
Il est identique à celui de Scilab à une petite différence près : Matlab ne
semple pas compatible avec les logiciels écrits pour DOS, et il faut donc
utiliser un logiciel écrit sous Windows, par exemple pour Delphi :
program Fixportw;
uses wincrt;
var adresse,valeur,nberr:integer;
begin
if paramcount<2
then begin
writeln('fixeport fixe la valeur d''un port :');
writeln('Premier paramètre, l''adresse … fixer');
writeln('deuxième paramètre, la valeur qu''on veut mettre …
cette adresse');
end
else begin
val(paramstr(1),adresse,nberr);
val(paramstr(2),valeur,nberr);
port[adresse]:=valeur;
end;
end.

Donc, pour fixer le port numport à la valeur valport, faire :

!fixportw numport valport;

un programme de lecture de port pour Matlab, en Pascal

Il est différent de celui de Scilab, car Matlab ne peut pas récupérer
directement les valeurs renvoyées par le programme, mais seulement
lire les valeurs écrites par le programme dans un fichier. Il faut donc
faire un programme qui écrit ces valeurs.
program lportmat;
uses wincrt;
var n,nberr:integer;
f:text;
begin
val(paramstr(1),n,nberr);
assign(f,'lportmat.txt');
rewrite(f);
writeln(f,port[n]);
close(f);
end.'

Ensuite, dans Matlab, sachant que numport est le numéro du port àlire, faire :
!lportmat.exe numport
A=load('lportmat.txt');
Généralisation : emploi de "pilotes faisant des fichiers"

L'exemple précédent du logiciel transfer.pas peut être généralisé : d'une part on peut
écrire de tels logiciels avec n'importe quel langage de programmation généraliste,
d'autre part on peut concevoir des pilotes permettant des échanges avec des appareils
reliés autrement que par liaison sérielle.
Divers langages pour aboutir à des pilotes
Les "vrais" langages de programmation généralistes sont certes moins puissants
mathématiquement que Matlab et Scilab, mais ils permettent de traiter des
informations beaucoup plus variées. Il est donc souhaitable de profiter de la puissance
des uns et des autres.
Pascal
Le TurboPascal 7 est disponible gratuitement en téléchargement sur le site de Borland-
France (www.borland.fr)
Pour une communication facile par RS232, le mieux est d'utiliser des unités conçues
dans ce but, disponibles dans le domaine public sur Internet.
Sur ce même site Borland, existent aussi diverses pièces de musée, en particulier le
TurboPascal 1, de 1983.
Basic
Vers 1990, Microsoft fournissait QBasic avec le système d'exploitation MS-DOS.
Il existe (ou existait il y a peu) dans un sous-répertoire des CD de Windows. Il est
téléchargeable sur le site de Microsoft, ainsi que sur d'autres sites Internet.
On peut aussi trouver sur Internet d'autres langages Basic, en particulier UBasic, ayant
une puissance mathématique impressionnante malgré son apparence désuète.
D'autres idées de pilotes, pour donner encore plus de puissance à
Matlab et Scilab
Mesure en tâche de fond, sans avoir besoin de déclenchement par Matlab ou
Scilab
On peut réaliser un programme "surveille.exe" qui scrute en permanence, par exemple
toutes les 500 millisecondes, les différentes voies de mesure, et qui sauve le résultat
dans des fichiers ea0.txt, ea1.txt, ea2.txt...
Ce même fichier scruterait l'existence et le contenu de fichiers correspondant aux
sorties logiques et analogiques sa0.txt, sa1.txt, sl0.tx, sl1.txt... et enverrait vers
l'interface les ordres correspondant.
Ainsi, Matlab et Scilab feraient leurs mesures en lisant les fichiers d'entrée
(analogique et logique), et commanderaient les actionneurs (sorties logiques et
analogiques) en écrivant les fichiers correspondant.
Voici un petit programme en QBasic permettant la mesure sur Orphy GTS lié à la voie
2. La mesure est faite sur l'entrée analogique 2 (EA2), le résultat est affiché à l'écran et
écrit dans le fichier EA2.TXT.
OPEN "com2:9600,N,8,1,RS,CS0,DS0,CD0" FOR RANDOM AS #1
WHILE INKEY$ = "":
OPEN "EA2.TXT" FOR OUTPUT AS #2
PRINT #1, "XEA 2"
INPUT #1, R%
PRINT USING "tension sur voie2 : #.## V "; R% * 5 / 255
PRINT #2, R%
CLOSE #2
WEND: REM fin de la mesure
CLOSE 1
END
Multiplicité des périphériques utilisables
De nombreux appareils de mesure sont connectables à un ordinateur ailleurs que sur
une prise RS232.
Par exemple, la Maison des Enseignants de Provence diffuse le boitier ADES,
connectable sur une prise parallèle (prise imprimante) et utilisable avec les capteurs
Calibration (oxymètre, pHmètre, etc).
La carte son comporte une prise "manettes de jeu", qui permet de mesurer facilement
des résistances (donc lumière par photorésistance, température par thermistance, etc).
Les slots (PCI ou autrefois ISA) permettent de connecter des cartes de mesure...
On peut donc faire des pilotes de type "surveille", qui échangent des données avec
Matlab et Scilab par des fichiers-textes spécialisés, et qui échangent des données avec
les appareils par leurs connecteurs spécialisés.

Conclusion : Même si Matlab et Scilab ne sont pas très performants en dehors de

leur domaine d'excellence, on peut les utiliser pour de l'informatique générale, à
condition de leur fournir quelques additifs.