Discussion :

[Ikit]

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 )

[Laurent Gomila]

(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

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

Après, bâtir un timer sur ce genre de fonction est assez trivial.

[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 ?

[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.

[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

/* 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 ?

[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.

[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.

[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.

[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 !

[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

[Nico65]

un chrono :

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
 
#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

[SKZ81]

sigaction
alarm
setitimer
Sous Unix faire

Code :

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

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).

[Aratox]

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

Fichier timer.c :

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
#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

[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.