Discussion :

[Nowoday]

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.

[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.

[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).

[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 ?

[Nowoday]

Ca tourne sur windows XP et mon programme n'a pas besoin d'etre portable.

[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

• Microsoft event
• pour l'attente avec timeout
• pour la création du thread

[Nowoday]

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 :

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
#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.

[ram-0000]

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 :

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
 
#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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !!

[Nowoday]

Ca veut dire que pendant les 4 secondes je peux executer d'autres commandes ?

[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 ?