getevent.pas

16 relay output channels and 16 isolated digital input channels LED indicators to show activated

unit GetEvent;

interface

uses
  Classes, SysUtils, windows,
  Init ,Convert, DataShow, Driver;

type
  TGetEvent = class(TThread)
  private
    { Private declarations }
    dwDeviceNumber : Longint;
    dwDuration     : Longint;
    bCyclic        : Boolean;
    ulIntCounter   : Longint ;
    ulBfChgCounter : Longint;


  protected
    procedure Execute; override;

    procedure adInterruptEvent;
    procedure adBufChangeEvent;
    procedure adOverrunEvent;
    procedure adTerminateEvent;
  public
    constructor Create(dwDevNum : Longint; dwDur : Longint; bCyc : Boolean);
  end;

implementation

{ Important: Methods and properties of objects in VCL can only be used in a
  method called using Synchronize, for example,

      Synchronize(UpdateCaption);

  and UpdateCaption could look like,

    procedure TGetEvent.UpdateCaption;
    begin
      Form1.Caption := 'Updated in a thread';
    end; }

{ TGetEvent }

constructor TGetEvent.Create(dwDevNum : Longint; dwDur : Longint; bCyc : Boolean);
begin
    inherited Create(False);
    dwDeviceNumber := dwDevNum;
    dwDuration := dwDur;
    bCyclic := bCyc;

    FreeOnTerminate := True;
end;

procedure TGetEvent.Execute;
var
    lTickCount  : Longint;

    ptChkEvent  : PT_CheckEvent;
    wEventType  : Word;

    ptAiCheck  : PT_FAICheck;
    wActiveBuf : Word;
    wStopped   : Word;
    lRetrieved : Longint;
    wOverrun   : Word;
    wHalfReady : Word;

begin
    { Place thread code here }
    {Prepare structure for checking conversion status}
    ulIntCounter :=0;
    ulBfChgCounter :=0;
    with ptChkEvent do
    begin
        EventType    := @wEventType;
        Milliseconds := 5000;
    end;

    with ptAiCheck do
    begin
        ActiveBuf  := @wActiveBuf;
        stopped    := @wStopped;
        retrieved  := @lRetrieved;
        overrun    := @wOverrun;
        HalfReady  := @wHalfReady;
    end;

    {Calculation the terminate time}
    lTickCount := GetTickCount + dwDuration + 60000;

    {Cyclic get deiver's event}
    while (bCyclic = True) or (lTickCount > GetTickCount) do
    begin
        {1. Get the Device event}
        if DRV_CheckEvent(frmInit.ghDev, ptChkEvent) <> 0 then
        begin
            {If cannot get event close and terminate thread}
            MessageBox(0,'Check Event Error !','Thread Message',MB_OK);
            exit;
        end;

        {2. Does it contain the Interrupt event?}
        if (wEventType and ADS_EVT_INTERRUPT) <> 0 then
            {process interrupt event}
            adInterruptEvent();

        {3. Does it contain the buffer change event?}
        if (wEventType and ADS_EVT_BUFCHANGE) <> 0 then
            {process buffer change event}
            adBufChangeEvent();

        {4. Does it contain Overrun event?}
        if (wEventType and ADS_EVT_OVERRUN) <> 0 then
            {process overrun event}
            adOverrunEvent();

        {5. Does it contain terminate event?}
        if (wEventType and ADS_EVT_TERMINATED) <> 0 then
        begin
            {process terminate event}
            adTerminateEvent();
            exit;
        end;

        frmConverting.txtInt.Text :=IntToStr(ulIntCounter);
        frmConverting.txtBuffChange.text := IntToStr(ulBfChgCounter);
    end;

    {Exit get event loop.  Display error message and termionate GetEvent}
    MessageBox(0,'Never Get Any Event! Terminate GetEvent thread',
                 'Thread Message',MB_OK);

end;

procedure TGetEvent.adInterruptEvent();
begin
    {Process Interrupt event}
    ulIntCounter:=ulIntCounter+1;
end;

procedure TGetEvent.adBufChangeEvent();
begin
    {Process Buffer change event}
    ulBfChgCounter:=ulBfChgCounter+1;
end;

procedure TGetEvent.adOverrunEvent();
var
    lErrCde  : Longint;
    szErrMsg : string[50];
begin
    {Process overrun event.
     This demo does not care the overrun event, just clear it}
    lErrCde := DRV_ClearOverrun(frmInit.ghDev);
    if lErrCde <> 0 then
    begin
        DRV_GetErrorMessage(lErrCde, PChar(@szErrMsg));
        MessageBox(0, PChar(@szErrMsg), 'Thread Message', MB_OK);
    end;
end;

procedure TGetEvent.adTerminateEvent();
begin
    {Close the converting form and make it to retrieved convered data}
    if frmConverting.ghThreadGetEvent <> 0 then
    begin
        frmConverting.ghThreadGetEvent := 0;
        frmConverting.Close;
    end;
end;


end.