Timer One-Shot

Question

programmatori Delphi Caro,

Sto cercando aiuto come scrivere un timer one-shot (No GUI, in modo da VCL Timer fuori questione) ...

Mi spiego ancora un po.

Nel mio codice (che spiega con temporizzatore VCL ma in questo particolare progetto non ho forme):

1. chiamata una procedure che inviano un carattere sopra porta seriale
2. abilitare un timer con una quantità X di Interval

In OnTimer evento:

ho un codice che inviano un carattere quindi disattivare ° Il timer stesso non verrà mai più eseguito.

Il problema è che ho bisogno di rendere dinamica la creazione di questi timer. Ho pensato alla funzione SetTimer() quindi KillTimer() nell'evento "OnTimer" per disabilitarla (liberarla).

È un buon modo (sicuro)?

Grazie!

Answer 1

È sicuro uccidere il timer dall'interno di un evento del timer?

Sì, è perfettamente sicuro.

Come implementare il timer one shot più semplice?

Il metodo più semplice implementazione di un secondo timer 1 colpo è questo, ma è da notare, che se si avvia più di loro, non sarà in grado di distinguere quale uno di loro trascorsi suo intervallo:

procedure TimerProc(hwnd: HWND; uMsg: UINT; idEvent: UINT_PTR; 
    dwTime: DWORD); stdcall; 
begin 
    KillTimer(0, idEvent); 
    ShowMessage('I''m done!'); 
end; 

procedure TForm1.Button1Click(Sender: TObject); 
begin 
    SetTimer(0, 0, 1000, @TimerProc); 
end; 

Answer 2

L'API timer multimediale fornisce supporto per un timer one shot. Il vantaggio è che i tempi sono molto più precisi della soluzione SetTimer/KillTimer e possono essere utilizzati con intervalli < 50 ms. Questo ha un prezzo, in quanto il callback non ritorna nel contesto del thread principale. Qui è la mia realizzazione di un timer one-shot con il timer API multimediale:

unit MMTimer; 

interface 
uses windows, Classes, mmsystem, SysUtils; 
TOneShotCallbackEvent = procedure (const UserData: Pointer) of object; 

(* 
    The MMOneShotCallback function calls the Callback after the Interval passed. 
    ** Attention: ** 
    The Callback is not called within the context of the main thread. 
*) 

type TMMOneShotTimer = class(TObject) 
    private 
    FTimeCaps: TTimeCaps; 
    FResult: Integer; 
    FResolution: Cardinal; 
    public 
    constructor Create; 
    function MMOneShotCallback(const Interval: Cardinal; UserData: Pointer; Callback: TOneShotCallbackEvent): Boolean; 
    property Result: Integer read FResult; 
    property Resolution: Cardinal read FResolution; 
end; 
implementation 
type 
    TOneShotCallbackData = record 
    Callback: TOneShotCallbackEvent; 
    UserData: Pointer; 
    end; 
    POneShotCallbackData = ^TOneShotCallbackData; 

procedure OneShotCallback(TimerID, Msg: UINT; 
        dwUser, dw1, dw2: DWord); pascal; 
var pdata: POneShotCallbackData; 
begin 
    pdata := Pointer(dwUser); 
    pdata.Callback(pdata.UserData); 
    FreeMemory(pdata); 
end; 

constructor TMMOneShotTimer.Create; 
begin 
    FResult := timeGetDevCaps(@FTimeCaps, SizeOF(FTimeCaps)); 
    Assert(FResult=TIMERR_NOERROR, 'Call to timeGetDevCaps failed'); 
    FResolution := FTimeCaps.wPeriodMin; 
    FResult := timeBeginPeriod(FResolution); 
    Assert(FResult=TIMERR_NOERROR, 'Call to timeBeginPeriod failed'); 
end; 

function TMMOneShotTimer.MMOneShotCallback(const Interval: Cardinal; UserData: Pointer; Callback: TOneShotCallbackEvent): Boolean; 
var pdata: POneShotCallbackData; 
begin 
    GetMem(pdata, SizeOf(TOneShotCallbackData)); 
    pdata.Callback := Callback; 
    pdata.UserData := UserData; 
    result := (0 <> timeSetEvent(Interval, FResolution, @OneShotCallback, DWord(pdata), TIME_ONESHOT)); 
    if not result then 
    FreeMemory(pdata); 
    end; 
end. 

Answer 3

Ti rendi conto, che non deve avere una GUI, di utilizzare un timer VCL finché si dispone di un maniglia della finestra? Si può semplicemente istanziare uno dal codice

fTimer := TTimer.Create(hWindowHandle); 

E anche se non si dispone di un handle di finestra È possibile creare un chiamando

fVirtualWindowHWND := AllocateHWnd(WndMethod); 

ma in questo caso si hanno anche per scrivere il proprio ciclo di messaggi. So che chiamare l'API di Windows sembra essere una soluzione più semplice, ma ha anche i suoi cavilli (come se non si potesse passare ad un metodo di classe ...), e ho pensato, potresti voler sapere di questo.