Discussion :

[untipy]

Bonjour
un histoire de temps !!
Voici un timer en C qui fonctionne sur un système unix (par appel système).
Une fois lancé ce timer fonctionne en boucle, a chaque fin de la tempo il exécute proc.
Comment fait on pour l'arrêter pendant son exécution (cf dernieres lignes du programme)
avez-vous des pistes?
Merci

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
#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
#include <errno.h>
 
extern int errno;
 
void proc(){/*procedure executee lorsque le signal SIGALRM est recu */
  fprintf(stdout,"5 secondes ecoulees!\n"); 
}
 
main(){
  char input[30];
  struct itimerval timer; /
 
#ifdef BSD
  signal(SIGALRM,proc);  
#else 
  struct sigaction act;
  act.sa_handler = proc;
  act.sa_flags = SA_RESTART; 
  if(sigaction(SIGALRM, &act, NULL) == -1) {
    fprintf(stderr,"error %d in sigaction\n");
  }
#endif
 
/* Config du timer */
  timer.it_interval.tv_sec = 5;  
  timer.it_interval.tv_usec = 0; 
  timer.it_value.tv_sec = 5;     
  timer.it_value.tv_usec = 0;    
  setitimer(ITIMER_REAL, &timer, 0); 
  while(1){
    while((fscanf(stdin,"%30s",input)<0)&&(errno=EINTR));
    fprintf(stdout,"%s\n",input); 
	if(!strncmp(input,"quit",5)){	/* demade de stop timer*/
            memset(&timer, 0, sizeof(timer));	/* MARCHE PAS*/
        } 
  }
}

[Emmanuel Delahaye]

Voici un timer en C qui fonctionne sur un système unix (par appel système).
Une fois lancé ce timer fonctionne en boucle, a chaque fin de la tempo il exécute proc.
Comment fait on pour l'arrêter pendant son exécution (cf dernieres lignes du programme)

[Unixoïde]
Utilise plutôt select().

[untipy]

j'ai trouvé de la doc
As tu un exemple stp ?

[crocodilex]

Bonjour
un histoire de temps !!
Voici un timer en C qui fonctionne sur un système unix (par appel système).
Une fois lancé ce timer fonctionne en boucle, a chaque fin de la tempo il exécute proc.
Comment fait on pour l'arrêter pendant son exécution (cf dernieres lignes du programme)
avez-vous des pistes?
Merci

Une solution serait peut être de restituer l'ancien gestionnaire d'alarme et l'ancien timer :

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
int main(void)
{
    [...]
    struct itimerval timer;
    struct itimerval old_timer;

    [...]
    
    struct sigaction act;
    struct sigaction old_act;
    
    [...]
    
    if(sigaction(SIGALRM, &act, &old_act) == -1)
    {
        fprintf(stderr,"error %d in sigaction\n");
    }

    [...]
    
    if ( getitimer(ITIMER_REAL, &old_timer) != 0)
    {
        /* Traitement d'erreur */
    }
    
    if ( setitimer(ITIMER_REAL, &timer, 0) != 0)
    {
        /* Traitement d'erreur */
    }
    
    while(1)
    {
        [...]
        
        if(!strncmp(input,"quit",5))
        {	/* demade de stop timer*/
                if ( setitimer(ITIMER_REAL, &old_timer, 0) != 0)
                {
                    /* Traitement d'erreur */
                }
                
                if( sigaction(SIGALRM, &old_act, NULL) != 0)
                {
                    /* Traitement d'erreur */
                }
        }
    }
    
    return 0;
}

[DaZumba]

Voici un petit exemple utilisant select() pour attendre 5 secondes pour que l'utilisateur entre quelque-chose. S'il l'a fait, on imprime ce qui a ete saisit. Tu devrais pouvoir l'adapter a ton usage.

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
 
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
 
static int input_timeout(int filedes, unsigned int seconds)
{
  fd_set set;
  struct timeval timeout;
 
  /* 
   * Initialize the file descriptor set. 
   */
  FD_ZERO(&set);
  FD_SET(filedes, &set);
 
  /* 
   * Initialize the timeout data structure. 
   */
  timeout.tv_sec = seconds;
  timeout.tv_usec = 0;
 
  /* 
   * select returns 0 if timeout, 1 if input available, -1 if error. 
   */
  return select(FD_SETSIZE, &set, NULL, NULL, &timeout);
}
 
static void get_and_display(FILE *f)
{
#define MAXLEN 10
  char line[MAXLEN];
  char *p;
 
  fgets(line, sizeof line, f);
 
  p = strchr(line, '\n');
  if (p != NULL)
  {
    *p = '\0';
  }
  else
  {
    fprintf(stderr, "Line too long: Will be truncated.\n");
    line[MAXLEN - 1] = '\0';
    {
      /*
       * empty the stdin buffer
       */
      int c;
      while ((c = fgetc(f)) != '\n' && c!= EOF);
    }
  }
#undef MAXLEN
 
  printf("You entered %s.\n", line);
}
 
int main (void)
{
  int ret;
  int seconds = 5;
 
  printf("You have %d seconds to enter something.\n", seconds);
  ret = input_timeout(STDIN_FILENO, seconds);
 
  switch (ret)
  {
    case 1:
      get_and_display(stdin);
      break;
    case 0:
      printf("Time elapsed.\n");
      break;
    case -1:
      perror("select() on standard input");
  }
 
  return 0;
}

[souviron34]

c'est pas memset qu'il faut mettre.. Il faut remettre tous les champs à 0, et faire :

Code :

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

1
2
3
4
5
6
7
8
 
       rttimer.it_value.tv_sec     = 0 ;
       rttimer.it_value.tv_usec    = 0 ;
       rttimer.it_interval.tv_sec  = 0 ;
       rttimer.it_interval.tv_usec = 0 ;
 
       signal ( SIGALRM, (void (*)())act );
       setitimer (ITIMER_REAL, &rttimer, &old_rttimer);

[Zef14]

j'ai trouvé de la doc
As tu un exemple stp ?

Un autre exemple qui m'a servi pas plus tard qu'hier :

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
 
       #include <sys/time.h> 
       #include <sys/types.h> 
       #include <unistd.h> 
 
       #define STDIN 0  /* Descripteur de fichier pour entrée standard */
 
       main()
       {
           struct timeval tv;
           fd_set readfds;
 
           tv.tv_sec = 2;
           tv.tv_usec = 500000;
 
           FD_ZERO(&readfds);
           FD_SET(STDIN, &readfds);
 
           /* ignorer writefds et exceptfds: */
           select(STDIN+1, &readfds, NULL, NULL, &tv);
 
           if (FD_ISSET(STDIN, &readfds))
               printf("Une touche a été pressé !\n");
           else
               printf("Timed out.\n");
       }

Il attend 2.5 secondes qu'on appuie sur une touche.

[Emmanuel Delahaye]

Un autre exemple qui m'a servi pas plus tard qu'hier :

Code :

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

1
2
3
4
5
6
 
       #include <sys/time.h> 
       #include <sys/types.h> 
       #include <unistd.h> 
 
       #define STDIN 0  /* Descripteur de fichier pour entrée standard */

Huh ! POSIX.1 définit FILENO_STDIN...

[Zef14]

Huh ! POSIX.1 définit FILENO_STDIN...

C'est pas pour rejeter la faute sur quelqu'un d'autre, mais j'ai trouvé l'exemple ici.

Même s'il est pas parfait il m'a permis de comprendre comment la fonction marche. Ca pourrait également le cas pour untipy.

[untipy]

Merci de vos reponses.
C'est bon j'ai solutionné mon pb

bon week-end a tous