Fonction à intervalles régulier

Version imprimable

21/05/2010, 12h24
la_praline

Fonction à intervalles régulier

Bonjour à tous,

Je suis sous unix et je bosse sur une application sur laquelle je désire rajouter un module un écran d'accueil pour être précis et celui doit se remettre à jour à intervalle de temps régulier. (Pourquoi pas utiliser boost).

Comment est ce que je dois m'y prendre ? Dois je forcément créer un processus a part y a t'il une fonction qui me permette de réaliser ça directement. Je vous remercie pour votre aide.
21/05/2010, 12h51
haraelendil

Pour faire ce genre de chose on utilise généralement des objets appelés timer, qui permettent d'exécuter un fonction qu'on leur donne à interval régulier.

Je ne connais pas bien boost, mais je suis sur à 99% qu'il doit bien y avoir une classe timer...

[EDIT]
il y a bien ce qu'il faut:
http://www.boost.org/doc/libs/1_43_0...mer/index.html
[/EDIT]

Voici le code de la classe timer. J'avais vu cette classe il ne semble pas à moins erreur de ma part une méthode me permettant de réussir à lancer une méthode à intervalle de temps régulier.

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
 
class timer
{
 public:
         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
//         timer( const timer& src );      // post: elapsed()==src.elapsed()
//        ~timer(){}
//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
  double elapsed() const                  // return elapsed time in seconds
    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
 
  double elapsed_max() const   // return estimated maximum value for elapsed()
  // Portability warning: elapsed_max() may return too high a value on systems
  // where std::clock_t overflows or resets at surprising values.
  {
    return (double((std::numeric_limits<std::clock_t>::max)())
       - double(_start_time)) / double(CLOCKS_PER_SEC); 
  }
 
  double elapsed_min() const            // return minimum value for elapsed()
   { return double(1)/double(CLOCKS_PER_SEC); }
 
 private:
  std::clock_t _start_time;
};

Je vois pas encore concrètement de méthode me permettant de m'aider.

21/05/2010, 14h14
la_praline

J'ai déjà vue certaine solution mais l'idée s'est qu'étant donné qu'il s'agit d'un accueil l'utilisateur doit pouvoir continuer à interagir avec la fenêtre le timer ne doit pas bloquer l'application. Je suis donc à la recherche d'une méthode réalisant cela.

Donc la question quelle méthode utilisée ? Faut il forcément créer un nouveau thread ?
21/05/2010, 15h29
atttchoum

Qu'utilises tu pour faire ton IHM ?
Si le timer ne doit pas être bloquant un thread vas surement devoir être créé quelque part mais tu n'auras pas forcement a le gérer.

Hello,
Voici la classe de timer que nous utilisons au boulot. C'est basé sur boost.asio et boost.signal2 et ca correspond à ce que tu cherche je crois.

Le cpp:

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
#include "AsioClock.h"
 
CAsioClock::CAsioClock()
:m_io_service(),
m_timer(m_io_service),
m_stop(true)
{
}
 
CAsioClock::~CAsioClock()
{
	Reset();
}
 
void CAsioClock::Run()
{
	if (m_stop)
	{
		m_io_service.reset();
		m_stop = false;
	}
 
	m_timer.expires_from_now( boost::posix_time::milliseconds(static_cast<int>(m_sampling_time * 1000)) );
 
	m_timer.async_wait(boost::bind(&CAsioClock::HandleCount, 
		this, 
		boost::asio::placeholders::error)
		);
 
	// Launch io_service
	m_thread.reset(new boost::thread(boost::bind(&boost::asio::io_service::run, boost::ref(m_io_service))));
}
 
void CAsioClock::Stop()
{
	if (!m_stop)
	{
		m_stop = true;
 
		m_io_service.stop();
		m_thread->join();
	}
}
 
bool CAsioClock::IsRunning()
{
	return !m_stop;
}
 
/*void CAsioClock::Resume()
{
	m_time += m_sampling_time;
	Run();
}*/
 
void CAsioClock::Reset()
{
	Stop();
	m_time = GetBeginTime();
}
 
void CAsioClock::Next()
{
	try{
 
		m_time += m_sampling_time;
		m_signal();
 
	}
	catch(std::exception & e)
	{
		std::cerr<<e.what()<<std::endl;
	}
}
 
 
void CAsioClock::HandleCount (const boost::system::error_code& error)
{
	try{
 
	if (!error && (m_stop == false) )
	{
		m_time += m_sampling_time;
		if(m_time > m_end_time && m_end_time > m_begin_time)
			m_stop = true;
 
		// Execute signals
		m_signal();
 
		m_timer.expires_at(m_timer.expires_at() + boost::posix_time::millisec(static_cast<int>(m_sampling_time * 1000) ));
 
		m_timer.async_wait(boost::bind(&CAsioClock::HandleCount, 
		this, 
		boost::asio::placeholders::error)
		);
	}
 
	}
	catch(std::exception & e)
	{
		std::cerr<<e.what()<<std::endl;
	}
}

Le header

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#ifndef ASIO_CLOCK_H
#define ASIO_CLOCK_H
 
#define _WIN32_WINNT 0x0501
 
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <boost/signals2.hpp>
 
class CAsioClock
{
public:
 
	typedef boost::signals2::signal<void()> signal;
 
	/**
        * \brief Default constructor.
        */
	CAsioClock();
 
	/**
        * \brief Clock destructor. Call Stop().
        */
	~CAsioClock();
 
	/**
        * \brief Start the Clock.
        */
	void Run();
 
	/**
        * \brief Stop the Clock.
        */
	void Stop();
 
	/**
        * \brief Call next clock only.
        */
	void Next();
 
	/**
        * \brief Reset the clock.
        */
	void Reset();
 
	/**
        * \brief Return true if the clock is running.
        */
	bool IsRunning();
 
/**
        * \brief Set sampling time
        * \param sampling_time sampling time of the clock
        */
	virtual void SetSamplingTime(double sampling_time)
	{
		m_sampling_time = sampling_time;
	}
 
	/**
        * \brief Set the current time
        * \param time current time
        */
	virtual void SetCurrentTime(double time)
	{
		m_time = time;
	}
 
	/**
        * \brief Set the clock limits
        * \param begin_time starting time
        * \param end_time end time of the clock
        */
	virtual void SetTimeLimits(double begin_time, double end_time)
	{
		m_begin_time = begin_time;
		m_end_time = end_time;
		m_time = m_begin_time;
	}
 
	/**
        * \brief Get the sampling time
        */
	virtual double GetSamplingTime() const 
	{
		return m_sampling_time;
	}
 
	/**
        * \brief Get the current time
        */
	virtual double GetTime() const 
	{
		return m_time;
	}
 
	/**
        * \brief Get start time of the clock
        */
	virtual double GetBeginTime() const 
	{
		return m_begin_time;
	}
 
	/**
        * \brief Get the end time of the clock
        */
	virtual double GetEndTime() const 
	{
		return m_end_time;
	}
 
	/**
        * \brief Return the boost signal called on each clock tick
        */
	signal & GetSignal()
	{
		return m_signal;
	}
 
 
private:
 
 
	void HandleCount (const boost::system::error_code&);
 
	boost::shared_ptr<boost::thread> m_thread;
	boost::asio::io_service			m_io_service;
	boost::asio::deadline_timer		m_timer;
 
        double							m_sampling_time;
	double							m_time;
 
	double							m_begin_time;
	double							m_end_time;
 
	signal							m_signal;
	bool							m_stop;
	bool							m_running;
};
 
#endif

J'ai enlevé les bouts qui t'intéresse pas forcement (gestion du XML notamment) donc ca compilera peut etre pas du premier coup. Il suffit d'enregistrer les fonctions à appeler dans la variable m_signal.