qui a testé la librairie "temps reel" Hadcon ?

Bonjour,

Au risque de te décevoir, je ne l'ai pas testé ...
Mais les commentaires que je lis sur codeproject rejoignent ce que je sais : NT/2000/XP ne sont en aucun cas des OS Temps réel et je pense que cette librairie n'est pas une bonne solution.
Si tu veux absolument faire ton programme sous Windows, la solution la plus simple est d'utiliser la librairie winmm.lib qui offre les timers multimedias.
Fait une recherche sur le Web, ils sont simples d'utilisation et offrent une très bonne précision ... au bémol près qu'on ne maîtrise pas le jitter (glissement) temporel => on peut sans trop de problème cadencer des threads à 10 voir 1ms (mais il faut accepter que de temps en temps, il y est des "absences" - ex un swap de l'OS, un démarrage d'application).
Ci Joint un petit exemple d'encapsulation pour utiliser des threads voir des threads appelant une fonction périodiquement (avec des timers multimédias).
Ces classes sont des virtuelles pures et il suffit juste de dériver des classes concrètes implémentant le corps du thread ou la fonction qui doit être appelée périodiquement.
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
class CThread
{
 
public:
    // corps du thread
    virtual UINT BodyThread(void) = 0;        
 
    CThread();
    virtual ~CThread();
    // demarrage du thread
    void BeginThread(int nPriority = THREAD_PRIORITY_HIGHEST);
    // envoi de l'evenement d'arret
    void SendStop(void);
    // attente de la fin du thread
    void WaitTerminate(DWORD timeoutMs = INFINITE);
    // demande de l'arret du thread avec attente de sa fin
    void StopThread(DWORD timeoutMs = INFINITE) { SendStop(); WaitTerminate(timeoutMs);};
 
protected:
    HANDLE m_hEventStop;        // Evenement signale pour l'arret du thread
    HANDLE m_hThread;           // handle du thread
};
 
 
// definition d'un thread periodique
class CThreadPer : public CThread
{
 
public:
    // fonction qui sera appelee periodiquement
    // si elle renvoie une valeur differente de 0
    // on arrete le thread
    virtual UINT PeriodicFct(void) = 0;
 
    // corps du thread
    virtual UINT BodyThread(void);
 
    // fct utilisee par l'objet manager 
    void BeginThreadPer(DWORD perMs, int nPriority = THREAD_PRIORITY_HIGHEST)
    {
        // on stocke la periode d'appel
        m_perMs = perMs;
        // et on lance le thread
        BeginThread(nPriority);
    };
private:
    DWORD  m_perMs;                 // periode en ms
};

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
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
/////////////////////////////////////////////////////////////////////////////
// Procedure de demarrage du thread (param de AfxBeginThread)
/////////////////////////////////////////////////////////////////////////////
static DWORD WINAPI ProcThread(LPVOID pParam) 
{
    CThread * pThreadAcq = (CThread*) pParam;
    return pThreadAcq->BodyThread();
}
 
/////////////////////////////////////////////////////////////////////////////
// Constructeur
/////////////////////////////////////////////////////////////////////////////
CThread::CThread()
{
    m_hThread = NULL;
    m_hEventStop = ::CreateEvent(NULL, false, false, NULL);
}
 
/////////////////////////////////////////////////////////////////////////////
// Destructeur
/////////////////////////////////////////////////////////////////////////////
CThread::~CThread()
{
    if (m_hThread)
    {
        // on force l'arret du thread
        StopThread();
    }
 
    CloseHandle(m_hEventStop);
}
 
/////////////////////////////////////////////////////////////////////////////
/// Demarrage du thread
///
/// Parametres :
/// \param nPriority    priorite du thread
/////////////////////////////////////////////////////////////////////////////
void CThread::BeginThread(int nPriority)
{
    DWORD dwThreadId;
 
    // Demarrage du thread
    m_hThread = ::CreateThread( NULL
                                    , 0
                                    , ProcThread
                                    , this
                                    , CREATE_SUSPENDED
                                    , &dwThreadId
                                    );
    ::SetThreadPriority(m_hThread, nPriority);
 
    // Activation du thread
    ::ResumeThread(m_hThread);
}
/////////////////////////////////////////////////////////////////////////////
/// Demande d'arret du thread
/////////////////////////////////////////////////////////////////////////////
void CThread::SendStop(void)
{
    // Envoi de l'evenement d'arret
    SetEvent(m_hEventStop);
 
}
/////////////////////////////////////////////////////////////////////////////
/// Attente de l'arret du thread
///
/// Parametres :
/// \param timeoutMs    timeout d'attente de l'arret du thread en ms
/////////////////////////////////////////////////////////////////////////////
void CThread::WaitTerminate(DWORD timeoutMs /*= INFINITE*/)
{
    if (m_hThread == NULL)
    {
        return;
    }
 
    // Attente de l'arret effectif du thread
    WaitForSingleObject(m_hThread, timeoutMs);
 
    CloseHandle(m_hThread);
 
    m_hThread = NULL;
}
 
 
// Class CThreadPer
/////////////////////////////////////////////////////////////////////////////
// Corps du thread pour un thread periodique
/////////////////////////////////////////////////////////////////////////////
UINT CThreadPer::BodyThread(void)
{
    HANDLE hEventPer = CreateEvent(NULL, false, false, "");
    HANDLE arrEvent[2];
    arrEvent[0] = m_hEventStop;
    arrEvent[1] = hEventPer;
 
    // creation du timer periodique
    UINT idMMTimer = timeSetEvent(m_perMs, 1, (LPTIMECALLBACK )hEventPer, 0 , TIME_PERIODIC | TIME_CALLBACK_EVENT_SET);
    while (1)
    {
        unsigned int taille = sizeof(arrEvent)/sizeof(HANDLE);
        DWORD dw = WaitForMultipleObjects(sizeof(arrEvent)/sizeof(HANDLE), arrEvent, false, INFINITE);
        if (dw == WAIT_OBJECT_0)
        {
            // demande d'arret => on sort
            timeKillEvent(idMMTimer);
            CloseHandle(hEventPer);
            return 0;
        }
        else if (dw == WAIT_OBJECT_0 + 1)
        {
            // appel de la fonction periodique
            if (PeriodicFct() != 0)
            {
                // demande d'arret => on sort
                timeKillEvent(idMMTimer);
                CloseHandle(hEventPer);
                return 0;
            }
        }
        else
        {
            dw = GetLastError();
        }
    }
    return 0;
}