Ancienne fonction TP7 en Delphi

Version imprimable

19/03/2008, 15h33
mpetri

Ancienne fonction TP7 en Delphi
Bonjour.

J'éspère être clair, pardon si la description de mon problème est confuse, et si les questions qui suivent sont idiotes, mais je ne suis pas informaticien mais enseignant en physique.

Je voulais utiliser la fonction "delay" de TP7 qui se trouvait dans l'unité "Crt", mais il semble que DELPHI 6 ne connaisse pas cette unité.

Quelqu'un saurait-il s'il existe une fonction analogue à "delay" en DELPHI 6 ?
Si oui dans quelle unité se trouve-t-elle ?
Si non, est-il possible de récupérer une unité "Crt" contenant delay et de l'utiliser en DELPHI 6 ?
Enfin où pourrais-je retrouver cette unité (je ne la trouve pas dans mon bon vieux TP7) ?

J'ai essayé de remplacer cette fonction par une boucle "for" mais l'instruction précédant la boucle n'était exécutée qu'après la boucle! Voici le code : (i est un entier, j et jc des Longint, et j'ai placé deux edit dans la fiche)
Code:

1 2 3 4 5 6 7 8 9 10 i:=34; edit1.text:=inttostr(i); for j:=1 to 100000000 do begin jc:=j-1; end; i:=35; edit2.text:=intostr(i);
A l'éxécution de ce code la valeur 34 est affichée après un certains temps, c'est à dire après l'éxécution de la boucle. Pour le vérifier j'ai remplacé edit2 par edit1, et seule la valeur 35 s'affichait (34 étant immédiatement remplacée).

Quelqu'un pourrait-il m'expliquer ce qui se passe dans ce code pour que les instructions ne soient pas éffectuées dans l'ordre ?

Merci pour toute réponse.
19/03/2008, 23h31
Nono40

Bonjour,

Non, ton instruction est bien exécutée avant ta boucle. Par contre ta fiche n'est pas mise à jour tant que ta procédure n'est pas terminée. Ajoute un edit1.Refresh pour forcer la mise à jour et tu veras qu'il est bien modifié. ;)

Sinon, non Delay n'existe plus. Tu peux le remplacer par un test sur la date (pour les temps de plusieurs secondes), mais dans tous les cas ce n'est pas "propre" de l'utiliser. Il vaut cent fois mieux utiliser un TTimer dans ce cas.
20/03/2008, 04h46
smk01

Bonjour

Code:

sleep(x);//x en millisecondes

ne peut pas faire l'affaire ?
Delay(x) c'est pour attendre X millisecondes non ?
20/03/2008, 07h54
Paul TOTH
bonjour

en effet sleep() a le même effet que delay() mais le problème c'est que sur TP7 disponible ici.

le problème c'est que ce n'est pas très compatible avec le fonctionnement des applications Windows.

Sous DOS ou sous Delphi en mode console (voir {$APPTYPE CONSOLE} on a un écran en mode texte (voir en mode graphique sous TP7) qui est statique, un delay n'a pas de conséquence sur celui ci.

Sous Windows (sauf en mode console) l'application est responsable de son affichage en permanence, en effet Windows peut demander à n'importe quel moment à une application de s'afficher (fenêtre qui passe en avant plan par exemple), or si le thread principal de l'application est bloqué dans un Sleep(), aucun message ne sera traité.

Un solution simple pour débloquer une telle situation et d'invoquer Application.Processmessages à l'intérieur d'une boucle de temporisation...exemple :
Code:

1 2 3 4 5 6 7 8 9 10 procedure TForm1.Delay(ms:cardinal); var t:cardinal; begin t:=GetTickCount+ms; while t<GetTickCount do begin Application.ProcessMessages; end; end;
mais le problème est qu'alors l'interface graphique répond aux messages justement, on peut donc modifier un TEdit, cliquer sur un bouton, etc...

Si on peut désactiver l'interface (Form1.Enabled:=False), tout cela relève du bidouillage tout de même :)

et comme je ne sais pas pourquoi tu veux suspendre l'execution de ton programme pour un temps donné, j'aurais du mal à te donner une solution plus adaptée.
20/03/2008, 15h44
mpetri

Merci

Merci de vos réponses.

Je vais essayer vos propositions.

Pour répondre à Paul TOTH, je veux faire une simulation de régulateur PID avec tracé des réponses du système au cours du temps. Mais je voudrait que la courbe se construise au fur et à mesure, et ne soit pas affichée d'un bloc, afin de simuler ce qu'on observerait avec un dispositif réel. J'ai donc besoins de temporiser le calcul, pour qu'il ne soit pas trop rapide à l'exécution.

Pour répondre à Nono40, le TTimer c'est bien joli, mais je ne comprend rien au fonctionnement de ce truc, et l'aide DELPHI est pour le moins absconse pour un non informaticien comme moi. Je me débrouille en calcul numérique, mais l'informatique pure est un peu au dessus de mes moyens intellectuels.

Encore merci.

la logique voudrais que tu crées un Thread de ce type :

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
 
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;
 
type
// déclaration d'un objet THREAD
  TMonThread=class(TThread)
   Value:integer;
   procedure Execute; override;
  end;
 
// il nous faut une fiche avec un memo
  TForm1 = class(TForm)
// ceci est créé automatiquement dans l'IDE
// 1) placer le memo
    Memo1: TMemo;
// 2) cliquer 2 fois sur l'événement OnCreate de Form1
    procedure FormCreate(Sender: TObject);
// 3) cliquer 2 fois sur l'événement OnDestroy de Form1
    procedure FormDestroy(Sender: TObject);
  private
    { Private declarations }
// la déclaration à la main
    Thread:TMonThread;
    procedure NouvelleValeur;
  public
    { Public declarations }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
// comment se comporte le Thread ?
procedure TMonThread.Execute;
begin
// choix d'une valeur
 Value:=123;
// l'afficher dans la fiche (ce qui nécessite une synchronisation des threads)
 Synchronize(Form1.NouvelleValeur);
// attente façon Delay()
 Sleep(2000);
// nouvelle valeur
 Value:=456;
// etc...
 Synchronize(Form1.NouvelleValeur);
 Sleep(2000);
 Value:=789;
 Synchronize(Form1.NouvelleValeur);
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
// lorsque la fiche est crée, on crée en même temps le Thread
 Thread:=TMonThread.Create(False);
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
// quand la fiche se termine, on termine le thread
 Thread.Free;
end;
 
procedure TForm1.NouvelleValeur;
begin
// cette méthode est appelée périodiquement par le thread
// on se contente d'ajouter la valeur dans le memo, on pourrait
// tout aussi bien enregistrer la valeur dans un tableau et invoquer "Invalidate"
// pour que la fiche se redessine et sur le OnPaint, on dessine un graphe
 Memo1.Lines.Add(IntToStr(Thread.Value));
end;
 
end.

avec cette méthode, le thread peut être figé pendant 2s sans problème, le reste de l'application fonctionne comme si de rien n'était.