Timeout sur read() avec termios et VTIME

Version imprimable

Bonjour,

Je cherche a comprendre comment inserer un timeout dans mon programme.

Ce programme utilise une structure termios pour aller lire en mode non canonique caractère par caractère ce qui passe sur mon port série via un read(). Je veux donc ajouter une verification de timeout entre la lecture de chaque caractère.

- Voici mon ouverture et configuration du port série :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 fd = open(PORT, O_RDWR | O_NOCTTY); if (fd <0) {perror(PORT); exit(-1); } /* Lecture des parametres courants */ tcgetattr(fd,&termios_p); /* On ignore les BREAK et les caracteres avec erreurs de parite */ termios_p.c_iflag = IGNBRK | IGNPAR; /* Pas de mode de sortie particulier */ termios_p.c_oflag = 0; /* Liaison a 9600 bps avec 8 bits de donnees et une parite paire */ termios_p.c_cflag = B9600 | CS8 | CLOCAL | CREAD; /* Mode non-canonique avec echo */ termios_p.c_lflag = ECHO; /* Caractères immediatement disponibles */ termios_p.c_cc[VMIN] = 1; termios_p.c_cc[VTIME] = 0; /* Sauvegarde des nouveaux parametres */ tcsetattr(fd,TCSANOW,&termios_p);
Si j'ai bien compris je crois qu'il faut que je passe une valeur à termios_p.c_cc[VTIME] en ms, qui sera mon timeout.

Code:

termios_p.c_cc[VTIME]=10 //par exemple 10ms

- Et voici la lecture des caractères en simplifié :
Code:

1 2 3 4 5 while(c!=0x0a) { /* Récupère un caractère */ read(fd, &c, 1); printf("%c\n",c); }
Ici je pense qu'il faut que je test le retour du read et qu'en fonction de celui-ci je traite le résultat.

Voilà j'ai donc quelques idées mais je n'y arrive pas, je ne sais pas trop comment m'y prendre. :oops:

Merci d'avance de votre aide !

03/04/2006, 18h47
PRomu@ld

Ta question est peut être plus appropriée dans le forum developpement linux.
03/04/2006, 19h26
Jack_serious

Citation:

Envoyé par PRomu@ld

Ta question est peut être plus appropriée dans le forum developpement linux.

Pas necessairement.

Citation:

Envoyé par olivier857

Voilà j'ai donc quelques idées mais je n'y arrive pas, je ne sais pas trop comment m'y prendre. :oops:

J'avoue que j'ai du mal a saisir ton probleme.

D'apres tes explications tu as deja trouve la solution a ton probleme non ?

Effectivement avec termios tu peux definir un timeout, et d'autres choses encore.

Donc ensuite juste en recuperant la valeur de retour de read, tu peux savoir combien de caracteres ont ete lus.

Ou est le probleme ?

Un fois le timeout defini, read ne peut pas rester bloque plus longtemps que ce qui est defini dans le timeout.

Si il y a quelque chose a lire avant que le timeout expire, read se debloque tout de suite.

Ou est ce que ca coince ?
04/04/2006, 00h45
olivier857
Citation:

Envoyé par PRomu@ld

Ta question est peut être plus appropriée dans le forum developpement linux.

Bein j'avoue avoir hésité entre les 2, mais ma question est plus orienté code en C et j'ai remarqué que dans le forum developpement linux, il y avait plutôt des questions logiciels, installation et un peu moins code.

Citation:

Envoyé par Jack_serious

J'avoue que j'ai du mal a saisir ton probleme.

D'apres tes explications tu as deja trouve la solution a ton probleme non ?

Effectivement avec termios tu peux definir un timeout, et d'autres choses encore.

Oui en fait j'ai bien des idées mais au niveau code j'y arrive pas.

Citation:

Envoyé par Jack_serious

Donc ensuite juste en recuperant la valeur de retour de read, tu peux savoir combien de caracteres ont ete lus.

Ou est le probleme ?

Un fois le timeout defini, read ne peut pas rester bloque plus longtemps que ce qui est defini dans le timeout.

Si il y a quelque chose a lire avant que le timeout expire, read se debloque tout de suite.

Ou est ce que ca coince ?

Dans mon cas je lis caractère par caractère.

Je ne sais pas trop comment se comporte le retour du Read(). Et comment le timeout se comportera dessus.

C'est à ce niveau que je cherche des infos.

Et également comment il faut que je configure le "termios".
Ais-je raison dans ce que j'ai dit dans mon premier post ou faut t’il s'y prendre différemment.

Il faut changer que c'est 2 ligne là ? :
Code:

1 2 termios_p.c_cc[VMIN] = 1; termios_p.c_cc[VTIME] = 0;
Dans mon cas je veux que le read ce déclanche sur lecture d'un caractère et que entre chaque lecture d'un caractère ca ne dépasse pas plus de 2 ms. Par contre entre chaque lecture de trame il faut plus que les 2ms soit valable. Je veu le timeout après la lecture du premier caractère et je veu qu'il s'arette en fin de lecture de trame (quand on a 0x0a).

Voilà j'espère avoir été plus claire.

Slt,

alors ca y est j'ai fait un premier code, mais c'est pas parfait !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
void start_timeout(int fd)
{
  struct termios termios_p;  
  tcgetattr(fd,&termios_p); 
  termios_p.c_cc[VMIN] = 1;
  termios_p.c_cc[VTIME] = TIMEOUT; 
  tcsetattr(fd,TCSANOW,&termios_p);
}
 
void stop_timeout(int fd)
{
  struct termios termios_p;  
  tcgetattr(fd,&termios_p); 
  termios_p.c_cc[VMIN] = 1;
  termios_p.c_cc[VTIME] = 0; 
  tcsetattr(fd,TCSANOW,&termios_p);
}
 
int main () {  
  int fd,n,stop;
  int i,j,num_int,somme,CRC_calc,CRC_lu;
  char recup_port[20],num_str[20];
  char c;
 
  /* Ouverture de la liaison série */
  fd = open(PORT, O_RDWR | O_NOCTTY);
  if (fd <0) {perror(PORT); exit(-1); }  
  /* Configuration du termios */
  config_termios(fd);
 
  /* Boucle de lecture du port */
  while(1){  
    /* Vide le buffer */
    tcflush(fd, TCIFLUSH);
 
    /* Initialise le caractère et le compteur de caractère */
    c='\0';
    i=0;
    stop=FALSE;
 
    while((c!=0x0a) & (stop==FALSE)){
      /* Récupère un caractère */
      n=read(fd, &c, 1);
 
      if (i==0){
      /* Lance le timeout */
      start_timeout(fd);
      }
 
      if (n>0){    // si timeout non dépassé
        printf("%c\n",c);        
        /* Concatène le caractère dans le string recup_port */
        recup_port[i]=c;
        i++;
      }
      else{        // si timeout dépassé
        /* Stop le timeout */
        stop_timeout(fd);
        printf("Erreur de lecture carte : TimeOut dépassé\n");
        /* Réinitialise les variables pour faire une nouvelle boucle */
        stop=TRUE;
        c=0x0a;      
      }
    }
 
    /* Stop le timeout */
    stop_timeout(fd);
 
    if (!stop){
      ...
    }
  }
 
/* Fermeture de la liaion serie */
close(fd);   
 
return 0;
}

Voilà donc ca marche un peu près. Si je mais un timeout trop faible (<1ms) le programme affiche bien "Erreur de lecture carte : TimeOut dépassé" et se remet en attente d'une nouvelle trame.

Mais le problème et la façon dont j'ai décléré mon timeout et donc le comportement du read.

J'ai fait ca :

Code:

1
2
3
4
5
6
7
8
void start_timeout(int fd)
{
  struct termios termios_p;  
  tcgetattr(fd,&termios_p); 
  termios_p.c_cc[VMIN] = 0;
  termios_p.c_cc[VTIME] = TIMEOUT; 
  tcsetattr(fd,TCSANOW,&termios_p);
}

et j'aurai préfaré cà :

Code:

1
2
3
4
5
6
7
8
void start_timeout(int fd)
{
  struct termios termios_p;  
  tcgetattr(fd,&termios_p); 
  termios_p.c_cc[VMIN] = 1;
  termios_p.c_cc[VTIME] = TIMEOUT; 
  tcsetattr(fd,TCSANOW,&termios_p);
}

C'est à dire que dans le 1er cas mon read se déclanche uniquement toute les valeurs de mon timeout et dans le second sur lecture d'un caractère ou toute les valeur du timeout (si il est atteind avant une lecture d ecaractère).

Comme je l'ais dis le 1er cas marche mais pas le second. Dans le second l'erreur timeout ne se lance jamais. J'ai l'impression que quand je met 1 dans VMIN le timeout inscrit dans VTIME n'est pas pris en compte. Même avec un timeout très faible l'erreur timeout ne se déclenche pas.

04/04/2006, 16h45
Jack_serious
En fait, read() se comporte de maniere tres differente selon le parametrage de VMIN et VTIME.
- Si VMIN et VTIME sont tous deux a 0, alors read devient totalement non-bloquant. Sauf dans certains cas extremement precis, c'est une tres mauvaise idee (dans une boucle, ca consomme tout le CPU).
- Si VMIN est a 0, et que VTIME a une valeur > 0 , c'est un read() avec un timeout. Il se debloque si il a des donnees a lire, ou quand le timeout expire.
- Si VMIN et VTIME ont une valeur, read lira au moins VMIN, puis se debloquera quand VTIME expirera ou quand il n'y aura plus rien a lire. Le timer se declenche uniquement quand VMIN caracteres ont ete lus.
- Si VTIME vaut 0 et que VMIN a une valeur, read lit au moins VMIN caracteres. Il ne se debloque pas avant. Comportement indefini dans le cas ou on fait read(fd, buffer, nbyte) avec un nbyte inferieur a VMIN.
05/04/2006, 00h39
olivier857
Citation:
Envoyé par Jack_serious

En fait, read() se comporte de maniere tres differente selon le parametrage de VMIN et VTIME.

Si VMIN et VTIME sont tous deux a 0, alors read devient totalement non-bloquant. Sauf dans certains cas extremement precis, c'est une tres mauvaise idee (dans une boucle, ca consomme tout le CPU).
Si VMIN est a 0, et que VTIME a une valeur > 0 , c'est un read() avec un timeout. Il se debloque si il a des donnees a lire, ou quand le timeout expire.
Si VMIN et VTIME ont une valeur, read lira au moins VMIN, puis se debloquera quand VTIME expirera ou quand il n'y aura plus rien a lire. Le timer se declenche uniquement quand VMIN caracteres ont ete lus.
Si VTIME vaut 0 et que VMIN a une valeur, read lit au moins VMIN caracteres. Il ne se debloque pas avant. Comportement indefini dans le cas ou on fait read(fd, buffer, nbyte) avec un nbyte inferieur a VMIN.
Donc ce que j'ai fais serait bon. Le choix de de VMIN a 0 et VTIME a une valeur > 0 est apparement la bon pour faire ce que je veu.

Effectivement je veux que le read ce déclenche soit sur lecture de 1 caractère soit si le timeout est dépassé.
J'avais mal compris, je croyer que pour cela il fallait la configuration VMIN=1 et VTIME > 0.

Mon code était donc bon ?
05/04/2006, 01h57
Jack_serious
Citation:
Envoyé par olivier857

Citation:

Envoyé par Jack_serious

En fait, read() se comporte de maniere tres differente selon le parametrage de VMIN et VTIME.

Si VMIN et VTIME sont tous deux a 0, alors read devient totalement non-bloquant. Sauf dans certains cas extremement precis, c'est une tres mauvaise idee (dans une boucle, ca consomme tout le CPU).
Si VMIN est a 0, et que VTIME a une valeur > 0 , c'est un read() avec un timeout. Il se debloque si il a des donnees a lire, ou quand le timeout expire.
Si VMIN et VTIME ont une valeur, read lira au moins VMIN, puis se debloquera quand VTIME expirera ou quand il n'y aura plus rien a lire. Le timer se declenche uniquement quand VMIN caracteres ont ete lus.
Si VTIME vaut 0 et que VMIN a une valeur, read lit au moins VMIN caracteres. Il ne se debloque pas avant. Comportement indefini dans le cas ou on fait read(fd, buffer, nbyte) avec un nbyte inferieur a VMIN.

Donc ce que j'ai fais serait bon. Le choix de de VMIN a 0 et VTIME a une valeur > 0 est apparement la bon pour faire ce que je veu.

Effectivement je veux que le read ce déclenche soit sur lecture de 1 caractère soit si le timeout est dépassé.
J'avais mal compris, je croyer que pour cela il fallait la configuration VMIN=1 et VTIME > 0.

Mon code était donc bon ?
Si tu veux que read se debloque soit sur un caractere soit sur timeout, il faut que VMIN soit egal a 0 et VTIME a ton timeout.

Et tu fais un read de 1 caractere.

Normalement ca devrait marcher avec le premier code que tu as fais.

Mais si tu dis que read ne se declenche que tous les timeout, dans ce cas il y a un probleme et il me vient une idee...

As-tu desactive la bufferisation de ton fd ? J'entends par la desactiver le mode canonique ?

Car il se peut que l entree soit bufferisee auquel cas il est normal que ton read reste bloque...

Essaie avec ca en plus :
Code:

1 2 termios_p.c_lflag &= ~ICANON;
05/04/2006, 08h44
olivier857
Citation:
Envoyé par Jack_serious

Si tu veux que read se debloque soit sur un caractere soit sur timeout, il faut que VMIN soit egal a 0 et VTIME a ton timeout.

Et tu fais un read de 1 caractere.

Normalement ca devrait marcher avec le premier code que tu as fais.

Mais si tu dis que read ne se declenche que tous les timeout, dans ce cas il y a un probleme et il me vient une idee...

As-tu desactive la bufferisation de ton fd ? J'entends par la desactiver le mode canonique ?

Car il se peut que l entree soit bufferisee auquel cas il est normal que ton read reste bloque...

Essaie avec ca en plus :

Code:

1 2 termios_p.c_lflag &= ~ICANON;
Alors oui je pense l'avoir fait je nn'ai pas mis :

Code:

termios_p.c_lflag &= ~ICANON;

mais ca :

Code:

termios_p.c_lflag &=0;

Tu me corrigera si j'ai tord mais je crois que c'est la même chose, enfin je vais tester tout de même.

Bon alors voici mon code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 #define PORT "/dev/ttyS0" #define FALSE 0 #define TRUE 1 #define TIMEOUT 5 /* en ms */ void config_termios(int fd) { struct termios termios_p; /* Lecture des parametres courants */ tcgetattr(fd,&termios_p); /* On ignore les BREAK et les caracteres avec erreurs de parite */ termios_p.c_iflag = IGNBRK | IGNPAR; /* Pas de mode de sortie particulier */ termios_p.c_oflag = 0; /* Liaison a 9600 bps avec 8 bits de donnees et une parite paire */ termios_p.c_cflag = B9600 | CS8 | CLOCAL | CREAD; /* Mode non-canonique avec echo */ termios_p.c_lflag = 0; /* accès bloquant jusqu'à ce que 1 caractère soit lu sans timeout */ termios_p.c_cc[VMIN] = 1; termios_p.c_cc[VTIME] = 0; /* Sauvegarde des nouveaux parametres */ tcsetattr(fd,TCSANOW,&termios_p); } void start_timeout(int fd) { struct termios termios_p; tcgetattr(fd,&termios_p); termios_p.c_cc[VMIN] = 0; termios_p.c_cc[VTIME] = TIMEOUT; tcsetattr(fd,TCSANOW,&termios_p); } void stop_timeout(int fd) { struct termios termios_p; tcgetattr(fd,&termios_p); termios_p.c_cc[VMIN] = 1; termios_p.c_cc[VTIME] = 0; tcsetattr(fd,TCSANOW,&termios_p); } int main () { int fd,n,stop; int i,j,num_int; char recup_port[20],num_str[20]; char c; /* Ouverture de la liaison série */ fd = open(PORT, O_RDWR | O_NOCTTY); if (fd <0) {perror(PORT); exit(-1); } /* Configuration du termios */ config_termios(fd); /* Boucle de lecture du port */ while(1){ /* Vide le buffer */ tcflush(fd, TCIFLUSH); /* Initialise le caractère et le compteur de caractère */ c='\0'; i=0; stop=FALSE; while((c!=0x0a) & (stop==FALSE)){ /* Récupère un caractère */ n=read(fd, &c, 1); if (i==0){ /* Lance le timeout */ start_timeout(fd); } if (n>0){ // si timeout non dépassé printf("%c\n",c); /* Concatène le caractère dans le string recup_port */ recup_port[i]=c; i++; } else{ // si timeout dépassé -> ereur /* Stop le timeout */ stop_timeout(fd); printf("Erreur de lecture carte : TimeOut dépassé\n"); /* Réinitialise les variables pour faire une nouvelle boucle */ stop=TRUE; c=0x0a; } } /* Stop le timeout */ stop_timeout(fd); if (!stop){ // si pas d'erreur ... /* traitement des données lues */ } /* Tempo : évite d'endormir le programme de lecture sur la même carte */ sleep(1); } /* Fermeture de la liaion serie */ close(fd); return 0; }
Mon code doit effectuer la lecture des numéros de cartes à puces qui se badge sur le lecteur de carte brancher a mon port série.
Chaque numéro de carte est composé comme suit : 000000xxxxx\r\n
C'est pour cela que je fais une boucle "while(c!=0x0a)", chacune de c'est boucle corresponde a la lecture d'une trame (d'une carte) et s'arrète donc à la lecture du dernier caractère d ela carte qui est tjs \n (0x0a). ensuite la boucle extérieur while(1) permet d epasser à une autre carte. J'ai positionné les start-timeout et stop-timeout pour que le time-out soit valide après la lecture du 1er caractère de chaque carte et s'annule après la lecture du dernier caractère.

Je voudrais être sure de bien comprendre tout le fonctionement du code. Avec mon code, j'ai l'impression que le read est belle est bien bloquant lors de la lecture du 1er caractère mais par la suite celui-ci n'est plus bloquant il lit tous les autres caractère de la carte les uns après les autres (normal la boucle while(0x0a) s'effectue bien) mais sans que le read soit bloquant entre les autres caractères. Quand j'execute le code en mode pas à pas le read se bloque une seul fois.

Cela me parait logique la lecture de la carte se fait qu'une fois et on peut la retirer de suite sans atteindre la fin de la boucle. Je suppose alors que même si les un seul caractère est récupéré lors du passage de la carte les autres sont positionnés dans le buffer. Or ce que je voudrais savoir c'est est-ce que le read éxécute bien un timeout ensuite sur la lecture de chaque caractère positionné dans le buffer? Difficile à vérifié car si tout marche bien la lecture du read se déclenche sur la lecture du caractère(imédiat) et non pas du timeout dépassé.