Executer une action toute les x secondes.

**nuFox** · 06/03/2008, 12h01

Bonjour ...

Voila, je pense que le titre est assez explicite ...

Mais je vais vous planter le décors ...

J'ai réaliser un code que je compile en une DLL ... Cette dll je vais l'inclure dans labView (si vous connaissez) pour pouvoir utiliser les fonctions de ma dll.

La fonction que j'appelle est une peu sur le principe de grafcet !

Donc c'est une suite d'instruction avec des étapes ...

Dans une des étapes, je dois faire une demande toute les secondes +/- ...

Pour l'instant ce que je fais, c'est que j'utilise une variable que j'incremente a chaque passage dans ma boucle et quand elle vaut une certaine valeur, j'effectue mon action ... et je recommence ainsi de suite ...

Voici d'ailleur le code pour illustrer la chose
(il y a des appelles a des fonctions que j'ai réalisé, step est une variable globale qui est changée dans la fonction appellée si tout c'est bien passé)

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
 
__declspec(dllexport) int LAfonction(short stop, statMeasRead *cluster1, unsigned short paramLv[]){
 
  // Test fermeture du programme
  if(stop == 1){
    step = 3;
  }
 
  // Step = 0 -> Initialisation + connection.
  if(step == 0){
    connection();
  }
 
  // Step = 1 -> Recuperer tout les parametres.
  if(step == 1){
 
    sending(2, cpt, 0);
    receive(cluster1, paramLv);
 
    // Compteur de passage dans initialisation
    cpt++;
 
    // Initialisation terminee
    if(cpt == NBPARAM){
      memcpy((void *)paramOld, (const void*)paramLv, NBPARAM*sizeof(unsigned short));
      step = 2;
    }
  }
 
  //Step = 2 -> Envoyer et recevoir des données normalement.
  if(step == 2){
 
    // Boucle pour voir si le tableau des parametres a été modifié.
    for(cpt = 0; cpt < NBPARAM; cpt++){
      if(paramLv[cpt] != paramOld[cpt]){
        sending(3, cpt, paramLv[cpt]);
        receive(cluster1, paramLv);
        paramOld[cpt] = paramLv[cpt];
        break;
      }
    }
 
    // Status and Measures reading (TCS request)
    cptReqStat++;
    if(cptReqStat == 10000){
      sending(1,0,0);
      receive(cluster1, paramLv);
      cptReqStat = 0;
    }
  }
 
  //Step = 3 -> Deconnection.
  if(step == 3){
    disconnection();
    return 1;
  }         
}

et la partie plus précisement dont je vous parlais :

Code :

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

1
2
3
4
5
6
7
 
    cptReqStat++;
    if(cptReqStat == 10000){
      sending(1,0,0);
      receive(cluster1, paramLv);
      cptReqStat = 0;
    }

Maintenant cette solution n'est pas très précise ...

Comment pourrais je faire pour utiliser plutot un style de timer ? Histoire d'avori quelque chose de plus propre et de plus précis ?

Merci d'avance

**Médinoc** · 06/03/2008, 12h13

Pour une application graphique sous Windows, j'aurait utilisé un bète timer (SetTimer(), WM_TIMER). Mais j'ignore s'il existe un équivalent sous LabView...

En tout cas, je pense qu'il ne devrait pas y avoir besoin de multithread pour ça.

**nuFox** · 06/03/2008, 12h16

Bah la dll est independante de labview ...

Le code serait interne a la dll ...

LabView ne sert qu'a afficher ce que je recois

**Médinoc** · 06/03/2008, 12h23

Si tu peux ouvrir des fenêtres Win32 dans ta DLL (sachant que si j'ai bien compris, celle-ci n'a aucun contrôle sur la boucle de messages, et c'est LabView qui contrôle), alors tu peux utiliser un timer depuis la DLL elle-même.

**nuFox** · 06/03/2008, 12h25

Bah le probleme, c'est que ca doit etre portable sous linux ... Donc je sais pas si ouvrir des fenetres win32 c'est très portable ...

Enfaite c'est la dll qui fait tout ... (c''est une dll qui s'occuper d'envoyer et recevoir des messages par TCP/IP) ... LabView n'est la que pour recuperer les valeurs recues a la sortie de la dll pour les afficher

**Médinoc** · 06/03/2008, 12h38

Je ne connais rien de portable pour faire un truc toutes les X secondes sans bloquer complètement le thread courant.

Si bloquer le thread courant est acceptable, une simple boucle avec des appels à Sleep()/usleep() suffit...

**nuFox** · 06/03/2008, 12h41

Non justement ... Il faut que ca tourne sans cesse ... Pas de blocage ...

Donc enfait ... Il y a pas spécialement de methode a part la methode que j'ai utilisé ...

Donc rien de comparable a ce que j'ai fais et qui soit portable ... hé bin

**Médinoc** · 06/03/2008, 12h43

Ben oui, le C standard ne connait pas l'attente, ni le multi-thread, ni le fenêtrage (si fenêtrage il y a), etc. Le C standard est assez con, tu sais...

PS: Tu devrais donner un préfixe explicite à tes variables globales, si tu ne peux pas t'en passer...

**nuFox** · 06/03/2008, 13h05

Oui tu me l'avais deja dis ... Je n'ai pas encore appliqué la modification ...

Mais pour mon probleme ... On pourrait par exemple recup l'heure systeme la convertir en seconde, puis la tester a chaque passage dans la dll pour voir si une seconde est passée ?
Un truc dans le genre c'est pas possible ?

Histoire de jouer avec une variable temps et pas avec le nombre de fois que l'on passe dans la dll

Un truc dans le genre mais portable
http://www.montefiore.ulg.ac.be/serv...-proc2/timer.c

**Médinoc** · 06/03/2008, 13h45

Si tu fais une boucle d'attente active, ça ne résoudra pas le problème de "bloquer tout le thread".

Déjà, je ne connais pas assez labview pour savoir QUI contrôle le flot d'exécution. Pourrais-tu me faire un topo rapide pour me dire quand est appelée ta DLL, s'il y a un truc qui est fait en boucle, et auquel cas, où se trouve cette boucle ?

**souviron34** · 06/03/2008, 13h51

Envoyé par nuFox

Mais pour mon probleme ... On pourrait par exemple recup l'heure systeme la convertir en seconde, puis la tester a chaque passage dans la dll pour voir si une seconde est passée ?
Un truc dans le genre c'est pas possible ?

Si , sans problèmes, et de manière portable...

Par contre, ça ne garantira pas qu'il se soit passé 1 seconde exactement, mais plus ou moins... Tu auras une mesure du temps écoulé simplement...

**nuFox** · 06/03/2008, 13h58

Voici un screen shot de l'appli sous labView avec des explications :

mais comme je te l'ai dis ... LabView ne fait rien de spécial mise a part lancer la fonction que je t'ai copier dans mon premier post ... Et recuperer les valeurs qu'il a besoin pour les afficher ... Tout se passe dans la DLL ...

Enfait j'ai créée une fonction. Cette fonction labView va l'appeler tout le temps ... (cette fonction c'est celle dans le premier post) ...

C'est fonction fonction en étape

Etape 1 = connection avec le serveur
Etape 2 = initialisation du tableaux
Etape 3 = demande des status et mesure toute les secondes + mise a jour du tableau si une valeur change
Etape 4 = deconnection

Et donc dans l'étape 3 pour qu'il demande les tatus toute les secondes +/- j'ai fais comme ca :

Code :

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

1
2
3
4
5
6
7
 
    cptReqStat++;
    if(cptReqStat == 10000){
      sending(1,0,0);
      receive(cluster1, paramLv);
      cptReqStat = 0;
    }

Et donc maintenant je voudrais bien modifier la boucle pour que ca ne depande pas du temps d'excecution de la fonction, mais bien d'un temps réelle ...

J'espere que j'ai bien fais le ptit topo et que ca pourra t'aider a comprendre

**Médinoc** · 06/03/2008, 14h05

Ah, donc tu as la fonction qui est appelée en permanence, mais tu veux qu'une de ses actions NE soit exécutée QUE toutes les secondes (ou une fois par seconde)...

Dans ce cas, je pense que le coup de l'heure système est ce que tu peux faire de mieux en restant portable.

**nuFox** · 06/03/2008, 14h08

Oui c'est ca

...
Lol ...

On sait allez jusque la milliseconde ? Parce que bon ...; Comme je dois faire un traitement toute les secondes ... Et que je recup l'heure systeme ... ca va rester a la meme secondes pendant 100milliseconde ... Et donc ca va pas etre très utile ... :s

**souviron34** · 06/03/2008, 14h20

on sait récupérer à la microseconde... ça te suffit

**nuFox** · 06/03/2008, 14h32

Enfait... je suis bete la seconde ca me va ...
Lol

Voila ce que j'ai trouvé/écrit :

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
 
int recupTime(){
  time_t timer1;
  int secondes, minutes, heures;
  struct tm *newTime1;
 
 
  time(&timer1);
 
  newTime1 = localtime(&timer1);
 
  heures = newTime1->tm_hour*3600;
  minutes = newTime1->tm_min*60;
  secondes = (newTime1->tm_sec + heures + minutes);	
 
  return secondes;
}

ca vous semble correct ?

**souviron34** · 06/03/2008, 14h38

oui , sinon tu as aussi clock() pour aller plus loin ou des fonctions (voir les sources C ici) pour aller jusqu'à la micro-seconde...

**nuFox** · 06/03/2008, 14h41

Oui j'viens de voir la source dispo sur le site ... Ca a l'air plus puissant ...

Mais je viens d epenser a un truc ... Mon programme est censé tourné 24h/24 ... Donc il y a bien un moment ou ca va passer a minuit ... Et donc ca va niquer mes teste ...

23h59:59 et 00h00:00 ca sux pour etre comparé

**nuFox** · 06/03/2008, 15h18

Enfait non .. ca va ^^

Lol ...

Je sias je me parle tout seul ... Mais des fois ca aide a reflechir ^^

Executer une action toute les x secondes.

C

Discussions similaires

Partager

Partager