Timer-ting

Du skal ganske rigtigt brugen TTimer fra Delphis komponent liste. Du skal så i koden til dit OnTimer event checkke for om klokken nu er det den skal være for at udløse en bestemt handling ... Hvis dne er det så kald en procedure der exekverer dit event

Jens B

Eller du kan sætte ttimerns interval til at være det stykke tid der er indtil næste gang du vil udføre noget - og så udføre det i onTimer, hvor klokken faktisk er det rigtige..

Regner du rigtigt (forskellen mellem nu og hvornår du vil have din kode udført) er ttimere præcise ned til ca. 50 ms. Det kan svinge lidt.. Men det burde være okay til de fleste ting :o)

Hvis det bare er for at tjekke noget op imod klokken skulle et sekunds intervaller være ok ...

Du kan prøve det her ...

procedure TForm1.Timer1Timer(Sender: TObject);
var
  h,m,s,hund : Word;
begin
  DeCodeTime(Now,h,m,s,hund);
  if (h = 9) and (m = 37) and (s=0) then
    ShowMessage('Klokken er 9:37');
end;

Damn, i er hurtige :)

Borrisholt, tager det ikke megen CPU-kraft hele tiden at tjecke på hvad klokken er ? Eller misforstår jeg dig..

lrj, er det ok at lave en masse timere som alarmer, eller er der en "pænere" måde.

Afhænight af hvor nøjagtigt du skal bruge dine alarmer kan du bare sætte intervallet ned til et minut ellers har jeg en timer der er implemteret i en tråd, den bruger ingen CPU kraft, så kan jeg bare den dig den ...

Jens B

Borrisholt, det er fordi jeg er ved at lave et transportprogram, der skal lave en alarm, når der skal hentes bands (jazzmusikere). Hvis du vil sende implementationen af din tråd ville det være perfekt. Thomas@ding.dk
Forresten er der også lige den ting, at jeg godt kunne tænke mig, at alarmen gik i gang selvom mit program er minimeret...hmm ideer ?

Jeg vil etnelig hellere publisere den her fordi så kan alle få glæde af den.

unit ThdTimer;

interface

uses
  Windows, Messages, SysUtils, Classes,
  Graphics, Controls, Forms, Dialogs;

const
  DEFAULT_INTERVAL = 1000;

type
  TThreadedTimer = class;

  TTimerThread = class(TThread)
  private
    FOwner: TThreadedTimer;
    FInterval: Integer;
    FStop: THandle;
  protected
    constructor Create(CreateSuspended: Boolean); virtual;
    procedure Execute; override;
  end;

  TThreadedTimer = class(TComponent)
  private
    FEnabled: Boolean;
    FOnTimer: TNotifyEvent;
    FTimerThread: TTimerThread;

    procedure DoTimer;

    procedure SetEnabled(Value: Boolean);
    function GetInterval: Integer;
    procedure SetInterval(Value: Integer);
    function GetThreadPriority: TThreadPriority;
    procedure SetThreadPriority(Value: TThreadPriority);
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

  published
    property Enabled: Boolean read FEnabled write SetEnabled;
    property Interval: Integer read GetInterval write SetInterval default DEFAULT_INTERVAL;
    property OnTimer: TNotifyEvent read FOnTimer write FOnTimer;
    property ThreadPriority: TThreadPriority read GetThreadPriority
      write SetThreadPriority;
  end;

procedure Register;

implementation

{ TTimerThread }

constructor TTimerThread.Create(CreateSuspended: Boolean);
begin
  inherited Create(CreateSuspended);

  // create event object for signaling interruptions
  FStop := CreateEvent(nil, False, False, nil);
end;

procedure TTimerThread.Execute;
begin
  repeat
      // wait for time elapse
      if WaitForSingleObject(FStop, FInterval) = WAIT_TIMEOUT then
        // if time elapsed run user-event
        Synchronize(FOwner.DoTimer);
  until Terminated;

  // Delete event object
  CloseHandle(FStop);
end;

{ TThreadedTimer }

constructor TThreadedTimer.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);

  // create timer thread
  FTimerThread := TTimerThread.Create(True);
  FTimerThread.FOwner := Self;
  FTimerThread.FreeOnTerminate := False;
  FTimerThread.Priority := tpNormal;
  FTimerThread.FInterval := DEFAULT_INTERVAL;
end;

destructor TThreadedTimer.Destroy;
begin
  // Destroy thread
  // signal thread to terminate
  FTimerThread.Terminate;
  SetEvent(FTimerThread.FStop);
  // resume if stopped
  if FTimerThread.Suspended then FTimerThread.Resume;
  // wait and free
  FTimerThread.WaitFor;
  FTimerThread.Free;

  inherited Destroy;
end;

procedure TThreadedTimer.DoTimer;
begin
  if Assigned(FOnTimer) then
    FOnTimer(self);
end;

procedure TThreadedTimer.SetEnabled(Value: Boolean);
begin
  if Value <> FEnabled then
  begin
    FEnabled := Value;

    if FEnabled then
    begin
      // When enabled resume thread
      if FTimerThread.FInterval > 0 then
      begin
        SetEvent(FTimerThread.FStop);
        FTimerThread.Resume;
      end;
    end
    else
      // suspend thread
      FTimerThread.Suspend;
  end;
end;

function TThreadedTimer.GetInterval: Integer;
begin
  Result := FTimerThread.FInterval;
end;

procedure TThreadedTimer.SetInterval(Value: Integer);
begin
  if Value <> FTimerThread.FInterval then
  begin
    Enabled := False;
    FTimerThread.FInterval := Value;
  end;
end;

function TThreadedTimer.GetThreadPriority: TThreadPriority;
begin
  Result := FTimerThread.Priority;
end;

procedure TThreadedTimer.SetThreadPriority(Value: TThreadPriority);
begin
  FTimerThread.Priority := Value;
end;

procedure Register;
begin
  RegisterComponents('System', [TThreadedTimer]);
end;

end.

Jens B

Det der med om dit program er minimeret eller ej har vel etnelig ikke nogeet med alarment at gører .. I dit Alarm event maximere du bare din application

Hmm, jeg er ikke helt med på programmet. er det et komponent jeg skal installere ? Jeg får ihvertfald en fejlmeddelse. Kan du ikke give et lille eksempel på, hvordan jeg benytter din udgave ?

Hmm, jeg er ikke helt med på programmet. er det et komponent jeg skal installere ? Jeg får ihvertfald en fejlmeddelse. Kan du ikke give et lille eksempel på, hvordan jeg benytter din udgave ?

eksemplet som Borrisholt viser er et component.
gem programmet som Thdtimer.pas
og installer det som et component.
har prøvet det....virker