/usr/share/doc/HOWTO/fr-html/Serial-Programming-HOWTO.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for HTML5 for Linux version 5.2.0">
<meta name="GENERATOR" content="LinuxDoc-Tools 0.9.72">
<title>Le Linux Serial Programming HOWTO</title>
</head>
<body>
<h1>Le Linux Serial Programming HOWTO</h1>
<h2>par Peter H. Baumann, <code><a href=
"mailto:Peter.Baumann@dlr.de">Peter.Baumann@dlr.de</a></code><br>
Adaptation française Etienne BERNARD <code><a href=
"mailto:eb@via.ecp.fr">eb@via.ecp.fr</a></code></h2>
v1.0, 22 janvier 1998
<hr>
<em>Ce document décrit comment programmer sous Linux la
communication avec des périphériques sur port série.</em>
<hr>
<h2><a name="s1">1. Introduction</a></h2>
<p>Voici le Linux Serial Programming HOWTO, qui explique comment
programmer sous Linux la communication avec des périphériques ou
des ordinateurs via le port série. Différentes techniques sont
abordées&nbsp;: Entrées/Sorties canoniques (envoi ou réception
ligne par ligne), asynchrones, ou l'attente de données depuis de
multiples sources.</p>
<p>Ce document ne décrit pas comment configurer les ports séries,
puisque c'est décrit par Greg Hankins dans le Serial-HOWTO.</p>
<p>Je tiens à insister sur le fait que je ne suis pas un expert
dans ce domaine, mais j'ai eu à réaliser un projet utilisant la
communication par le port série. Les exemples de code source
présentés dans ce document sont dérivés du programme
<code>miniterm</code>, disponible dans le <em>Linux programmer's
guide</em>
(<code>ftp://sunsite.unc.edu/pub/Linux/docs/LDP/programmers-guide/lpg-0.4.tar.gz</code>
et les miroirs, par exemple
<code>ftp://ftp.lip6.fr/pub/linux/docs/LDP/programmers-guide/lpg-0.4.tar.gz</code>)
dans le répertoire contenant les exemples.</p>
<p>Depuis la dernière version de ce document, en juin 1997, j'ai dû
installer Windows NT pour satisfaire les besoins des client, et
donc je n'ai pas pu investiguer plus en avant sujet. Si quelqu'un a
des commentaires à me faire, je me ferai un plaisir de les inclure
dans ce document (voyez la section sur les commentaires). Si vous
désirez prendre en main l'évolution de ce document, et l'améliorer,
envoyez moi un courrier électronique.</p>
<p>Tous les exemples ont été testés avec un i386, utilisant un
noyau Linux de version 2.0.29.</p>
<h2><a name="ss1.1">1.1 Copyright</a></h2>
<p>Le Linux Serial-Programming-HOWTO est copyright (c) 1997 Peter
Baumann. Les HOWTO de Linux peuvent être reproduits et distribués
intégralement ou seulement par partie, sur quelconque support
physique ou électronique, aussi longtemps que ce message de
copyright sera conservé dans toutes les copies. Une redistribution
commerciale est autorisée, et encouragée; cependant, l'auteur
<em>apprécierait</em> d'être prévenu en cas de distribution de ce
type.</p>
<p>Toutes les traductions ou travaux dérivés incorporant un
document HOWTO Linux doit être placé sous ce copyright.
C'est-à-dire que vous ne pouvez pas produire de travaux dérivés à
partir d'un HOWTO et imposer des restrictions additionnelles sur sa
distribution. Des exceptions à cette règle peuvent être accordées
sous certaines conditions&nbsp; ; contactez le coordinateur des
HOWTO Linux à l'adresse donnée ci-dessous.</p>
<p>En résumé, nous désirons promouvoir la distribution de cette
information par tous les moyens possibles. Néanmoins, nous désirons
conserver le copyright sur les documents HOWTO, et nous
<em>aimerions</em> être informés de tout projet de redistribution
des HOWTO.</p>
<p>Pour toute question, veuillez contacter Greg Hankins, le
coordinateur des HOWTO Linux, à <code><a href=
"mailto:gregh@sunsite.unc.edu">gregh@sunsite.unc.edu</a></code> par
mail.</p>
<h2><a name="ss1.2">1.2 Nouvelles versions de ce document.</a></h2>
<p>Les nouvelles version du Serial-Programming-HOWTO seront
disponibles à<br>
<code><a href=
"ftp://sunsite.unc.edu:/pub/Linux/docs/HOWTO/Serial-Programming-HOWTO">
ftp://sunsite.unc.edu:/pub/Linux/docs/HOWTO/Serial-Programming-HOWTO</a></code>
et les sites miroir, comme par exemple <code><a href=
"ftp://ftp.lip6.fr/pub/linux/docs/HOWTO/Serial-Programming-HOWTO">ftp://ftp.lip6.fr/pub/linux/docs/HOWTO/Serial-Programming-HOWTO</a></code>.
Il existe sous d'autres formats, comme PostScript ou DVI dans le
sous répertoire <code>other-formats</code>. Le
Serial-Programming-HOWTO est également disponible sur
<code><a href="http://sunsite.unc.edu/LDP/HOWTO/Serial-Programming-HOWTO.html">
http://sunsite.unc.edu/LDP/HOWTO/Serial-Programming-HOWTO.html</a></code>,
et sera posté dans <code><a href=
"news:comp.os.linux.answers">comp.os.linux.answers</a></code> tous
les mois (NdT&nbsp;: la version française de ce document est
également postée dans <code><a href=
"news:fr.comp.os.linux.annonce">fr.comp.os.linux.annonce</a></code>
tous les mois).</p>
<h2><a name="ss1.3">1.3 Commentaires</a></h2>
<p>Envoyez moi, s'il vous plaît toute correction, question,
commentaire, suggestion ou complément. Je désire améliorer cet
HOWTO&nbsp;! Dites moi exactement ce que vous ne comprenez pas, ou
ce qui pourrait être plus clair. Vous pouvez me contacter à
<code><a href=
"mailto:Peter.Baumann@dlr.de">Peter.Baumann@dlr.de</a></code> par
courrier électronique. Veuillez inclure le numéro de version de ce
document pour tout courrier. Ce document est la version 0.3.</p>
<h2><a name="s2">2. Démarrage</a></h2>
<h2><a name="ss2.1">2.1 Débuggage</a></h2>
<p>Le meilleur moyen de débugguer votre code est d'installer une
autre machine sous Linux et de connecter les deux ordinateurs par
un câble null-modem. Utilisez <code>miniterm</code> (disponible
dans le Linux programmers guide --
<code>ftp://sunsite.unc.edu/pub/Linux/docs/LDP/programmers-guide/lpg-0.4.tar.gz</code>
-- dans le répertoire des exemples) pour transmettre des caractères
à votre machine Linux. <code>Miniterm</code> est très simple à
compiler et transmettra toute entrée clavier directement sur le
port série. Vous n'avez qu'à adapter la commande <code>#define
MODEMDEVICE "/dev/ttyS0"</code> à vos besoins. Mettez
<code>ttyS0</code> pour COM1, <code>ttyS1</code> for COM2, etc...
Il est essentiel, pour les tests, que <em>tous</em> les caractères
soient transmis bruts (sans traitements) au travers de la ligne
série. Pour tester votre connexion, démarrez <code>miniterm</code>
sur les deux ordinateurs et taper au clavier. Les caractères écrit
sur un ordinateur devraient apparaître sur l'autre ordinateur, et
vice versa. L'entrée clavier sera également recopiée sur l'écran de
l'ordinateur local.</p>
<p>Pour fabriquer un câble null-modem, pour devez croiser les
lignes TxD (<em>transmit</em>) et RxD (<em>receive</em>). Pour une
description du câble, référez vous à la section 7 du
Serial-HOWTO.</p>
<p>Il est également possible de faire cet essai avec uniquement un
seul ordinateur, si vous disposez de deux ports série. Vous pouvez
lancez deux <code>miniterm</code>s sur deux consoles virtuelles. Si
vous libérez un port série en déconnectant la souris, n'oubliez pas
de rediriger <code>/dev/mouse</code> si ce fichier existe. Si vous
utilisez une carte série à ports multiples, soyez sûr de la
configurer correctement. La mienne n'était pas correctement
configurée, et tout fonctionnait correctement lorsque je testais
sur mon ordinateur. Lorsque je l'ai connecté à un autre, le port a
commencé à perdre des caractères. L'exécution de deux programmes
sur un seul ordinateur n'est pas totalement asynchrone.</p>
<h2><a name="ss2.2">2.2 Configuration des ports</a></h2>
<p>Les périphériques <code>/dev/ttyS*</code> sont destinés à
connecter les terminaux à votre machine Linux, et sont configurés
pour cet usage après le démarrage. Vous devez vous en souvenir
lorsque vous programmez la communication avec un périphérique
autre. Par exemple, les ports sont configurés pour afficher les
caractères envoyés vers lui-même, ce qui normalement doit être
changé pour la transmission de données.</p>
<p>Tous les paramètres peuvent être facilement configuré depuis un
programme. La configuration est stockée dans une structure de type
<code>struct termios</code>, qui est définie dans
<code>&lt;asm/termbits.h&gt;</code>&nbsp;:</p>
<blockquote>
<pre><code>
#define NCCS 19
struct termios {
        tcflag_t c_iflag;               /* Modes d'entrée */
        tcflag_t c_oflag;               /* Modes de sortie */
        tcflag_t c_cflag;               /* Modes de contrôle */
        tcflag_t c_lflag;               /* Modes locaux */
        cc_t c_line;                    /* Discipline de ligne */
        cc_t c_cc[NCCS];                /* Caractères de contrôle */
};
</code></pre></blockquote>
<p>Ce fichier inclus également la définition des constantes. Tous
les modes d'entrée dans <code>c_iflag</code> prennent en charge le
traitement de l'entrée, ce qui signifie que les caractères envoyés
depuis le périphérique peuvent être traités avant d'être lu par
<code>read</code>. De la même façon, <code>c_oflags</code> se
chargent du traitement en sortie. <code>c_cflag</code> contient les
paramètres du port, comme la vitesse, le nombre de bits par
caractère, les bits d'arrêt, etc... Les modes locaux, stockés dans
<code>c_lflag</code> déterminent si les caractères sont imprimés,
si des signaux sont envoyés à votre programme, etc... Enfin, le
tableau <code>c_cc</code> définit les caractères de contrôle pour
la fin de fichier, le caractère stop, etc... Les valeurs par défaut
pour les caractères de contrôle sont définies dans
<code>&lt;asm/termios.h&gt;</code>. Les modes possibles sont
décrits dans la page de manuel de <code>termios(3)</code>. La
structure <code>termios</code> contient un champ
<code>c_line</code> (discipline de ligne), qui n'est pas utilisé
sur les systèmes conformes à POSIX.</p>
<h2><a name="ss2.3">2.3 Façons de lire sur les périphériques
série</a></h2>
<p>Voici trois façons de lire sur les périphériques série. Le moyen
approprié doit être choisi pour chaque application. Lorsque cela
est possible, ne lisez pas les chaînes caractère par caractère.
Lorsque j'utilisais ce moyen, je perdais des caractères, alors
qu'un <code>read</code> sur la chaîne complète ne donnait aucune
erreur.</p>
<h3>Entrée canonique</h3>
<p>C'est le mode de fonctionnement normal pour les terminaux, mais
peut également être utilisé pour communiquer avec d'autres
périphériques. Toutes les entrées sont traitées lignes par lignes,
ce qui signifie qu'un <code>read</code> ne renverra qu'une ligne
complète. Une ligne est terminée par défaut avec un caractère
<code>NL</code> (ACII <code>LF</code>), une fin de fichier, ou un
caractère de fin de ligne. Un <code>CR</code> (le caractère de fin
de ligne par défaut de DOS et Windows) ne terminera pas une ligne,
avec les paramètres par défaut.</p>
<p>L'entrée canonique peut également prendre en charge le caractère
erase, d'effacement de mot, et de réaffichage, la traduction de
<code>CR</code> vers <code>NL</code>, etc...</p>
<h3>Entrée non canonique</h3>
<p>L'entrée non canonique va prendre en charge un nombre fixé de
caractère par lecture, et autorise l'utilisation d'un compteur de
temps pour les caractères. Ce mode doit être utilisé si votre
application lira toujours un nombre fixé de caractères, ou si le
périphérique connecté envoit les caractères par paquet.</p>
<h3>Entrée asynchrone</h3>
<p>Les deux modes ci-dessus peut être utilisé en mode synchrone ou
asynchrone. Le mode synchrone est le mode par défaut, pour lequel
un appel à <code>read</code> sera bloquant, jusqu'à ce que la
lecture soit satisfaite. En mode asynchrone, un appel à
<code>read</code> retournera immédiatement et lancera un signal au
programme appelant en fin de transfert. Ce signal peut être reçu
par un gestionnaire de signal.</p>
<h3>Attente d'entrée depuis de multiples sources</h3>
<p>Cela ne constitue pas un mode d'entrée différent, mais peut
s'avérer être utile, si vous prenez en charge des périphériques
multiples. Dans mon application, je traitais l'entrée depuis une
socket TCP/IP et depuis une connexion série sur un autre ordinateur
quasiment en même temps. L'exemple de programme donné plus loin
attendra des caractères en entrée depuis deux sources. Si des
données sur l'une des sources deviennent disponibles, elles seront
traitées, et le programme attendra de nouvelles données.</p>
<p>L'approche présentée plus loin semble plutôt complexe, mais il
est important que vous vous rappeliez que Linux est un système
multi-tâche. L'appel système <code>select</code> ne charge pas le
processeur lorsqu'il attend des données, alors que le fait de faire
une boucle jusqu'à ce que des caractères deviennent disponibles
ralentirait les autres processus.</p>
<h2><a name="s3">3. Exemples de programmes</a></h2>
<p>Tous les exemples ont été extraits de <code>miniterm.c</code>.
Le tampon d'entrée est limité à 255 caractères, tout comme l'est la
longueur maximale d'une ligne en mode canonique
(<code>&lt;linux/limits.h&gt;</code> ou
<code>&lt;posix1_lim.h&gt;</code>).</p>
<p>Référez-vous aux commentaires dans le code source pour
l'explication des différents modes d'entrée. J'espère que le code
est compréhensible. L'exemple sur l'entrée canonique est la plus
commentée, les autres exemples sont commentés uniquement lorsqu'ils
diffèrent, afin de signaler les différences.</p>
<p>Les descriptions ne sont pas complètes, mais je vous encourage à
modifier les exemples pour obtenir la solution la plus intéressante
pour votre application.</p>
<p>N'oubliez pas de donner les droits corrects aux ports série (par
exemple, <code>chmod a+rw /dev/ttyS1</code>)&nbsp;!</p>
<h2><a name="ss3.1">3.1 Traitement canonique</a></h2>
<blockquote>
<pre><code>
#include &lt;sys/types.h&gt;
#include &lt;sys/stat.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;termios.h&gt;
#include &lt;stdio.h&gt;

/* les valeurs pour la vitesse, baudrate, sont définies dans &lt;asm/termbits.h&gt;, qui est inclus
dans &lt;termios.h&gt; */
#define BAUDRATE B38400            
/* changez cette définition pour utiliser le port correct */
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* code source conforme à POSIX */

#define FALSE 0
#define TRUE 1

volatile int STOP=FALSE; 

main()
{
  int fd,c, res;
  struct termios oldtio,newtio;
  char buf[255];
/* 
  On ouvre le périphérique du modem en lecture/écriture, et pas comme
  terminal de contrôle, puisque nous ne voulons pas être terminé si l'on
  reçoit un caractère CTRL-C.
*/
 fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY ); 
 if (fd &lt;0) {perror(MODEMDEVICE); exit(-1); }

 tcgetattr(fd,&amp;oldtio); /* sauvegarde de la configuration courante */
 bzero(&amp;newtio, sizeof(newtio)); /* on initialise la structure à zéro */

/* 
  BAUDRATE: Affecte la vitesse. vous pouvez également utiliser cfsetispeed
            et cfsetospeed.
  CRTSCTS : contrôle de flux matériel (uniquement utilisé si le câble a
            les lignes nécessaires. Voir la section 7 du Serial-HOWTO).
  CS8     : 8n1 (8 bits,sans parité, 1 bit d'arrêt)
  CLOCAL  : connexion locale, pas de contrôle par le modem
  CREAD   : permet la réception des caractères
*/
 newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
 
/*
  IGNPAR  : ignore les octets ayant une erreur de parité.
  ICRNL   : transforme CR en NL (sinon un CR de l'autre côté de la ligne
            ne terminera pas l'entrée).
  sinon, utiliser l'entrée sans traitement (device en mode raw).
*/
 newtio.c_iflag = IGNPAR | ICRNL;
 
/*
 Sortie sans traitement (raw).
*/
 newtio.c_oflag = 0;
 
/*
  ICANON  : active l'entrée en mode canonique
  désactive toute fonctionnalité d'echo, et n'envoit pas de signal au
  programme appelant.
*/
 newtio.c_lflag = ICANON;
 
/* 
  initialise les caractères de contrôle.
  les valeurs par défaut peuvent être trouvées dans
  /usr/include/termios.h, et sont données dans les commentaires.
  Elles sont inutiles ici.
*/
 newtio.c_cc[VINTR]    = 0;     /* Ctrl-c */ 
 newtio.c_cc[VQUIT]    = 0;     /* Ctrl-\ */
 newtio.c_cc[VERASE]   = 0;     /* del */
 newtio.c_cc[VKILL]    = 0;     /* @ */
 newtio.c_cc[VEOF]     = 4;     /* Ctrl-d */
 newtio.c_cc[VTIME]    = 0;     /* compteur inter-caractère non utilisé */
 newtio.c_cc[VMIN]     = 1;     /* read bloquant jusqu'à l'arrivée d'1 caractère */
 newtio.c_cc[VSWTC]    = 0;     /* '\0' */
 newtio.c_cc[VSTART]   = 0;     /* Ctrl-q */ 
 newtio.c_cc[VSTOP]    = 0;     /* Ctrl-s */
 newtio.c_cc[VSUSP]    = 0;     /* Ctrl-z */
 newtio.c_cc[VEOL]     = 0;     /* '\0' */
 newtio.c_cc[VREPRINT] = 0;     /* Ctrl-r */
 newtio.c_cc[VDISCARD] = 0;     /* Ctrl-u */
 newtio.c_cc[VWERASE]  = 0;     /* Ctrl-w */
 newtio.c_cc[VLNEXT]   = 0;     /* Ctrl-v */
 newtio.c_cc[VEOL2]    = 0;     /* '\0' */

/* 
  à présent, on vide la ligne du modem, et on active la configuration
  pour le port
*/
 tcflush(fd, TCIFLUSH);
 tcsetattr(fd,TCSANOW,&amp;newtio);

/*
  la configuration du terminal est faite, à présent on traite
  les entrées
  Dans cet exemple, la réception d'un 'z' en début de ligne mettra
  fin au programme.
*/
 while (STOP==FALSE) {     /* boucle jusqu'à condition de terminaison */
 /* read bloque l'exécution du programme jusqu'à ce qu'un caractère de
    fin de ligne soit lu, même si plus de 255 caractères sont saisis.
    Si le nombre de caractères lus est inférieur au nombre de caractères
    disponibles, des read suivant retourneront les caractères restants.
    res sera positionné au nombre de caractères effectivement lus */
    res = read(fd,buf,255); 
    buf[res]=0;       /* on termine la ligne, pour pouvoir l'afficher */
    printf(":%s:%d\n", buf, res);
    if (buf[0]=='z') STOP=TRUE;
 }
 /* restaure les anciens paramètres du port */
 tcsetattr(fd,TCSANOW,&amp;oldtio);
}
</code></pre></blockquote>
<h2><a name="ss3.2">3.2 Entrée non canonique</a></h2>
<p>Dans le mode non canonique, les caractères lus ne sont pas
assemblés ligne par ligne, et ils ne subissent pas de traitement
(erase, kill, delete, etc...). Deux paramètres contrôlent ce
mode&nbsp;: <code>c_cc[VTIME]</code> positionne le <em>timer</em>
de caractères, et <code>c_cc[VMIN]</code> indique le nombre minimum
de caractères à recevoir avant qu'une lecture soit satisfaite.</p>
<p>Si MIN &gt; 0 et TIME = 0, MIN indique le nombre de caractères à
recevoir avant que la lecture soit satisfaite. TIME est égal à
zéro, et le <em>timer</em> n'est pas utilisé.</p>
<p>Si MIN = 0 et TIME &gt; 0, TIME est utilisé comme une valeur de
<em>timeout</em>. Une lecture est satisfaite lorsqu'un caractère
est reçu, ou que la durée TIME est dépassée (t = TIME * 0.1s). Si
TIME est dépassé, aucun caractère n'est retourné.</p>
<p>Si MIN &gt; 0 et TIME &gt; 0, TIME est employé comme
<em>timer</em> entre chaque caractère. La lecture sera satisfaite
si MIN caractères sont reçus, ou que le <em>timer</em> entre deux
caractères dépasse TIME. Le <em>timer</em> est réinitialisé à
chaque fois qu'un caractère est reçu, et n'est activé qu'après la
réception du premier caractère.</p>
<p>Si MIN = 0 et TIME = 0, le retour est immédiat. Le nombre de
caractères disponibles, ou bien le nombre de caractères demandé est
retourné. Selon Antonino (voir le paragraphe sur les
participations), vous pouvez utiliser un <code>fcntl(fd, F_SETFL,
FNDELAY);</code> avant la lecture pour obtenir le même
résultat.</p>
<p>Vous pouvez tester tous les modes décrit ci-dessus en modifiant
<code>newtio.c_cc[VTIME]</code> et
<code>newtio.c_cc[VMIN]</code>.</p>
<blockquote>
<pre><code>
#include &lt;sys/types.h&gt;
#include &lt;sys/stat.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;termios.h&gt;
#include &lt;stdio.h&gt;

#define BAUDRATE B38400
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* code source conforme à POSIX */
#define FALSE 0
#define TRUE 1

volatile int STOP=FALSE; 

main()
{
  int fd,c, res;
  struct termios oldtio,newtio;
  char buf[255];

 fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY ); 
 if (fd &lt;0) {perror(MODEMDEVICE); exit(-1); }

 tcgetattr(fd,&amp;oldtio); /* sauvegarde de la configuration courante */

 bzero(&amp;newtio, sizeof(newtio));
 newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
 newtio.c_iflag = IGNPAR;
 newtio.c_oflag = 0;

 /* positionne le mode de lecture (non canonique, sans echo, ...) */
 newtio.c_lflag = 0;
 
 newtio.c_cc[VTIME]    = 0;   /* timer inter-caractères non utilisé */
 newtio.c_cc[VMIN]     = 5;   /* read bloquant jusqu'à ce que 5 */
                              /* caractères soient lus */
 tcflush(fd, TCIFLUSH);
 tcsetattr(fd,TCSANOW,&amp;newtio);


 while (STOP==FALSE) {       /* boucle de lecture */
   res = read(fd,buf,255);   /* retourne après lecture 5 caractères */
   buf[res]=0;               /* pour pouvoir les imprimer... */
   printf(":%s:%d\n", buf, res);
   if (buf[0]=='z') STOP=TRUE;
 }
 tcsetattr(fd,TCSANOW,&amp;oldtio);
}
</code></pre></blockquote>
<h2><a name="ss3.3">3.3 Lecture asynchrone</a></h2>
<blockquote>
<pre><code>
#include &lt;termios.h&gt;
#include &lt;stdio.h&gt;
#include &lt;unistd.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;sys/signal.h&gt;
#include &lt;sys/types.h&gt;

#define BAUDRATE B38400
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* code source conforme à POSIX */
#define FALSE 0
#define TRUE 1

volatile int STOP=FALSE; 

void signal_handler_IO (int status);   /* le gestionnaire de signal */
int wait_flag=TRUE;              /* TRUE tant que reçu aucun signal */

main()
{
  int fd,c, res;
  struct termios oldtio,newtio;
  struct sigaction saio;        /* définition de l'action du signal */
  char buf[255];

  /* ouvre le port en mon non-bloquant (read retourne immédiatement) */
  fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY | O_NONBLOCK);
  if (fd &lt;0) {perror(MODEMDEVICE); exit(-1); }

  /* installe le gestionnaire de signal avant de passer le port en
     mode asynchrone */
  saio.sa_handler = signal_handler_IO;
  saio.sa_mask = 0;
  saio.sa_flags = 0;
  saio.sa_restorer = NULL;
  sigaction(SIGIO,&amp;saio,NULL);
  
  /* permet au processus de recevoir un SIGIO */
  fcntl(fd, F_SETOWN, getpid());
  /* rend le descripteur de fichier asynchrone (la page de manuel
     indique que seuls O_APPEND et O_NONBLOCK fonctionnent avec
     F_SETFL...) */
  fcntl(fd, F_SETFL, FASYNC);

  tcgetattr(fd,&amp;oldtio); /* sauvegarde de la configuration courante */
  /* positionne les nouvelles valeurs pour lecture canonique */
  newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
  newtio.c_iflag = IGNPAR | ICRNL;
  newtio.c_oflag = 0;
  newtio.c_lflag = ICANON;
  newtio.c_cc[VMIN]=1;
  newtio.c_cc[VTIME]=0;
  tcflush(fd, TCIFLUSH);
  tcsetattr(fd,TCSANOW,&amp;newtio);
 
  /* on boucle en attente de lecture. généralement, on réalise
     des traitements à l'intérieur de la boucle */
  while (STOP==FALSE) {
    printf(".\n");usleep(100000);
    /* wait_flag = FALSE après réception de SIGIO. Des données sont
       disponibles et peuvent être lues */
    if (wait_flag==FALSE) { 
      res = read(fd,buf,255);
      buf[res]=0;
      printf(":%s:%d\n", buf, res);
      if (res==1) STOP=TRUE; /* on arrête la boucle si on lit une
                                ligne seule */
      wait_flag = TRUE;      /* on attend de nouvelles données */
    }
  }
  /* restaure les anciens paramètres du port */
  tcsetattr(fd,TCSANOW,&amp;oldtio);
}

/***************************************************************************
* gestionnaire de signal. Positionne wait_flag à FALSE, pour indiquer à    *
* la boucle ci-dessus que des caractères ont été reçus.                    *
***************************************************************************/

void signal_handler_IO (int status)
{
  printf("réception du signal SIGIO.\n);
  wait_flag = FALSE;
}
</code></pre></blockquote>
<h2><a name="ss3.4">3.4 Multiplexage en lecture</a></h2>
<p>Cette section est réduite au minimum, et n'est là que pour vous
guider. Le code source d'exemple présenté est donc réduit au strict
minimum. Il ne fonctionnera pas seulement avec des ports série,
mais avec n'importe quel ensemble de descripteurs de fichiers.</p>
<p>L'appel système select et les macros qui lui sont attachées
utilisent un <code>fd_set</code>. C'est un tableau de bits, qui
dispose d'un bit pour chaque descripteur de fichier valide.
<code>select</code> accepte un <code>fd_set</code> ayant les bits
positionnés pour les descripteurs de fichiers qui conviennent, et
retourne un <code>fd_set</code>, dans lequel les bits des
descripteurs de fichier où une lecture, une écriture ou une
exception sont positionnés. Toutes les manipulations de
<code>fd_set</code> sont faites avec les macros fournies. Reportez
vous également à la page de manuel de <code>select(2)</code>.</p>
<blockquote>
<pre><code>
#include &lt;sys/time.h&gt;
#include &lt;sys/types.h&gt;
#include &lt;unistd.h&gt;

main()
{
   int    fd1, fd2;  /* entrées 1 et 2 */
   fd_set readfs;    /* ensemble de descripteurs */
   int    maxfd;     /* nombre max des descripteurs utilisés */
   int    loop=1;    /* boucle tant que TRUE */

   /* open_input_source ouvre un périphérique, configure le port
      correctement, et retourne un descripteur de fichier. */
   fd1 = open_input_source("/dev/ttyS1");   /* COM2 */
   if (fd1&lt;0) exit(0);
   fd2 = open_input_source("/dev/ttyS2");   /* COM3 */
   if (fd2&lt;0) exit(0);
   maxfd = MAX (fd1, fd2)+1; /* numéro maximum du bit à tester */

   /* boucle d'entrée */
   while (loop) {
     FD_SET(fd1, &amp;readfs);  /* test pour la source 1 */
     FD_SET(fd2, &amp;readfs);  /* test pour la source 2 */
     /* on bloque jusqu'à ce que des caractères soient
        disponibles en lecture */
     select(maxfd, &amp;readfs, NULL, NULL, NULL);
     if (FD_ISSET(fd1))         /* caractères sur 1 */
       handle_input_from_source1();
     if (FD_ISSET(fd2))         /* caractères sur 2 */
       handle_input_from_source2();
   }

}   
</code></pre></blockquote>
<p>L'exemple ci-dessus bloque indéfiniment, jusqu'à ce que des
caractères venant d'une des sources soient disponibles. Si vous
avez besoin d'un <em>timeout</em>, remplacez juste l'appel à select
par&nbsp;:</p>
<blockquote>
<pre><code>
int res;
struct timeval Timeout;

/* fixe la valeur du timeout */
Timeout.tv_usec = 0;  /* millisecondes */
Timeout.tv_sec  = 1;  /* secondes */
res = select(maxfd, &amp;readfs, NULL, NULL, &amp;Timeout);
if (res==0)
/* nombre de descripteurs de fichiers avec caractères
   disponibles = 0, il y a eu timeout */
</code></pre></blockquote>
<p>Cet exemple verra l'expiration du delai de <em>timeout</em>
après une seconde. S'il y a <em>timeout</em>, select retournera 0,
mais faîtes attention, <code>Timeout</code> est décrémenté du temps
réellement attendu par <code>select</code>. Si la valeur de
<em>timeout</em> est 0, select retournera immédiatement.</p>
<h2><a name="s4">4. Autres sources d'information</a></h2>
<ul>
<li>Le Linux Serial-HOWTO décrit comment mettre en place les ports
série et contient des informations sur le matériel.</li>
<li>Le <a href="http://www.easysw.com/~mike/serial">Serial
Programming Guide for POSIX Compliant Operating Systems</a>, par
Michael Sweet. Ce lien est périmé et je n'arrive pas à trouver la
nouvelle adresse du document. Quelqu'un sait-il où je peux le
retrouver&nbsp;? C'était un très bon document&nbsp;!</li>
<li>La page de manuel de <code>termios(3)</code> décrit toutes les
constantes utilisées pour la structure <code>termios</code>.</li>
</ul>
<h2><a name="s5">5. Contributions</a></h2>
<p>Comme je l'ai dit dans l'introduction, je ne suis pas un expert
dans le domaine, mais j'ai rencontré des problèmes, et j'ai trouvé
les solutions avec l'aide d'autres personnes. Je tiens à remercier
pour leur aide M. Strudthoff du European Transonic WindTunnel,
Cologne, Michael Carter
(<code>mcarter@rocke.electro.swri.edu</code>) et Peter Waltenberg
(<code>p.waltenberg@karaka.chch.cri.nz</code>).</p>
<p>Antonino Ianella (<code>antonino@usa.net</code> a écrit le
Serial-Port-Programming Mini HOWTO, au même moment où je préparais
ce document. Greg Hankins m'a demandé d'inclure le Mini-HOWTO
d'Antonino dans ce document.</p>
<p>La structure de ce document et le formattage SGML ont été
dérivés du Serial-HOWTO de Greg Hankins. Merci également pour
diverses corrections faites par&nbsp;: Dave Pfaltzgraff
(<code>Dave_Pfaltzgraff@patapsco.com</code>), Sean Lincolne
(<code>slincol@tpgi.com.au</code>), Michael Wiedmann
(<code>mw@miwie.in-berlin.de</code>), et Adrey Bonar
(<code>andy@tipas.lt</code>).</p>
</body>
</html>
doc-linux-fr-html 2013.01-3ubuntu1 / usr / share / doc / HOWTO / fr-html / Serial-Programming-HOWTO.html
