Bonjour,

J'ai deux classes : TTimer et pedal dont voici les headers:

template_timer.h

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
#pragma once
#include <atlbase.h>
 
static void CALLBACK TimerProc(void*, BOOLEAN);
 
// **********************************************************
// * class CTimer 											*
// **********************************************************
class CTimer
{
public:
    CTimer()
    {
        m_hTimer = NULL;
        m_mutexCount = 0;
    }
 
    virtual ~CTimer()
    {
        Stop();
    }
 
    bool Start(unsigned int interval,   // interval in ms
               bool immediately = false,// true to call first event immediately
               bool once = false)       // true to call timed event only once
    {
        if( m_hTimer )
        {
            return false;
        }
 
        SetCount(0);
 
        BOOL success = CreateTimerQueueTimer( &m_hTimer,
                                              NULL,
                                              TimerProc,
                                              this,
                                              immediately ? 0 : interval,
                                              once ? 0 : interval,
                                              WT_EXECUTEINTIMERTHREAD);
 
        return( success != 0 );
    }
 
    void Stop()
    {
        DeleteTimerQueueTimer( NULL, m_hTimer, NULL );
        m_hTimer = NULL ;
    }
 
    virtual void OnTimedEvent()
    {
        // Override in derived class
    }
 
    void SetCount(int value)
    {
        InterlockedExchange( &m_mutexCount, value );
    }
 
    int GetCount()
    {
        return InterlockedExchangeAdd( &m_mutexCount, 0 );
    }
 
private:
    HANDLE m_hTimer;
    long m_mutexCount;
};
 
// **********************************************************
// * TimerProc    											*
// **********************************************************
void CALLBACK TimerProc(void* param, BOOLEAN timerCalled)
{
    CTimer* timer = static_cast<CTimer*>(param);
    timer->SetCount( timer->GetCount()+1 );
    timer->OnTimedEvent();
};
 
// **********************************************************
// * template class TTimer									*
// **********************************************************
template <class T> class TTimer : public CTimer
{
public:
    typedef private void (T::*TimedFunction)(void);
 
    TTimer()
    {
        m_pTimedFunction = NULL;
        m_pClass = NULL;
    }
 
    void SetTimedEvent(T *pClass, TimedFunction pFunc)
    {
        m_pClass         = pClass;
        m_pTimedFunction = pFunc;
    }
 
protected:
    void OnTimedEvent()  
    {
        if (m_pTimedFunction && m_pClass)
        {
            (m_pClass->*m_pTimedFunction)();
        }
    }
 
private:
    T *m_pClass;
    TimedFunction m_pTimedFunction;
};


pedal.h

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
#pragma once
 
#include <string>
 
#include "toolbox.h"
#include "template_timer.h"
#include "const_pedal.h"
#include "tserial_event.h"
#include "enumser.h"
 
class pedal
{
public:
 
	void													enumerate(void);
	void													activate(void);
	bool													search_pedal_port(void);
	void													deactivate(void);
 
	static char*											reply_iss_version;
	static char*											reply_serial_number;
	static char*											reply_configuration;
	static char*											reply_io_state;
 
	// state comes with UP or DOWN
	static bool												pedal_state;
 
 
private:
 
	void                                                    wait_for_reply(void);
	void													OnTimedEvent_PedalReply(void);
	void													OnTimedEvent_PedalRequest(void);
	void													OnTimedEvent_PedalEnumeration(void);
	// the callback function has to be a static one if any class member !
	static void												SerialEventManager(uint32 object, uint32 event);
	static void												OnDataArrival(int size, char *buffer);
	static void												todo_on_pedalchange(void);
	void													request_iss_version(void);
	void													request_pedal_state(void);
	void													request_serial_number(void);
	void													configure_io_mode(void);
 
 
	TTimer<pedal>											timer_pedal_request;
	static TTimer<pedal>									timer_pedal_reply;
	TTimer<pedal>											timer_pedal_enumeration;
 
	static char*											serial_number;
	static std::string 										firmware_revision_number;
	// status comes with OK or not 
	static bool												pedal_status;
 
	static bool												iss_version_received;	
	static bool												io_mode_received;
	static bool												pedal_state_received;
	static bool												pedal_state_mem;
	static bool												first_pedalrequest;
	bool													pedalreply_timeelapsed;
 
 
};
La variable timer_pedal_reply est statique car utilisée dans un callback.
Je ne vois pas comment l'initialiser pour que celà passe à l'édition de lien.


Merci pour votre aide