Le Linux Serial Programming HOWTO

par Peter H. Baumann, Peter.Baumann@dlr.de

Adaptation française Etienne BERNARD eb@via.ecp.fr v0.3, 14 Juin 1997

Ce document décrit comment programmer sous Linux la communication avec des périphériques sur port série.

Table des matières

1 Introduction 2 1.1 Copyright . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.2 Nouvelles versions de ce document. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.3 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Démarrage 3 2.1 Débuggage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.2 Configuration des ports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.3 Façons de lire sur les périphériques série . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.3.1 Entrée canonique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.3.2 Entrée non canonique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.3.3 Entrée asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.3.4 Attente d’entrée depuis de multiples sources . . . . . . . . . . . . . . . . . . . . . . . 5

3 Exemples de programmes 5 3.1 Traitement canonique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 3.2 Entrée non canonique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 3.3 Lecture asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 3.4 Multiplexage en lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4 Autres sources d’information 13

5 Contributions 13

1 Introduction

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 : Entrées/Sorties canoniques (envoi ou réception ligne par ligne), asynchrones, ou l’attente de données depuis de multiples sources.

Ce document ne décrit pas comment configurer les ports séries, puisque c’est décrit par Greg Hankins dans le Serial-HOWTO.

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 miniterm, disponible dans le Linux programmer’s guide (ftp://sunsite.unc.edu/pub/Linux/docs/LDP/programmers-guide/lpg-0.4.tar.gz
et les miroirs, par exemple ftp://ftp.lip6.fr/pub/linux/docs/LDP/programmers-guide/lpg-0.4.tar.gz)

dans le répertoire contenant les exemples. Je me ferai un plaisir d’incorporer d’éventuels commentaires (voyez la section sur les commentaires).

Tous les exemples ont été testés avec un i386, utilisant un noyau Linux de version 2.0.29.

1.1 Copyright

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 apprécierait d’être prévenu en cas de distribution de ce type.

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 ; contactez le coordinateur des HOWTO Linux à l’adresse donnée ci-dessous.

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 aimerions être informés de tout projet de redistribution des HOWTO.

Pour toute question, veuillez contacter Greg Hankins, le coordinateur des HOWTO Linux, à gregh@sunsite.unc.edu par mail.

1.2 Nouvelles versions de ce document.

Les nouvelles version du Serial-Programming-HOWTO seront disponibles à

ftp://sunsite.unc.edu:/pub/Linux/docs/HOWTO/Serial-Programming-HOWTO et les sites miroir, comme
par exemple ftp://ftp.lip6.fr/pub/linux/docs/HOWTO/Serial-Programming-HOWTO. Il existe sous d’autres

formats, comme PostScript ou DVI dans le sous répertoire other-formats. Le Serial-Programming-HOWTO

est également disponible sur http://sunsite.unc.edu/LDP/HOWTO/Serial-Programming-HOWTO.html, et

sera posté dans comp.os.linux.answers tous les mois (NdT : la version française de ce document est également postée dans fr.comp.os.linux.annonce tous les mois).

1.3 Commentaires

Envoyez moi, s’il vous plaît tout correction, question, commentaire, suggestion ou complément. Je désire améliorer cet HOWTO ! Dites moi exactement ce que vous ne comprenez pas, ou ce qui pourrait être plus clair. Vous pouvez me contacter à Peter.Baumann@dlr.de par courrier électronique. Veuillez inclure le numéro de version de ce document pour tout courrier. Ce document est la version 0.3.

2 Démarrage

2.1 Débuggage

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 miniterm (disponible dans le Linux programmers guide –

ftp://sunsite.unc.edu/pub/Linux/docs/LDP/programmers-guide/lpg-0.4.tar.gz – dans le répertoire

des exemples) pour transmettre des caractères à votre machine Linux. Miniterm est très simple à compiler et transmettra toute entrée clavier directement sur le port série. Vous n’avez qu’à adapter la commande #define MODEMDEVICE "/dev/ttyS0" à vos besoins. Mettez ttyS0 pour COM1, ttyS1 for COM2, etc... Il est essentiel, pour les tests, que tous les caractères soient transmis bruts (sans traitements) au travers de la ligne série. Pour tester votre connexion, démarrez miniterm 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.

Pour fabriquer un câble null-modem, pour devez croiser les lignes TxD (transmit) et RxD (receive). Pour une description du câble, référez vous à la section 7 du Serial-HOWTO.

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 miniterms sur deux consoles virtuelles. Si vous libérez un port série en déconnectant la souris, n’oubliez pas de rediriger /dev/mouse 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.

2.2 Configuration des ports

Les périphériques /dev/ttyS* 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.

Tous les paramètres peuvent être facilement configuré depuis un programme. La configuration est stockée dans une structure de type struct termios, qui est définie dans <asm/termbits.h>:

     #define NCCS 19
     struct termios {
             tcflag_t c_iflag;               /* Modes d'entr\'{e}e */
             tcflag_t c_oflag;               /* Modes de sortie */
             tcflag_t c_cflag;               /* Modes de contr\^{o}le */
             tcflag_t c_lflag;               /* Modes locaux */
             cc_t c_line;                    /* Discipline de ligne */
             cc_t c_cc[NCCS];                /* Caract\`{e}res de contr\^{o}le */
     };

Ce fichier inclus également la définition des constantes. Tous les modes d’entrée dans c iflag 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 read. De la même façon, c oflags se chargent du traitement en sortie. c cflag 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 c lflag déterminent si les caractères sont imprimés, si des signaux sont envoyés à votre programme, etc... Enfin, le tableau c cc 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 <asm/termios.h>. Les modes possibles sont décrits dans la page de manuel de termios(3)

La structure termios contient l’élément c line. Cet élément n’est ni mentionné dans la page de manuel de termios de Linux, ni dans celle de Solaris 2.5. Quelqu’un peut-il m’éclairer sur cet attribut? Est-ce qu’il doit réellement être inclus dans la structure termios?

2.3 Façons de lire sur les périphériques série

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 read sur la chaîne complète ne donnait aucune erreur.

2.3.1 Entrée canonique

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 read ne renverra qu’une ligne complète. Une ligne est terminée par défaut avec un caractère NL (ACII LF), une fin de fichier, ou un caractère de fin de ligne. Un CR (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.

L’entrée canonique peut également prendre en charge le caractère erase, d’effacement de mot, et de réaffichage, la traduction de CR vers NL, etc...

2.3.2 Entrée non canonique

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.

2.3.3 Entrée asynchrone

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 à read sera bloquant, jusqu’à ce que la lecture soit satisfaite. En mode asynchrone, un appel à read 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.

2.3.4 Attente d’entrée depuis de multiples sources

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.

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 select 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.

3 Exemples de programmes

Tous les exemples ont été extraits de miniterm.c. Le tampon d’entrée est limité à 255 caractères, tout comme l’est la longueur maximale d’une ligne en mode canonique (<linux/limits.h> ou <posix1 lim.h>).

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.

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.

N’oubliez pas de donner les droits corrects aux ports série (par exemple, chmod a+rw /dev/ttyS1) !

3.1 Traitement canonique

     #include <sys/types.h>
     #include <sys/stat.h>
     #include <fcntl.h>

3. Exemples de programmes 6

#include <termios.h>
#include <stdio.h>
/* les valeurs pour la vitesse, baudrate, sont d\'{e}finies dans <asm/termbits.h>, qui est inclus
dans <termios.h> */
#define BAUDRATE B38400
/* changez cette d\'{e}finition pour utiliser le port correct */
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* code source conforme \`{a} 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\'{e}riph\'{e}rique du modem en lecture/\'{e}criture, et pas comme
  terminal de contr\^{o}le, puisque nous ne voulons pas \^{e}tre termin\'{e} si l'on
  re\c{c}oit un caract\`{e}re CTRL-C.
*/
 fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY );
 if (fd <0) {perror(MODEMDEVICE); exit(-1); }
 tcgetattr(fd,&oldtio); /* sauvegarde de la configuration courante */
 bzero(newtio, sizeof(newtio)); /* on initialise la structure \`{a} z\'{e}ro */
/*
  BAUDRATE: Affecte la vitesse. vous pouvez \'{e}galement utiliser cfsetispeed
            et cfsetospeed.
  CRTSCTS : contr\^{o}le de flux mat\'{e}riel (uniquement utilis\'{e} si le c\^{a}ble a
            les lignes n\'{e}cessaires. Voir la section 7 du Serial-HOWTO).
  CS8     : 8n1 (8 bits,sans parit\'{e}, 1 bit d'arr\^{e}t)
  CLOCAL  : connexion locale, pas de contr\^{o}le par le modem
  CREAD   : permet la r\'{e}ception des caract\`{e}res
*/
 newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
/*
  IGNPAR  : ignore les octets ayant une erreur de parit\'{e}.
  ICRNL   : transforme CR en NL (sinon un CR de l'autre c\^{o}t\'{e} de la ligne
            ne terminera pas l'entr\'{e}e).
  sinon, utiliser l'entr\'{e}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}e en mode canonique
 d\'{e}sactive toute fonctionnalit\'{e} d'echo, et n'envoit pas de signal au
 programme appelant.
*/
newtio.c_lflag = ICANON;
/*
 initialise les caract\`{e}res de contr\^{o}le.
 les valeurs par d\'{e}faut peuvent \^{e}tre trouv\'{e}es dans
 /usr/include/termios.h, et sont donn\'{e}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\`{e}re non utilis\'{e} */
newtio.c_cc[VMIN]     = 1;     /* read bloquant jusqu'\`{a} l'arriv\'{e}e d'1 caract\`{e}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' */
/*
 \`{a} pr\'{e}sent, on vide la ligne du modem, et on active la configuration
 pour le port
*/
tcflush(fd, TCIFLUSH);
tcsetattr(fd,TCSANOW,&newtio);
/*
 la configuration du terminal est faite, \`{a} pr\'{e}sent on traite
 les entr\'{e}es

       Dans cet exemple, la r\'{e}ception d'un 'z' en d\'{e}but de ligne mettra
       fin au programme.
     */
      while (STOP==FALSE) {     /* boucle jusqu'\`{a} condition de terminaison */
      /* read bloque l'ex\'{e}cution du programme jusqu'\`{a} ce qu'un caract\`{e}re de
         fin de ligne soit lu, m\^{e}me si plus de 255 caract\`{e}res sont saisis.
         Si le nombre de caract\`{e}res lus est inf\'{e}rieur au nombre de caract\`{e}res
         disponibles, des read suivant retourneront les caract\`{e}res restants.
         res sera positionn\'{e} au nombre de caract\`{e}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\`{e}tres du port */
      tcsetattr(fd,TCSANOW,&oldtio);
     }

3.2 Entrée non canonique

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 : c cc[VTIME] positionne le timer de caractères, et c cc[VMIN] indique le nombre minimum de caractères à recevoir avant qu’une lecture soit satisfaite.

Si MIN > 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 timer n’est pas utilisé.

Si MIN = 0 et TIME > 0, TIME est utilisé comme une valeur de timeout. 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é.

Si MIN > 0 et TIME > 0, TIME est employé comme timer entre chaque caractère. La lecture sera satisfaite si MIN caractères sont reçus, ou que le timer entre deux caractères dépasse TIME. Le timer 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.

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 fcntl(fd, F SETFL, FNDELAY); avant la lecture pour obtenir le même résultat.

Vous pouvez tester tous les modes décrit ci-dessus en modifiant newtio.c cc[VTIME] et newtio.c cc[VMIN].

     #include <sys/types.h>
     #include <sys/stat.h>
     #include <fcntl.h>
     #include <termios.h>
     #include <stdio.h>
     #define BAUDRATE B38400

#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* code source conforme \`{a} 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 <0) {perror(MODEMDEVICE); exit(-1); }
tcgetattr(fd,&oldtio); /* sauvegarde de la configuration courante */
bzero(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\`{e}res non utilis\'{e} */
newtio.c_cc[VMIN]     = 5;   /* read bloquant jusqu'\`{a} ce que 5 */
                             /* caract\`{e}res soient lus */
tcflush(fd, TCIFLUSH);
tcsetattr(fd,TCSANOW,&newtio);

while (STOP==FALSE) {       /* boucle de lecture */
  res = read(fd,buf,255);   /* retourne apr\`{e}s lecture 5 caract\`{e}res */
  buf[res]=0;               /* pour pouvoir les imprimer... */
  printf(":%s:%d\n", buf, res);
  if (buf[0]=='z') STOP=TRUE;
}
tcsetattr(fd,TCSANOW,&oldtio);
}

3.3 Lecture asynchrone

#include <termios.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>

#include <sys/signal.h>
#include <sys/types.h>
#define BAUDRATE B38400
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* code source conforme \`{a} 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\c{c}u aucun signal */
main()
{
int fd,c, res;
struct termios oldtio,newtio;
struct sigaction saio;        /* d\'{e}finition de l'action du signal */
char buf[255];
/* ouvre le port en mon non-bloquant (read retourne imm\'{e}diatement) */
fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (fd <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,&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,&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,&newtio);
  /* on boucle en attente de lecture. g\'{e}n\'{e}ralement, on r\'{e}alise
     des traitements \`{a} l'int\'{e}rieur de la boucle */
  while (STOP==FALSE) {
    printf(".\n");usleep(100000);
    /* wait_flag = FALSE apr\`{e}s r\'{e}ception de SIGIO. Des donn\'{e}es sont
       disponibles et peuvent \^{e}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\^{e}te la boucle si on lit une
                                ligne seule */
      wait_flag = TRUE;      /* on attend de nouvelles donn\'{e}es */
    }
  }
  /* restaure les anciens param\`{e}tres du port */
  tcsetattr(fd,TCSANOW,&oldtio);
}
/***************************************************************************
* gestionnaire de signal. Positionne wait_flag \`{a} FALSE, pour indiquer \`{a}    *
* la boucle ci-dessus que des caract\`{e}res ont \'{e}t\'{e} re\c{c}us.                    *
***************************************************************************/
void signal_handler_IO (int status)
{
  printf("r\'{e}ception du signal SIGIO.\n);
  wait_flag = FALSE;
}

3.4 Multiplexage en lecture

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.

L’appel système select et les macros qui lui sont attachées utilisent un fd set. C’est un tableau de bits, qui dispose d’un bit pour chaque descripteur de fichier valide. select accepte un fd set ayant les bits positionnés pour les descripteurs de fichiers qui conviennent, et retourne un fd set, dans lequel les bits des descripteurs de fichier où une lecture, une écriture ou une exception sont positionnés. Toutes les manipulations de fd set sont faites avec les macros fournies. Reportez vous également à la page de manuel de select(2).

#include <sys/time.h>
#include <sys/types.h>

#include <unistd.h>
main()
{
int    fd1, fd2;  /* entr\'{e}es 1 et 2 */
fd_set readfs;    /* ensemble de descripteurs */
int    maxfd;     /* nombre max des descripteurs utilis\'{e}s */
int    loop=1;    /* boucle tant que TRUE */
/* open_input_source ouvre un p\'{e}riph\'{e}rique, configure le port
   correctement, et retourne un descripteur de fichier. */
fd1 = open_input_source("/dev/ttyS1");   /* COM2 */
if (fd1<0) exit(0);
fd2 = open_input_source("/dev/ttyS2");   /* COM3 */
if (fd2<0) exit(0);
maxfd = MAX (fd1, fd2)+1; /* num\'{e}ro maximum du bit \`{a} tester */
/* boucle d'entr\'{e}e */
while (loop) {
  FD_SET(fd1, &readfs);  /* test pour la source 1 */
  FD_SET(fd2, &readfs);  /* test pour la source 2 */
  /* on bloque jusqu'\`{a} ce que des caract\`{e}res soient
     disponibles en lecture */
  select(maxfd, &readfs, NULL, NULL, NULL);
  if (FD_ISSET(fd1))         /* caract\`{e}res sur 1 */
    handle_input_from_source1();
  if (FD_ISSET(fd2))         /* caract\`{e}res sur 2 */
    handle_input_from_source2();
}
}

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 timeout, remplacez juste l’appel à select par :

int res;
struct timeval Timeout;
/* fixe la valeur du timeout */
Timeout.tv_usec = 0;  /* millisecondes */
Timeout.tv_sec  = 1;  /* secondes */
res = select(maxfd, &readfs, NULL, NULL, &Timeout);
if (res==0)
/* nombre de descripteurs de fichiers avec caract\`{e}res
disponibles = 0, il y a eu timeout */

Cet exemple verra l’expiration du delai de timeout après une seconde. S’il y a timeout, select retournera 0, mais faîtes attention, Timeout est décrémenté du temps réellement attendu par select. Si la valeur de timeout est 0, select retournera immédiatement.

4 Autres sources d’information

– Le Linux Serial-HOWTO décrit comment mettre en place les ports série et contient des informations sur le matériel.

– Le Serial Programming Guide for POSIX Compliant Operating Systems (http://www.easysw.com/ mike/serial), par Michael Sweet.

– La page de manuel de termios(3) décrit toutes les constantes utilisées pour la structure termios.

5 Contributions

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 (mcarter@rocke.electro.swri.edu)

et Peter Waltenberg (p.waltenberg@karaka.chch.cri.nz).

Antonino Ianella (antonino@usa.net 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.

La structure de ce document et le formattage SGML ont été dérivés du Serial-HOWTO de Greg Hankins.