Discussion :

[kurul1]

Bonjour à tous

Je doit concevoir un logiciel chargé d'afficher une séquence de signaux à l'écran (Textes et sigles)

Mon souci est le suivant

Quand j'effectue un test de mon logiciel dans XE3 directement (Exécution), aucun souci d'affichage
Lorsque j'exécute le logiciel directement en lançant l'exécutable il y a des signaux qui n'apparaissent pas.

Est-ce que quelqu'un aurait une idée.

Mes signaux je les dessine sur le Canvas avec la fonction TextOut
La form est en double Buffer
Le temps d'affichage de mes signaux est déterminé par un Thread qui calcule le temps (QUERY_PERFORMENCE COUNTER) et qui renvoit un booléen à true au programme quand le temps impartit au Signal est terminé pour qu'il passe au suivant.
Je ne voulais pas utiliser un Timer car trop imprécis et je ne voulais pas non plus que le programme soit bloquant pendant un Signal pour pouvoir interrompre une séquence.

Merci d'avance pour votre aide

[totoche76]

Quand j'effectue un test de mon logiciel dans XE3 directement (Exécution), aucun souci d'affichage
Lorsque j'exécute le logiciel directement en lançant l'exécutable il y a des signaux qui n'apparaissent pas.

Quand tu lances l'exécutable directement, est-ce qu'il y a une différence de mode de compilation (DEBUG/RELEASE) ?
Exécution dans l'IDE en compilant en debug ou en release...
Exécution en dehors en compilant en debug ou en release...
(Comportement différent en debug et en release: présomption de variable non initialisée)

Est-ce que quelqu'un aurait une idée.

Mes signaux je les dessine sur le Canvas avec la fonction TextOut
La form est en double Buffer
Le temps d'affichage de mes signaux est déterminé par un Thread qui calcule le temps (QUERY_PERFORMENCE COUNTER) et qui renvoit un booléen à true au programme quand le temps impartit au Signal est terminé pour qu'il passe au suivant.

Comment se fait la comm entre ton thread de gestion des signaux et le thread principal de l'appli ? Comment le thread principal est-il prévenu qu'il doit mettre à jour l'affichage ?
Tu parles d'un booléen... C'est une variable ? Si c'est le cas est-ce que tu as fait gaffe à bien gérer les accès concurrents sur cette variable (section critique par exemple) ?

[kurul1]

Merci pour ta réponse totoche76

Alors après les différents tests que tu m'as conseillé
Exécution dans l'IDE identique entre Debug et Release cela fonctionne normalement
Exécution extérieure identique entre Debug et Release il y a certains signaux qui n'apparaissent pas.

Concernant la gestion du Thread

J'ai déclaré dans le Thread 2 variables

Code :

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

1
2
3
4
5
6
 
	// Booléen pour savoir si le Thread à terminé
	bool Termine;
 
	// Temps
	int Temps;

Le Constructeur de mon Thread a des paramètres

Code :

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

1
2
3
4
5
6
7
8
 
// Constructeur avec paramètres
__fastcall MonThread::MonThread(bool CreateSuspended, int Tps)
	: TThread(CreateSuspended), Temps(Tps)
{
	// On met le booléen pour marquer la fin du Thread à false
	Termine = false;
}

Voilà ce que je fait dans la fonction Execute du Thread

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
 
void __fastcall MonThread::Execute()
{
	static __int64 FrequenceHorloge;
	static __int64 Debut;
	static __int64 Fin;
 
	// On initialise le tempsCourant à 0
	double TempsCourant = 0;
 
	// booléen pour la sortie de boucle
	bool Sortie = false;
 
	// On calcule la fréquence de l'horloge
	QueryPerformanceFrequency((LARGE_INTEGER*)&FrequenceHorloge);
 
	// On calcule le temps de départ
	QueryPerformanceCounter((LARGE_INTEGER*)&Debut);
 
	do
	{
		Application->ProcessMessages();
 
		// On calcule la Fin
		QueryPerformanceCounter((LARGE_INTEGER*)&Fin);
 
		// On calcule le Temps Courant
		TempsCourant = (1000 * ((Fin - Debut) / (double)FrequenceHorloge));
 
		// Si l'on à atteint le Temps ou que l'on doit terminé le Thread
		if(Termine || (TempsCourant >= double(Temps)))
		{
			// On sort de la boucle
			Sortie = true;
		}
	}
	// Tant que l'on ne doit pas sortir de la boucle
	while(!Sortie);
 
	// On marque que l'on à terminé
	Termine = true;
}

Et donc voilà comment j'appelle et communique avec le Thread dans le programme principal

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
 
	// On lance le Thread
	Thread = new MonThread(false, Temps);
 
	// On marque qu'il faut nettoyé à la sortie du Thread
	Thread->FreeOnTerminate = true;
 
	// Tant que le Thread n'est pas terminé
	while(!Thread->Termine)
	{
		// Si l'on doit quitter l'application
                // La variable QuitterApplication est mise à true lorsque l'on tape echap au clavier (OnKeyPress)
		if(QuitterApplication)
		{
			// On termine le Thread
			Thread->Termine = true;
		}
 
		Application->ProcessMessages();
	}

L'affichage est géré dans le programme principal, il est fait avant l'appel du Thread et lorsque le Thread est terminé, on passe a l'affichage du Signal suivant

[totoche76]

Code :

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

1
2
3
4
5
6
void __fastcall MonThread::Execute()
{
....
 	do
	{
		Application->ProcessMessages();

Houlaaaaaa.....
Déjà, gros mélange des genres: Application->ProcessMessages() c'est pour gérer la boucle des messages associée au thread principal, donc quand tu es dans un autre thread, c'est "pas touche".

Comment est géré l'affichage dans le thread principal ?? Tu dessines directement sur le Canvas du form ??? Tu géres bien l’évènement OnPaint du form ??
Si le but du thread est juste de faire une tempo, un Sleep suffit.... Pas besoin de compteurs de performance pour ça.
EDIT-
(bon ok Sleep n'est pas très précis, admettons...)
Remplaces Application->ProcessMessages() par un Sleep(1) ou Sleep(10) (quelques ms de décalage pour ta affichage, ça devrait aller, non ?)
-EDIT
Et tes signaux ? tu as une liste de signaux à afficher, chacun avec un temps d'affichage associé, c'est ça ?? Cette liste évolue au cours de l'exécution de l'appli ?

[kurul1]

Pour le Process Message je l'enlève sans souci petite erreur

Sinon concernant l'affichage, oui je dessine directement sur le Canvas mais je n'utilise pas le OnPaint je le fait directement dans une fonction qui dessine sur l'écran, surement une autre erreur de ma part, je vais essayer de modifier mon programme pour voir si cela fonctionne mieux.

Concernant le Sleep que tu me propose, il est bloquant c'est à dire que tant qu'il n'est pas terminé les évènements clavier ne sont pas pris en compte et ce n'est pas ce qui m'intéresse et connaissant la précision des Timer, j'ai opté pour cette solution pour avoir un temps plus précis

Concernant les Signaux, c'est une liste qui est fixe pour un Protocole donné elle n'évolue pas pendant le cycle d'affichage.

Un Signal est en fait un texte à afficher avec un arrière-plan, une couleur, une taille et une police déterminée.

[totoche76]

Sinon concernant l'affichage, oui je dessine directement sur le Canvas mais je n'utilise pas le OnPaint je le fait directement dans une fonction qui dessine sur l'écran, surement une autre erreur de ma part, je vais essayer de modifier mon programme pour voir si cela fonctionne mieux.

Je suppose que si tu faisais passer une autre fenêtre par dessus ton appli, les choses que tu avais dessinées sur le Canvas avaient disparues quand la fenêtre de ton appli redevenait visible, non ?

Concernant le Sleep que tu me propose, il est bloquant c'est à dire que tant qu'il n'est pas terminé les évènements clavier ne sont pas pris en compte et ce n'est pas ce qui m'intéresse et connaissant la précision des Timer, j'ai opté pour cette solution pour avoir un temps plus précis

??? Ok, si tu fais un sleep dans le thread principal, celui-ci est bloqué le temps du sleep et c'est normal que rien ne soit pris en compte. Maintenant, c'est l'intérêt d'un thread secondaire: tu y fais un sleep, il n'a pas d'impact sur ce qui se passe dans le thread principal... Tes évènements clavier ne sont pas gênés (à moins d'une autre bourde dans le thread principal) par ton thread secondaire.