Event bei Minutenwechsel der Windows-Uhr?

[Rollo62]

Zitat:

Zitat von TomyN (Beitrag 1514054)

Oder Thread mit Timer :-)

Gefühlsmässig halte ich Sleep für sehr unpräzise, kann es aber nicht begründen.

Der Timer ist aber auch "unpräzise", eine Thread Lösung hätte da meiner Meinung nach mehr Möglichkeiten.

Jednfalls sehe ich für meine Projekte die Präzision sowieso nicht als kritisch an, in 90% aller Fälle reicht eine sehr moderate Präzision (1-2 Sek) aus, manchmal kann eine leichte Prozessänderung die Präzisionsanforderung dahingehend reduzieren.
Hohe Zeitpräzision ist meistens eine Illusion :-)

Wann braucht man wirklich Präzision im 10ms Bereich, im genannten Fall jedenfalls nicht ?
Trotzdem wäre es gut mal eine stabile Lösung für echte ms/us Präzision in der Werkzeugkiste zu haben ( also quasi Echtzeitanforderungen ).
In der Praxis macht einem da aber sowieso schon das Betriebssystem einen Strich durch de Rechnung, was wohl mal locker sporadische Aussetzer im Sekundenbereich oder mehr haben kann, auch wenn es ansonsten im System-Tick bei ca. 10ms einigermaßen stabil ist.

@KodeZwerg
Ja Timer sind OK für mich in 90% der Fälle, ich habe nur immer ein schlechtes Bauchgefühl noch aus den Zeiten als es mal begrenzte Anzahl an System-Timern gab.
Ich glaube aber die Realität heute ist, dass es kein Problem sein sollte mal hier und da einen Timer einzusetzen,
trotzdem gehe ich noch immer sehr sparsam damit um.

[Michael II]

Zitat:

Zitat von Rollo62 (Beitrag 1514057)

In der Praxis macht einem da aber sowieso schon das Betriebssystem einen Strich durch de Rechnung, was wohl mal locker sporadische Aussetzer im Sekundenbereich oder mehr haben kann,

...wäre zum Beispiel bei einem "MIDI Sequencer" nicht gut. Was du suchst sind Multimedia Timer.

Die Zeit darfst du dann auch nicht über now/GetSystemTime abgreifen, da dieser Wert nur alle paar ms aktualisiert wird (auf vielen Systemen nicht mal in regelmässigen Abständen).

Wenn du auf 100ns genau die Systemzeit abgreifen willst, geht das über GetSystemTimePreciseAsFileTime; für eine Auflösung im ms Bereich also so:

Delphi-Quellcode:

    procedure GetSystemTimeFT( var st : TSystemTime );
    var tf : TFileTime;
    begin
      GetSystemTimePreciseAsFileTime ( tf );
      FileTimeToSystemTime( tf, st );
    end;

Oder... ...selber schreiben (PerformanceCounter, Atomzeitserver).

Aber für die gestellte Aufgabe ist das alles viel zu viel.

[venice2]

Ich verwende für sowas SetWaitableTimer in Verbindung mit Thread und WaitForSingleObject.
Aber man kann es auch übertreiben.

Delphi-Quellcode:

function MySetWaitableTimer(hTimer: THandle;
                            var lpDueTime: TLargeInteger;
                            lPeriod: longint;
                            pfnCompletionRoutine: TFNTimerAPCRoutine;
                            lpArgToCompletionRoutine: Pointer;
                            fResume: BOOL): BOOL;
                            stdcall; external 'kernel32.dll' name 'SetWaitableTimer';

Kleiner Ausschnitt..

Delphi-Quellcode:

constructor TVisDataThread.Create(var DataReadyMsg: HWND; var MemPointer: Pointer);
begin

  inherited Create(True);

  FDriveThreadId := 0;

  FShareMemPointer := GetBufferAddress;
  MemPointer := FShareMemPointer;
  FVisTimer := CreateWaitableTimer(nil, False, nil);
  if FVisTimer <> 0 then
  begin
    DataReadyMsg := FDataReadyMsg;
    FDelayMS := 0;
    FModuledelayMs := 0;
    FDelayMSChanged := False;
    FThreadReady := True;
  end;

end;

Delphi-Quellcode:

procedure TVisDataThread.Execute;
const
  _SECOND = 10000000;
var
  qwDueTime: Int64;
  liDueTime: _LARGE_INTEGER;
  ErrMsg: string;
begin

  if FVisTimer = 0 then
    Exit;

  // Create a negative 64-bit integer that will be used to
  // signal the timer 1/4 seconds from now.
  qwDueTime := -1 * (_SECOND div 4);

  // Copy the relative time into a LARGE_INTEGER.
  liDueTime.LowPart := DWORD(qwDueTime and $FFFFFFFF);
  liDueTime.HighPart := longint(qwDueTime shr 32);
  if MySetWaitableTimer(FVisTimer,                 // handle to a timer object
                        TLargeInteger(liDueTime), // when timer will become signaled
                        FDelayMS,                 // periodic timer interval
                        nil,                      // pointer to the completion routine
                        nil,                      // data passed to the completion routine
                        False {flag for resume state}) then
    // Following sentences are repeated every FDelayMS interval all the time from initial
    // start up to program end.
    repeat
      // We need to re-adjust timer interval according to the parameter "DelayMS" of vis plug-in.
      // (in case we exchange vis plug-ins)
      if FDelayMSChanged then
      begin
        FDelayMSChanged := False;
        CancelWaitableTimer(FVisTimer);
        MySetWaitableTimer(FVisTimer, TLargeInteger(liDueTime), FDelayMS, nil,
          nil, False);
      end;

      if WaitForSingleObject(FVisTimer, 1000 {1sec}) = WAIT_OBJECT_0 then
      begin
        DoOnVisTimer;
      end else
        Terminate;

      SuspendIfHalted;
    until Terminated
  else
  begin
    ErrMsg := SysErrorMessage(GetLastError);
    ShowErrorMsgBox(ErrMsg);
    Terminate;
  end;
end;

[himitsu]

Zitat:

nicht gut.

Hängen kann es so oder so, da hilft auch kein anderer Timer,
auch wenn Dieser um einige Millisekunden genauer arbeiten dürfte.


Hier ging es um etwas im Sekundenbereich, für menschliche Maßstäbe, wo es (meistens) garnicht so genau sein muß.
Wenn ein Rechner total augelastet/überlastet sein sollte, dann wäe es mir auch egal (hätte Verständnis dafür), wenn es hier mal 'ne Sekunde/Minute hängt.


Ja, die Frage war "gibt es schon was Fertiges?".

Antwort: nein (OK, jain)

* TimerEvent-Komponente dafür besorgen (oder bauen lassen)
* Timer öfters/regelmäßig triggern und Prüfen ob Minute voll
* Timer auf nachfolgende Minute einstellen
* Thread
* oder 200 Milliarden andere Lösungen


PS: er wollte es einfacher haben,
da ist es eh kontraproduktiv, wenn ihr es noch komplizierter macht. :zwinker:

ein TTimer mit Interval von 1000 (oder weniger, z.B. 500, 250 oder 100)

Delphi-Quellcode:

procedure TForm1.Timer1Timer(Sender: TObject);
begin
  //Label1.Caption := FormatDateTime('hh:mm:ss .zzz', Now);
  if Now < FNextEvent then
    Exit;
  FNextEvent := Trunc(Now * MinsPerDay + 1) / MinsPerDay;

  // mach irgendwas wenn die neue Minute beginnt
  Caption := TimeToStr(Now);
  Beep;
end;

Oder hab ich's übersehen und es gibt doch irgendwo ein RoundToMinute (Trunc) ?

oder

Delphi-Quellcode:

  FNextEvent := IncMinute(Now, 1);
  FNextEvent.SetSecond(0);
  FNextEvent.SetMilliSecond(0);

oder

Delphi-Quellcode:

  FNextEvent := IncMinute(RecodeDateTime(Now, RecodeLeaveFieldAsIs, RecodeLeaveFieldAsIs,
    RecodeLeaveFieldAsIs, RecodeLeaveFieldAsIs, RecodeLeaveFieldAsIs, 0, 0), 1);

oder
...

[Neumann]

Wenns nicht allzu genau sein muss, hier eine sehr simple Lösung:

Globale Variable Oldtime:tdatetime
In Onidle:

Delphi-Quellcode:

if now >= Oldtime+1/(24*60*60) then // 1 Sekunde
begin
  Oldtime:=now;
  dosomthing;
end;

Oldtime noch irgendwo initialisieren bei Programmstart

[Michael II]

Zitat:

Zitat von himitsu (Beitrag 1514087)

Zitat:

nicht gut.

Hängen kann es so oder so, da hilft auch kein anderer Timer,
auch wenn Dieser um einige Millisekunden genauer arbeiten dürfte.

Das MIDI Beispiel stammt nicht von mir sondern von m$.
Multimediatimer arbeiten nicht via Warteschlange sondern via Callbackfunktion. Das ist definitiv präziser. Da gibt's also schon einen Unterschied zwischen Timer und MMTimer.

Meine Meldung bezog sich auf Rollo62s Frage und nicht auf 1.

Dein Vorschlag einfach noch mehr Timer Events auszulösen um dann zu prüfen, ob eine Zeit erreicht ist bringt ausser Arbeit und noch mehr Stau in der Warteschlange nix.

Für die ursprüngliche Fragestellung sind die vorgeschlagenen WaitableTimers doch absolut topp: Du stellst eine Zeit ein und wirst benachrichtigt.

Die Idee von Neumann mit OnIdle ist nicht gut. Da wird u.U. von einer Minute zur nächsten millionenfach nachgefragt, ob wir bereits wieder grün leuchten sollen. OnIdle solltest du gar nicht nutzen... ausser vielleicht für handgestrickte Videogames (Ausgabe von Bildern unter Volllast) oder wenn du mit Threads nix am Hut hast und gewisse Aufgaben dann erledigen lassen willst, wenn grad sonst nix läuft.

Ich bin dann mal weg.

[himitsu]

Zitat:

Zitat von Michael II (Beitrag 1514116)

Zitat:

Zitat von himitsu (Beitrag 1514087)

Zitat:

nicht gut.

Hängen kann es so oder so, da hilft auch kein anderer Timer,
auch wenn Dieser um einige Millisekunden genauer arbeiten dürfte.

Das ist egal.
Da er etwas in der GUI machen will, muß er zwangsläufig Synchronisieren.

Ja, wenn man ausschließlich im Hintergrund (Thread) arbeitet, da ist der Hauptthread egal,
aber einem ContextSwitch entkommst du (normalerweise) dennoch nicht so leicht.