Zeitabhängige Ereignisse auslösen

[markon]

hallo.
brauch mal ne anregung zum programmieren.

muss einen fahrplan programmieren, der zu bestimmten zeitpunkten bestimmte ereignisse auslöst.
werde um einen oder mehrere timer nicht drumrum kommen..
hat jemand schon mal sowas programmiert?!
wenn ja, wie kann man das angehen, mit welchen komponenten?!

gruß
marcus

[Christian Seehase]

Moin Marcus,

Du könntest dafür einfach TTimer verwenden, oder Du erzeugst einen Thread, in dem Du mit Hilfe eines Dummy Events (CreateEvent in Regelmässigen Abständen nachschaust, ob der gewünschte Zeitpunkt eingetreten ist.

[Rumpi]

Hi,

vieleicht hilft dir ja das weiter

mit
MyTimerThread := TTimerThread.Create( OneSecProc ); wird alle sec die OneSecProc gerufen

mit
MyTimerThread := TTimerThread.Create( XXXX, Proc ); wird alle XXXX ms die Proc gerufen

mit
MyTimerThread.Enabled := False; kannst du ihn auch mal anhalten.

mit
MyTimerThread.Stop; beseitigt sich der "Timer-Thread" von allein

Delphi-Quellcode:

unit cl_Thread;

interface
  uses Windows, Classes, syncobjs, Sysutils;

type

  TTimerThread = class(TThread)
  private
    { Private-Deklarationen }
    FEnabled     : Boolean;
    FOneSec      : Boolean;
    FOnNotify    : TNotifyEvent;
    FInterval    : Longint;
    FTag         : Longint;
    FCloseEvent  : TSimpleEvent;
    FEnableEvent : TSimpleEvent;
    FLastSec     : Word;
  public
    constructor Create( OnNotify: TNotifyEvent ); overload;
    constructor Create( aInterval: Longint; OnNotify: TNotifyEvent ); overload;
    destructor  Destroy; override;
    procedure   Stop;
  protected
    procedure Execute; override;
    procedure Notify;
    procedure SetEnabled( Value: Boolean );
    procedure SetInterval( Value: Longint );
  published
    property Interval: Longint read FInterval write SetInterval;
    property Enabled : Boolean read FEnabled write SetEnabled;
    property Tag     : Longint read FTag write FTag;
  end;

implementation

constructor TTimerThread.Create( OnNotify: TNotifyEvent );
begin
  inherited Create( True );
  FreeOnTerminate := True;
  FOnNotify     := OnNotify;
  FInterval     := 50;
  FCloseEvent   := TSimpleEvent.Create;
  FEnableEvent  := TSimpleEvent.Create;
  FEnabled      := True;
  FOneSec       := True;
  Resume;
end;

constructor TTimerThread.Create( aInterval: Longint; OnNotify: TNotifyEvent );
begin
  inherited Create( True );
  FreeOnTerminate := True;
  FOnNotify   := OnNotify;
  FInterval   := aInterval;
  FCloseEvent := TSimpleEvent.Create;
  FEnableEvent:= TSimpleEvent.Create;
  FEnabled    := False;
  FOneSec     := False;
  Resume;
end;

destructor TTimerThread.Destroy;
begin
  FCloseEvent.Free;
  Inherited Destroy;
end;

procedure TTimerThread.Execute;
var
  Signaled    : Integer;
  h, m, s, ms : Word;
  EventHandles: array[0..1] of THandle;
begin
  EventHandles[0] := FCloseEvent.Handle;
  EventHandles[1] := FEnableEvent.Handle;
  repeat
    Signaled := WaitForMultipleObjects( 2, @EventHandles, False, FInterval );
    case Signaled of

      // Close event, terminate the thread
      WAIT_OBJECT_0 :
        begin
          ResetEvent(FCloseEvent.Handle);
          Break;
        end;

      WAIT_OBJECT_0 + 1:
        begin
          ResetEvent(FEnableEvent.Handle);
          FEnabled := True;
        end;

      // Timer Event
      WAIT_TIMEOUT  :
        if Not FOneSec then
          Synchronize(Notify)
        else
        begin
          // Has a second passed ?
          DecodeTime( Now, h, m, s, ms );
          if s <> FLastSec then
          begin
            Synchronize(Notify);
            FLastSec := s;
          end;
        end;

    end;
  until Terminated;
end;

procedure TTimerThread.Notify;
begin
  if Assigned( FOnNotify ) and FEnabled then
    FOnNotify( Self );
end;

procedure TTimerThread.Stop;
begin
  FEnabled := False;
  SetEvent(FCloseEvent.Handle);
end;

procedure TTimerThread.SetEnabled( Value: Boolean );
begin
  if FEnabled <> Value then
    if Value then
      SetEvent(FEnableEvent.Handle)
    else
      FEnabled := False;
end;

procedure TTimerThread.SetInterval( Value: Longint );
begin
  if FEnabled then
  begin
    FEnabled  := False;
    FInterval := Value;
    SetEvent(FEnableEvent.Handle);
  end
  else
    FInterval := Value;
end;


end.

mfg Rumpi

[markon]

wow

die thread-programmierung ist ja auf den ersten blick voll "übel".

werde ma kucken..

[Rumpi]

Wie meinst du das mit voll übel?

Ich hatte zum Anfang auch meine Probleme damit
und bin auf einen Timer gegangen.

Aber dann habe ich mir die Mühe gemacht...

Ich habe mir auch einen TPrecDelay Thread
geschrieben mit dem man Delays (Sleeps)
im µs realisieren kann siehe
-QueryPerformanceFrequency
-QueryPerformanceCounter

diese Funktionen greifen auf den PIT Timer zu.
(mit asm geht das auch unter Delphi 1 !! )

Suche mal im Forum,
da habe ich auch schon mal was gesehen zu QeryPerformance.


mfg Rumpi

[Rumpi]

Update TTimerThread !

Delphi-Quellcode:

destructor TTimerThread.Destroy; 
begin 
  FCloseEvent.Free; 
  FEnableEvent.Free; // ups hatte ich vergessen 
  Inherited Destroy; 
end;

mfg Rumpi