IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Fonction à intervalles régulier


Sujet :

C++

  1. #1
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2007
    Messages
    182
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2007
    Messages : 182
    Points : 73
    Points
    73
    Par défaut 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.

  2. #2
    Membre confirmé
    Avatar de haraelendil
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2004
    Messages
    283
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Février 2004
    Messages : 283
    Points : 533
    Points
    533
    Par défaut
    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]

  3. #3
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2007
    Messages
    182
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2007
    Messages : 182
    Points : 73
    Points
    73
    Par défaut
    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 : 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
     
    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.

  4. #4
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2007
    Messages
    182
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2007
    Messages : 182
    Points : 73
    Points
    73
    Par défaut
    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 ?

  5. #5
    Membre actif
    Profil pro
    Inscrit en
    Mars 2010
    Messages
    188
    Détails du profil
    Informations personnelles :
    Âge : 37
    Localisation : France

    Informations forums :
    Inscription : Mars 2010
    Messages : 188
    Points : 248
    Points
    248
    Par défaut
    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.

  6. #6
    Membre averti Avatar de vikki
    Profil pro
    Inscrit en
    Mai 2007
    Messages
    292
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations forums :
    Inscription : Mai 2007
    Messages : 292
    Points : 302
    Points
    302
    Par défaut
    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 : 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
    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 : 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
    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.

Discussions similaires

  1. Appel à une fonction à intervalle régulier
    Par Mozofeuk dans le forum Silverlight
    Réponses: 2
    Dernier message: 13/02/2012, 11h16
  2. [Débutant] Exécuter une fonction à intervales réguliers
    Par kikis09 dans le forum MATLAB
    Réponses: 5
    Dernier message: 11/02/2009, 15h54
  3. Réponses: 1
    Dernier message: 04/11/2006, 21h40
  4. Réponses: 4
    Dernier message: 25/02/2006, 15h54
  5. Traitement à intervalle régulier
    Par jagboys dans le forum MFC
    Réponses: 2
    Dernier message: 05/07/2005, 00h20

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo