[email protected]
[email protected]
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.
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.
Tous les exemples ont �t� test�s avec un i386, utilisant un noyau Linux de version 2.0.29.
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, �
[email protected] par mail.
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).
Envoyez moi, s'il vous pla�t toute 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 �
[email protected] par courrier �lectronique. Veuillez inclure le num�ro de version de ce document pour tout courrier. Ce document est la version 0.3.
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.
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 */
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 */
};
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 un champ c_line (discipline de ligne), qui n'est pas utilis� sur les syst�mes conformes � POSIX.
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.
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...
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.
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.
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.
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) !
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <stdio.h>
/* les valeurs pour la vitesse, baudrate, sont d�finies dans <asm/termbits.h>, qui est inclus
dans <termios.h> */
#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 <0) {perror(MODEMDEVICE); exit(-1); }
tcgetattr(fd,&oldtio); /* sauvegarde de la configuration courante */
bzero(&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,&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,&oldtio);
}
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 � 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�res non utilis� */
newtio.c_cc[VMIN] = 5; /* read bloquant jusqu'� ce que 5 */
/* caract�res soient lus */
tcflush(fd, TCIFLUSH);
tcsetattr(fd,TCSANOW,&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,&oldtio);
}
#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 � 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 <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�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,&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;
}
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�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<0) exit(0);
fd2 = open_input_source("/dev/ttyS2"); /* COM3 */
if (fd2<0) exit(0);
maxfd = MAX (fd1, fd2)+1; /* num�ro maximum du bit � tester */
/* boucle d'entr�e */
while (loop) {
FD_SET(fd1, &readfs); /* test pour la source 1 */
FD_SET(fd2, &readfs); /* test pour la source 2 */
/* on bloque jusqu'� ce que des caract�res soient
disponibles en lecture */
select(maxfd, &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();
}
}
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�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.
termios(3) d�crit toutes les constantes utilis�es pour la structure termios.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 ([email protected]) et Peter Waltenberg ([email protected]).
Antonino Ianella ([email protected] 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. Merci �galement pour diverses corrections faites par : Dave Pfaltzgraff ([email protected]), Sean Lincolne ([email protected]), Michael Wiedmann ([email protected]), et Adrey Bonar ([email protected]).