Sekunden in Millisekunden für Sleep umwandeln

[a.def]

Ich scheitere gerade wieder an einer eigentlich total einfachen Sache!
Ich habe ein Eingabefeld in welches man eine Zahl eingibt. z.B. 600 (Sekunden). Das wären dann 10 Minuten.
Zusätzlich habe ich 10 TImages und jedes davon kann 2 Zustände annehmen (2 verschiedene Grafiken).

Nun möchte ich in einem Thread eine Schleife ausführen lassen welche nach und nach von links nach rechts die Zustände der Bilder ändert, und das in 600 Sekunden.

Das mit dem Bilder-wechseln, dem Thread usw klappt alles aber ich bin wohl zu dumm diese 600 Sekunden in Millisekunden umzuwandeln, SODASS
ich eine eigene Schleife mit Sleep(1) verwenden kann statt Sleep(die-ausgerechnete-zeit).
Das soll den Vorteil haben, dass sich das Programm sofort beenden lässt und nicht erst in einer Sleep(1000) oder so festhängt.

Versteht ihr mein Problem?

Ich dachte eigentlich es ginge so:

Delphi-Quellcode:

   dTmp := StrToIntDef(Edit1.Text, 600); // Single
   iMaxImgLifetime := Round(dTmp * 100); // Integer
   iMaxImgLifetime := iMaxImgLifetime * 2; // *2 weil jedes der 10 Bilder 2 Zustände haben kann (Voll und Halb)

Meine Sleep-Schleife sieht echt mies aus (die wird in jedem Schleifendurchgang im Thread aufgerufen):

Delphi-Quellcode:

 procedure doSleep(iSleep: Integer);
  var
   i: Integer;
  begin
   i := 0;
   while i < iSleep do
    begin
     Inc(i);
     Sleep(1);
    end;
  end;

[Bernhard Geyer]

Threads und Aktionen auf einen Formular ist eine ganz schlechte Idee.
Die VCL (bzw. die dahinterliegenden Windows-Controls/Handles) sind dürfen nur im Erzeugenden Thread verwendet werden.
Das es gerade bei dir funktioniert ist Zufall.

Zu deiner eigentlichen Frage 1 Sekunde = 1000 Millisekunden. Siehe auch Vorsätze für Maßeinheiten

[a.def]

Zitat:

Zu deiner eigentlichen Frage 1 Sekunde = 1000 Millisekunden

Das weiß ich doch aber das ist gar nicht mein Problem :P

Zitat:

Threads und Aktionen auf einen Formular ist eine ganz schlechte Idee.

Dann benutze ich eben Synchronize :P

[Der schöne Günther]

Deine Annahme dass ein Sleep(1) auch wirklich eine Millisekunde wartet ist falsch. Schau mal in die Windows-Doku zu Sleep: https://msdn.microsoft.com/en-us/lib...(v=vs.85).aspx

Zitat:

The system clock "ticks" at a constant rate. If dwMilliseconds is less than the resolution of the system clock, the thread may sleep for less than the specified length of time. If dwMilliseconds is greater than one tick but less than two, the wait can be anywhere between one and two ticks, and so on.

Zitat:

Zitat von a.def (Beitrag 1363800)

Das soll den Vorteil haben, dass sich das Programm sofort beenden lässt und nicht erst in einer Sleep(1000) oder so festhängt.

Falls das deine Motivation ist dann ist Sleep nicht das richtige. Ich würde das mit WaitForSingleObject machen - Das ist im Endeffekt wie ein Sleep, aber wenn z.B. den Thread von außen terminieren möchte kann man es "abbrechen". Gibt im Forum bestimmt ein Beispiel. Wenn nicht, sag Bescheid.

[a.def]

Ok nochmal anders...

ich möchte statt Sleep(10000), welches den Thread für 10 Minuten blockieren würde, eine eigene Prozedur schreiben dir X-Mal Sleep(1) aufruft, sodass man am Ende auf circa 10000 kommt.
Und die Konvertierung von der Eingabe "600" (Sekunden) in Verbindung mit den 10 Bildern die jeweils 2 Zustände haben können schaffe ich nicht.

[t.roller]

Siehe hier:
http://www.delphipraxis.net/1362573-post17.html

[a.def]

Genau das ist es was ich gesucht habe nur ich war zu dumm dafür das selber zu machen. :thumb:

[Mavarik]

Wenn Du die einen TEvent erzeugst...

Wait := TEvent.create(NIL,true,true,'');

Du kannst bei einem Wait.WaitFor(TimeOut) angeben wie lange ein Thread warten soll..
Bei einem Keypress oder was auch immer du machst um Dein Programm zu beenden, brauchst Du nur ein Wait.SetEvent; Terminate; aufrufen und schon ist dein Thread beenden.

Mavarik

[a.def]

Bzgl dieses Codes hier:

Delphi-Quellcode:

procedure TForm1.ButtonClick(Sender: TObject);
var
AlarmTimer : THandle;
Zeit : Large_Integer;
start, ende : Cardinal;
begin
  Memo1.lines.add('SetWaitableTimer: 1 sec Running');
  start:= GetTickCount;
AlarmTimer := CreateWaitableTimer(nil, False, nil);
CancelWaitableTimer(AlarmTimer); // goto Start
Zeit.QuadPart := 1 * (-10000000); // 1 Sekunde
SetWaitableTimer(AlarmTimer, Zeit.Quadpart, 0, nil, nil, False);
while WaitForSingleObject(AlarmTimer, 20) <> Wait_Object_0 do // Beispiel: 20msec
begin Application.ProcessMessages; end;
  end1:= GetTickCount;
  Memo1.lines.add(INTTOSTR(end1-start)+' msec');
  Memo1.lines.add('WaitableTimer: Ready');
end;

Wie lasse ich den Sleep denn 500ms warten?
Verstehe den irgendwie nicht so richtig.

Der folgende wäre mir deutlich lieber aber auf meine boolsche Prüfung reagiert er gar nicht! Caption := 'X'; wird auch nie ausgeführt wenn das drin steht.

Delphi-Quellcode:

procedure TForm1.LongDelay(Milliseconds: Integer);
var
 Tick: DWord;
 Event: THandle;
begin
 Event := CreateEvent(nil, False, False, nil);

 try
  Tick := GetTickCount + DWord(Milliseconds);

  while (Milliseconds > 0) and (MsgWaitForMultipleObjects(1, Event, False, Milliseconds, QS_ALLINPUT) <> WAIT_TIMEOUT) do
   begin
    if not bTimerRunning then
     Exit;

    Milliseconds := Tick - GetTickCount;
   end;
 finally
  CloseHandle(Event);
 end;
end;

[Mavarik]

Zitat:

Zitat von a.def (Beitrag 1363824)

Der folgende wäre mir deutlich lieber aber auf meine boolsche Prüfung reagiert er gar nicht! Caption := 'X'; wird auch nie ausgeführt wenn das drin steht.

Delphi-Quellcode:

procedure TForm1.LongDelay(Milliseconds: Integer);
var
 Tick: DWord;
 Event: THandle;
begin
 Event := CreateEvent(nil, False, False, nil);

 try
  Tick := GetTickCount + DWord(Milliseconds);

  while (Milliseconds > 0) and (MsgWaitForMultipleObjects(1, Event, False, Milliseconds, QS_ALLINPUT) <> WAIT_TIMEOUT) do
   begin
    if not bTimerRunning then
     Exit;

    Milliseconds := Tick - GetTickCount;
   end;
 finally
  CloseHandle(Event);
 end;
end;

Caption := 'X'; ?? wo?

Du musst das ganz natürlich in einem Thread machen...

[a.def]

Hab jetzt eine andere Lösung gefunden. Die funktioniert.

[Mavarik]

Zitat:

Zitat von a.def (Beitrag 1363829)

Hab jetzt eine andere Lösung gefunden. Die funktioniert.

Dann zeig doch mal!

[t.roller]

Zitat:

Zitat von a.def (Beitrag 1363824)

Wie lasse ich den Sleep denn 500ms warten?

Delphi-Quellcode:

Zeit.QuadPart := 1 * (-10000000); // 1 Sekunde
Zeit.QuadPart := 1 * (-1000000); // 100 msec
Zeit.QuadPart := 1 * (-100000); // 10 msec
Zeit.QuadPart := 1 * (-10000); // 1 msec

[himitsu]

Nur mal zur Info: Es gibt ein paar Konstanten zur Zeitkonvertierung.

Zitat:

Delphi-Quellcode:

  HoursPerDay   = 24;
  MinsPerHour   = 60;
  SecsPerMin    = 60;
  MSecsPerSec   = 1000;
  MinsPerDay    = HoursPerDay * MinsPerHour;
  SecsPerDay    = MinsPerDay * SecsPerMin;
  SecsPerHour   = SecsPerMin * MinsPerHour;
  MSecsPerDay   = SecsPerDay * MSecsPerSec;

SysUtils


Laut Definition will SetWaitableTimer direkt den LARGE_INTEGER und keinen "QuadPart".

[a.def]

Ich mache das jetzt so

Delphi-Quellcode:

procedure TForm1.LongDelay(Milliseconds: Cardinal);
var
 FirstTickCount: DWord;
begin
 FirstTickCount := GetTickCount;

 while ((GetTickCount - FirstTickCount) < Milliseconds) do
  begin
   if not ThreadRunning then // nur ein Beispiel! (das hier steht hier nur, damit bei Programmende nicht unnötig hier gewartet wird)
    Exit;

   Application.ProcessMessages;
   Sleep(0);
  end;
end;

// Eingabe Nutzer: 600
var
 dTmp: Single;
 iMaxImgLifetime: Integer;
begin
 dTmp := (StrToIntDef(sSecondsInput, 600) / 20); // 20 = Anzahl Bilder
 iMaxImgLifetime := Round(dTmp * 1000); // Lebenszeit eines Bildes, bevor es versteckt wird

 // Thread
 while ... do
  begin
   LongDelay(iMaxImgLifetime);

   // Arbeite ...
  end;

[himitsu]

Nur keine Ahnung, warum jemand sich so viele Umstände macht anstatt das ganze Problem mit 2 Zeilen Code und einem TTimer zu lösen. :roll:

[a.def]

Weil ein Timer hier die GUI minimal blockieren würde. Statt einen Timer läuft es bei mir in einem TTask, ist doch kein Problem?

[himitsu]

Nein, es läuft nicht alles im Thread und wenn doch, dann hast du da einen schweren Designfehler im Programm, denn auf die VCL greift man ausschließlich vom Haupthtread drauf zu.
Der Task/Thread macht doch scheinbar nichts anderes, als sinnlos zu warten und dann das Bild zu änder.

Das Einzige, was hier "eigentlich" gemacht wird, ist alle x Sekunden in der GUI ein Bild zu ändern.
Das Ändern dauert immer gleich lang, egal ob es direkt im VCL-Thread von einem Timer ausgeführt wird
oder ob man es aus einem Thread synchronisiert im VCL-Thread macht.

[a.def]

Habs jetzt in einen Timer gepackt. Kein TTask mehr, kein Synchronize mehr, kein LongDelay mehr :stupid:
Das Interval ist die Zeit die vorher meine Sleep-Dauer war.
Im Timer ist bei jedem Durchgang ein ProcessMessages.

[stahli]

Das ist gut so, wie auch himitsu empfohlen hat.

Aber das ProcessMessages ist sicherlich überflüssig.
Erstens wird es keinen positiven Effekt haben und zweitens kann es durchaus Probleme machen.

Was willst Du damit erreichen?

[a.def]

Ohne dieses ProcessMessages sehe ich die das neu positionierte Bild noch immer an der alten Stelle.

[t.roller]

Zitat:

Zitat von himitsu (Beitrag 1363843)

Laut Definition will SetWaitableTimer direkt den LARGE_INTEGER und keinen "QuadPart".

Zeit.QuadPart ist INT64.
Largeint ist ein 8 Byte großer Integerwert mit Vorzeichen.
Ist also das Gleiche!

WINDOWS.PAS:
LARGE_INTEGER = record
case Integer of
0: (
LowPart: DWORD;
HighPart: Longint);
1: (
QuadPart: LONGLONG);
end;
TLargeInteger = Int64;

Zitat:
Remarks

The LARGE_INTEGER structure is actually a union. If your compiler has built-in support for 64-bit integers, use the QuadPart member to store the 64-bit integer. Otherwise, use the LowPart and HighPart members to store the 64-bit integer.

[Luckie]

Zitat:

Zitat von a.def (Beitrag 1363898)

Ohne dieses ProcessMessages sehe ich die das neu positionierte Bild noch immer an der alten Stelle.

Dann wäre wohl ein Refresh oder ähnliches angebracht.

[stahli]

@a.def

Die Positionsberechnung führst Du sicher in einem anderen Ereignis durch - oder?
Dann ruf Deine Positionsberechnung einfach noch mit in der Timer-Behandlung auf. Dann sollte das eigentlich funktionieren.

Mit Application.Processmessages schiebst Du im Grunde auch nur eine zusätzliche Ereignisbehandlung in die Timerbehandlung hinein.
Das kann aber Probleme machen - siehe hier: http://www.delphipraxis.net/190294-p...alsection.html

Kannst Du sonst mal ein Demoprojekt anhängen? Das sollte eigentlich ohne ProcessMessages funktionieren.

[himitsu]

Das Timer-Event ist eine Message und direkt danach werden alle weiteren Messages verarbeitet, es bringt also eigentlich garnichts, wenn man das vorher selber die Messages verarbeiten will, abgesehn von den genannten Problemen mit den rekursiven Aufrufen.

[Mavarik]

Zitat:

Zitat von a.def (Beitrag 1363898)

Ohne dieses ProcessMessages sehe ich die das neu positionierte Bild noch immer an der alten Stelle.

Dann stimmt immer noch etwas nicht...

Der Timer wird in der UI-Thread ausgeführt und wenn die Timerroutine durchgelaufen ist, geht es in der 0-Task(UI) weiter also müssen alle Änderungen angezeigt werden...

Mavarik

[a.def]

Zitat:

Dann stimmt immer noch etwas nicht...

Habe das durch ein Form1.Update; ersetzt.

[Mavarik]

Zitat:

Zitat von a.def (Beitrag 1363921)

Zitat:

Dann stimmt immer noch etwas nicht...

Habe das durch ein Form1.Update; ersetzt.

"Darf" eigentlich auch nicht nötig sein... Es sei den Du belastet den UI-Thread mit anderen dingen, die Du uns nicht erzählt hast.

[a.def]

Es gibt nur diesen einen Timer.
Alle 5 Sekunden verschiebt der ein Bild minimal und setzt es 50 Millisekunden später wieder an die ursprüngliche Stelle zurück.

[himitsu]

Somit hast du doch nicht alles verraten!

Also sieht es jetzt so aus, im OnTimerEvent?

Zitat:

verschiebe
warte 50ms
verschiebe

Die VCL ist natürlich schlau und malt sich absichtlich nicht sofort neu, sondern schickt beim Verschieben sich nur eine Refresh-Message
womit die Komponente nach dem Timer-Event (WM_TIMER Message) sich erst neu malt und dann natürlich nur an der zweiten Position. :stupid:

[a.def]

Ich dachte weil das in einem Thread auch ohne Refresh, Update usw funktioniert hat, hat das im Timer keine Bedeutung es zu erwähnen :P

[himitsu]

Wobei auch nie gezeigt wurde wie das im Thread aussah.
Und ich fast immernoch die Befürchtung hab, dass da eventell keine Synchronisierung drin war, bzw. mehrere Synchronisierungen, welche natürlich ein ganz anderes Verhalten zeigen, als ein Timer.