Discussion :

[playboard]

Bonjour,

Je rencontre un problème, avec l'utilisation de la fonction select(), pour situer un peu le problème, je souhaite utiliser cette fonction afin que mon "read" ne soit plus bloquante et qu'en cas de non réception de données le programme ne bloque pas sur ce fameux read. Je suis donc tombé sur la fonction select() et après avoir regardé pas mal de documentations dessus, je me suis lancé, mais malheureusement sans grand succès.

A l'heure actuelle, aucune erreur à la compilation le seul problème est que je lis bien les 4 premières secondes puis je passe en "Timeout" alors que je reçois toujours bien quelque chose.
La seule chose que je veux, en gros, c'est que seulement si je ne reçois rien pendant 5 secondes alors seulement à ce moment la je passe dans la boucle timeout.
Mais peut-être ai-je mal compris le principe de la fonction select()...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <time.h>
#include <sys/time.h>
#include <time.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/select.h>
 
 
#define OFFSET 47700
 
int main(void)
{
 
	int port_serie=0;
    int reception=0;
	int i=0, calcul=0,rc=0,rv;
	char buffer[36] = "";
	char verif[7] ="";
 
    struct timeval times;
	struct timezone timezs;
	struct timeval timeg;
	struct timezone timezg;
    struct termios options;
 
    fd_set set;
    FD_ZERO(&set); /* clear the set */
    FD_SET(port_serie, &set); /* add our file descriptor to the set */
 
    struct timeval timeout;
    timeout.tv_sec = 5;
    timeout.tv_usec = 0;
 
    time_t timestamp = time(NULL);
 
// 	Paramètres concernant la zone géographique. On n'y touche pas.
    timezs.tz_minuteswest=0;
    timezs.tz_dsttime=0;
 
//	lecture et ecriture | pas controlling terminal | ne pas attendre DCD
    port_serie = open("/dev/ttySP4", O_RDWR | O_NOCTTY | O_NONBLOCK | O_NDELAY);
 
	if(port_serie < 0 ) //cas d'erreur d'ouverture
	  {
		perror("Erreur d'ouverture du port serie, veuillez verifier que l'antenne est bien branché :");
		exit(-1);
	  }
 
	else // cas ouverture réussie
	  {
 
		tcgetattr(port_serie, &options);//chargement des données
		cfsetospeed(&options, B4800);//B4800 bauds
		options.c_cflag |= (CLOCAL | CREAD);//programme propriétaire du port
//		structure en 8N1 !!
		options.c_cflag &= ~PARENB; //pas de parité
		options.c_cflag &= ~CSTOPB; // 1 bit de stop
		options.c_cflag &= ~CSIZE; //option a 0
		options.c_cflag |= CS8; //8 bits
		tcsetattr(port_serie, TCSANOW, &options); //enregistrement des valeurs de configuration du port serie 1
 
		printf("Configuration OK strcuture en 8N1 !. \n");
 
		do
		  {
            calcul =0;  //On réinitialise la variable qui sert à calculer le checksum
 
            tcflush(port_serie,TCIFLUSH);// On vide à chaque fois le buffer du port série en entrée
            fcntl(port_serie,F_SETFL,10); //La fonction read est en mode bloquant. On attend tant qu'on ne reçoit pas de caractères.
 
            rv = select(port_serie +1, &set,NULL,NULL, &timeout);
 
            if(rv == -1)
               perror("select"); /* an error accured */
            else if(rv == 0)
               printf("timeout"); /* a timeout occured */
            else
              {
                reception=read(port_serie,buffer,34);// On vient lire 34 octets placés dans le buffer provenant du port série.
              }
 
		  }while(1);
 
	  }
	  close(port_serie);
	  return 0;
  }

Quelqu'un aurait-il une idée .?

Merci d'avance

[Neckara]

Bonjour,

Il me semble que lorsque select retourne, il écrit dans ta variable "timeout" le temps restant à attendre.
Il faut donc à chaque tour de boucle réaffecter à timeout le temps à attendre.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
while(1)
{
      timeOut = tempsAAttendre;
      select(..., &timeout );
 
}

[ram-0000]

Il me semble que lorsque select retourne, il écrit dans ta variable "timeout" le temps restant à attendre.
Il faut donc à chaque tour de boucle réaffecter à timeout le temps à attendre

Je confirme

[Dinoosaure]

Tu devrais aussi utiliser la macro FD_ISSET pour savoir si port_serie peut être lu. Ici, il n'y a pas trop d'utilité mais quand tu manipules plusieurs file descriptor, il peut être intéressant (et même nécessaire) de savoir lequel peut être lu (sous peine d'avoir un read bloquant).

Sinon, il faut re-assigner le timeout à chaque itération de la boucle en effet.