Appel periodique d'une fonction

Version imprimable

09/07/2008, 16h48
Nowoday

Appel periodique d'une fonction

Bonjour a tous,

je voudrais faire appel a une fonction toutes les 20 secondes sans bloquer le systeme entre temps. J'ai donc pense a une interruption declenchee par un timer. J'ai deja realise quelque chose de ce type en assembleur ou un registre est specialement dedie a cette tache mais jamais en langage evolue.

Auriez-vous des pistes sachant que je ne peux pas installer d'autres bibliotheques que les standards ni utiliser un autre langage?

Je vous remercie.
09/07/2008, 16h52
Médinoc

Qu'appelles-tu "les standards" ?

Il est impossible de faire ça en C++ standard absolu, tu as besoin au moins de l'API système.

Précise aussi ce que signifie "sans bloquer le système entre temps". Si ça veut juste dire "pas de boucle d'attente active", un bète sleep() ou Sleep() de l'API système correspondante répond à la question. Si c'est "ne pas bloquer le reste du processus", c'est impossible sans multithreading ou trucs plus ésotériques encore.
09/07/2008, 17h18
Nowoday

En fin de compte je realise un driver pour controler un ampli optique.

Je communique par RS232. Je voudrais avoir un log de l'etat du systeme par intervalles de 20 secondes en pouvant toute fois continuer a piloter le systeme sans contrainte.

J'ai vu que boost::asio pouvait contenir des choses interessantes mais pour mon application finale je ne pourrais pas l'integrer (systeme embarque).
09/07/2008, 18h01
loufoque

Faire des pilotes en C++ pour Linux par exemple, c'est pas forcément simple.
De quel système d'exploitation s'agit-il ?
09/07/2008, 19h00
Nowoday

Ca tourne sur windows XP et mon programme n'a pas besoin d'etre portable.
09/07/2008, 19h37
ram-0000
tu crées un thread dans ton service ou driver et tu le met en attente bloquante avec timeout de 20 secondes sur un objet genre CEvent.

Au bout de 20 secondes, ton thread est libéré, tu fais ton boulot et tu retournes en attente avec timeout.

Si l'événement est signalé, alors le thread doit s'arrêter

Merci bcp
je vais voir ca.

EDIT:

La fonction WaitforSingleObject ne prend pas tout le processeur ?
Est ce que je peux faire tourner mon programme en mm temps ? A premiere vue ca n'as pas l'air le cas.

Voici mon programme test :

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
#include <windows.h>
#include <stdio.h>
 
HANDLE ghEvent; 
 
DWORD WINAPI Requetes( LPVOID );
 
void main()
{
    HANDLE aThread;
    DWORD ThreadID;
    int i;
 
	ghEvent = CreateEvent(0,false,true,NULL);
 
    if (ghEvent == NULL) 
    {
        printf("CreateEvent error: %d\n", GetLastError());
        return;
    }
 
    aThread = CreateThread( 
                 NULL,       // default security attributes
                 0,          // default stack size
                 (LPTHREAD_START_ROUTINE) Requetes, 
                 NULL,       // no thread function arguments
                 0,          // default creation flags
                 &ThreadID); // receive thread identifier
 
    if( aThread == NULL )
    {
        printf("CreateThread error: %d\n", GetLastError());
        return;
    }
 
    WaitForSingleObject(aThread, INFINITE);
 
    CloseHandle(aThread);
 
    CloseHandle(ghEvent);
 
}
 
DWORD WINAPI Requetes( LPVOID lpParam )
{ 
    DWORD dwCount=0, dwWaitResult; 
 
    while( dwCount < 3 )
    { 
        dwWaitResult = WaitForSingleObject( 
            ghEvent,    ///< handle to event
            4000);		///< 4sec
 
        switch (dwWaitResult) 
        {
            case WAIT_TIMEOUT:
            { 
		printf("Hello World\n");
                break;
            }
            case WAIT_ABANDONED: 
                return FALSE; 
        }
    }
    return TRUE; 
}

Avez vous une autre methode ?
J'ai l'impression que tant que je suis dans la boucle je ne peux rien faire d'autres.

Citation:

Envoyé par Nowoday

La fonction WaitforSingleObject ne prend pas tout le processeur ?

Non, c'est pour cela qu'on l'utilise !!

Quelques petites retouches sans conséquences dans ton code :

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
 
#include <windows.h>
#include <stdio.h>
 
HANDLE ghEvent; 
 
DWORD WINAPI Requetes( LPVOID );
 
void main()
{
   HANDLE aThread;
   DWORD ThreadID;
   int i;
 
   // creation de l'evenement
   ghEvent = CreateEvent(0, false, true, NULL);
   if(ghEvent == NULL) 
   {
      printf("CreateEvent error: %d\n", GetLastError());
      return;
   }
 
   // creation du thread
   aThread = CreateThread(NULL,       // default security attributes
                 0,          // default stack size
                 (LPTHREAD_START_ROUTINE) Requetes, 
                 NULL,       // no thread function arguments
                 0,          // default creation flags
                 &ThreadID); // receive thread identifier
   if(aThread == NULL )
   {
      printf("CreateThread error: %d\n", GetLastError());
      return;
   }
 
   // ici, tu peux placer un appel a du code pour effectuer quelquechose
   // ...
   printf("Le thread principal %d est actif\n", GetCurrentThreadId());
   Sleep(1000);
 
   // attente de la fin du thread
   printf("Attente de la fin du thread...\n");
   WaitForSingleObject(aThread, INFINITE);
   printf("le thread est fini\n");
 
   // fermeture du handle du thread
   CloseHandle(aThread);
 
   // fermeture du handle de l'event
   CloseHandle(ghEvent);
}
 
// point d'entree du thread
DWORD WINAPI Requetes(LPVOID /*lpParam*/)
{
   // boucle infinie
DWORD dwCount = 0;
   for(;;)
   {
      // seulement 3 passage dans la boucle (pour l'instant je suppose)
      if(dwCount > 3)
         return TRUE;
 
      // attente d'un l'evenement avec un timeout de 4 sec
      DWORD dwWaitResult = WaitForSingleObject( 
                  ghEvent,    ///< handle to event
                  4000);		///< 4sec
      switch (dwWaitResult) 
      {
         case WAIT_TIMEOUT:
         {
            // action du thread
            printf("Hello World dans le thread %d\n", GetCurrentThreadId());
            break;
         }
 
         case WAIT_ABANDONED: 
            return FALSE; 
        }
   }
}

et le résultat obtenu dans la console :

Code:

1
2
3
4
5
6
7
 
Le thread principal 2276 est actif
Attente de la fin du thread...
Hello World dans le thread 3404
Hello World dans le thread 3404
Hello World dans le thread 3404
le thread est fini

Donc tout fonctionne bien !!

10/07/2008, 21h31
Nowoday

Ca veut dire que pendant les 4 secondes je peux executer d'autres commandes ?
10/07/2008, 22h05
ram-0000

Non, cela veut dire que tes 2 thread vont s'exécuter simultanément ou presque. Si tu as 2 CPU (ou 2 coeurs de CPU), le thread principal ET le thread "auxiliaire" pourront s'exécuter simultanément.
Si ton thread ne fait rien ou presque (attendre 4 secondes et dire hello, c'est pas grand chose), tu es sûr que cela s'exacutera de manière indépendante par rapport à ton thread principal.

Voilà, j'espère avoir été clair ?