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.