Timer sous linux

Version imprimable

07/01/2005, 13h31
Ikit

Timer sous linux

Bonjour

j'aimerais faire que dans mon programme, à interval de temps régulier, une fonction s'éxecute... donc j'ai entendu parler des timer, mais je n'y connait absolument rien, et ça m'arrangerait de savoir comment on les crés/initialises/utilises, sous linux ...

(ps: la faq ne parle d'aucun problème relatif au temps/chronomètres/timer ... c une idée comme ça que je vous donne :) )
07/01/2005, 15h35
Laurent Gomila

Citation:

(ps: la faq ne parle d'aucun problème relatif au temps/chronomètres/timer ... c une idée comme ça que je vous donne :) )

Tu as dû mal chercher :wink:

http://c.developpez.com/faq/c/?page=...S_chronometrer

Après, bâtir un timer sur ce genre de fonction est assez trivial.
07/01/2005, 19h12
Ikit

ok ... il y a bien 1 sujet sur les chronos ^^

mais ça ne résoud pas le prob des timer sous linux :s

faut utiliser time.h pour les timer ?
07/01/2005, 19h37
Laurent Gomila

Oups désolé, j'avais zappé le fait que tu étais sous Linux. Je ne crois pas qu'il existe de timers tout faits, il faudra constuire les tiens. Pas très dur à faire une fois que tu dispose d'une bonne fonction de timing, par contre je n'en connais pas de précises sous Linux.
09/01/2005, 18h17
Ikit

re moi

donc j'ai appris qu'une bonne base pour faire les timer était la librairie
SDL:
seulement je n'ai aucune idée comment faire un timer de toute pièce et encore moins comment faire pour l'utiliser ...
voilà les renseigenement que j'ai

Citation:

/* retourne le nombre de ms sur 32 bits depuis l'initialisation de SDL */
Uint32 SDL_GetTicks(void);

/* impose une pause au processus en cours */
void SDL_Delay(Uint32 ms);

En ce qui concerne les timers, SDL fournit une fonction qui permet de placer une fonction de rappel (callback) qui sera appelée à intervalle régulier. Cette fonction de rappel pourrait être lancée dans un thread différent donc faites attention à ce que vous faites en son sein. D'autre part, la résolution maximale du timer est de 10 ms, et de fait si vous demandez un intervalle de 16 ms, la fonction sera rappelée toutes les 20ms ! Enfin n'oubliez pas de passer le flag SDL_INIT_TIMER lors de l'initialisation de SDL.

/* créer un timer */
SDL_TimerID SDL_AddTimer(Uint32 interval, SDL_NewTimerCallback callback, void *param);

/* détruire un timer */
SDL_bool SDL_RemoveTimer(SDL_TimerID id);

est-ce que à partir de ces quelques fonctions on peut faire un timer ?
comment ça marche ?
09/01/2005, 18h19
Steki-kun

si ca te gêne pas tu peux utiliser la librairie Qt ! elle est libre sous linux, la doc est en ligne et très bien faite (doc.trolltech.com), et tu as un QTimer qui te permet de faire ce genre de trucs.
09/01/2005, 18h57
Laurent Gomila

Pour ce qui est de Qt et SDL, si tu n'utilises pas déjà ces bibliothèques dans ton projet, pas la peine de les sortir pour ça.
09/01/2005, 19h04
Steki-kun

c'est pas faux ça :) alors sinon y'a linux/timer.h qui doit pouvoir faire l'affaire, le code du header est assez clair pour savoir comment on s'en sert.
10/01/2005, 02h49
SKZ81

linux/timer.h est effectivement pas mal, mais des fonction POSIX comme sigaction / alarm / setittimer sont à mon humble avis préférable en général, car beaucoup plus portables...
A celui qui code de voir !
11/01/2005, 12h35
Ikit

effectivement la portabilité m'interesse bcp ...

mais c quoi POSIX ?
on les trouve où les fonction dont tu parle?

et comment on fait un timer :? ? vous avez des tutos ?
parceque pour moi; ok faut utiliser sigaction / alarm / setittimer mais comment ?

si vous préférez, je sais qu'un timer me permettrait d'appeller une fct° à interval de tps régulier, mais c tout ... je ne connais pas la syntaxe ni rien !et je trouve aucun tutos :(

un chrono :

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
 
#ifndef COMMON_TIMER_HPP
#define COMMON_TIMER_HPP
 
#ifdef WIN32
#include <windows.h>
#else
#include <sys/time.h>
#endif
#include <sstream>
#include <iostream>
 
using namespace std;
 
 
class Timer {
private:    
#ifdef WIN32
	LARGE_INTEGER ticksPerSecond, tick1, tick2;
	DWORD temps;
#else
	struct timeval	sTime;
#endif
 
public:
	static unsigned long getTickCount()
	{
	#ifdef WIN32
		// return number of ms since last reboot
		return GetTickCount();
	#else
		// return number of ms since 1970/1/1
		struct timeval cTime;
		gettimeofday(&cTime, 0);
		return (cTime.tv_sec * 1000) + (cTime.tv_usec / 1000);
	#endif
   }    	
 
	void initTimer()
	{
	#ifdef WIN32
		temps = GetTickCount();
		QueryPerformanceFrequency(&ticksPerSecond);
  		QueryPerformanceCounter(&tick1);		
	#else
		gettimeofday(&sTime, 0);		
	#endif
	}
 
	unsigned long getMilliSec()
	{
	#ifdef WIN32
		return GetTickCount() - temps;
	#else
	   struct timeval	cTime;
	   gettimeofday(&cTime, 0);
	   return ((cTime.tv_sec - sTime.tv_sec) * 1000)
	      + ((cTime.tv_usec - sTime.tv_usec) / 1000);
	#endif
	}
 
	unsigned long getMicroSec()
	{
	#ifdef WIN32
		QueryPerformanceCounter(&tick2);
		return ((tick2.QuadPart - tick1.QuadPart) * 1000000) / ticksPerSecond.QuadPart;
	#else
	   struct timeval	cTime;
	   gettimeofday(&cTime, 0);
	   return ((cTime.tv_sec - sTime.tv_sec) * 1000000)
	      + ((cTime.tv_usec - sTime.tv_usec));
	#endif
	}
};
 
#endif

11/01/2005, 15h07
SKZ81
sigaction
alarm
setitimer
Sous Unix faire
Code:

1 2 $ man fonction
POSIX est une norme. C'est un choix pour un compilo de l'implémenter complètement ou non. GCC le propose en standard.

Le principe est le suivant :
- Créer une callback (fonction qui sera appellé)
- L'installer en tant que callback au signal SIGALRM via sigaction()
- Lancer le timer via alarm() (one-shot) ou setitimer() (périodique).

Si ca peut aider quelqu'un, Voila comment j'ai bricolé un timer sous linux.

Fichier timer.c :

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
#include <pthread.h>
#include <time.h>
#include <stdio.h>
 
void *timer(void *stop);
 
int main()
{
	int stop = 0;
 
	pthread_t thread;
	pthread_create(&thread, NULL, timer, &stop);
 
	// plins d'autres choses...
	while (1) // boucle infinie uniquement pour l'exemple
		sleep(10);
 
	return 0;
}
 
void *timer(void *stop)
{
	while (!*((int*)stop)) {
		// du code executé toutes les secondes...
		printf("tic-tac...\n");
 
		sleep(1);
		// On peut également utiliser :
		// usleep(usec); 1'000'000 us = 1 sec
	}
	return NULL;
}

n'oubliez pas -lpthread lors de la compilation.
gcc timer.c -lpthread

09/02/2010, 16h34
gangsoleil

Bonjour,

Juste pour pinailler, je rappelle que les fonctions sleep ou usleep te garantissent que tu dors au moins le temps passe en paramètre.