convert.pas

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

unit Convert;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Buttons, Mask, ComCtrls, ExtCtrls, Gauges,
  Driver;

type
  TfrmConverting = class(TForm)
    butTerminate: TButton;
    prgsDataCounts: TProgressBar;
    tmrDataCounts: TTimer;
    memEvent: TMemo;
    procedure butTerminateClick(Sender: TObject);
    procedure tmrDataCountsTimer(Sender: TObject);
    procedure FormShow(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Terminate();
  private
    {Private declarations }
    ptAiCheck  : PT_FAICheck;
    wActiveBuf : Word;
    wStopped   : Word;
    lRetrieved : Longint;
    wOverrun   : Word;
    wHalfReady : Word;

  public
    { Public declarations }
    gbCyclic         : Boolean;
  end;

var
  frmConverting: TfrmConverting;

implementation

uses Init, DataShow;

{*************************************************************
 * Function: Handle the error code. If the input error code > 0,
 *           it means some error apperent.  This function can
 *           show the error message to a message box and stop
 *           this application.
 * Input:    The error code.
 * return:   none
 ************************************************************* }
Function DoesErr(var lErrCode: LongInt): integer;
var
    szErrMsg   : string[100];
    pszErrMsg  : PChar;
    iRet       : integer;
begin
     {Check the pressed error code}
    If (lErrCode <> 0) Then
    begin
        pszErrMsg := @szErrMsg;
        DRV_GetErrorMessage(lErrCode, pszErrMsg);
        iRet := Application.MessageBox(pszErrMsg, 'Error!!', MB_OK);
        DoesErr := 1;
    end
    else
        DoesErr := 0;
end;


{$R *.DFM}
procedure TfrmConverting.butTerminateClick(Sender: TObject);
var
  lErrCde   : Longint;
begin
  tmrDataCounts.Enabled := false;  ;  
  lErrCde := DRV_FAITerminate(frmInit.ghDev);
  if DoesErr(lErrCde) = 1 then
  begin
    DRV_FreeDMABuffer(frmInit.ghDev, @(frmInit.glDmaBufPtr));
    DRV_DeviceClose(frmInit.ghDev);
    Exit;
  end;
  if not frmInit.chkEventEnable.Checked then
  begin
    Terminate();
  end;
end;

procedure TfrmConverting.tmrDataCountsTimer(Sender: TObject);
var
  lErrCde : Longint;
  iRet    : Integer;
begin
  lErrCde := DRV_FAICheck(frmInit.ghDev, ptAiCheck);
  if DoesErr(lErrCde) = 1 then
  begin
    tmrDataCounts.Enabled := False;
    iRet := Application.MessageBox('Stop to get conversion status!',
                                   'Converting & transfering data message',
                                    MB_OK);
    Exit;
  end;
  prgsDataCounts.Position := ptAiCheck.retrieved^;
end;

procedure TfrmConverting.FormShow(Sender: TObject);
begin
     tmrDataCounts.Enabled := TRUE;
end;

procedure TfrmConverting.FormCreate(Sender: TObject);
begin
  with ptAiCheck do
  begin
    ActiveBuf  := @wActiveBuf;
    stopped    := @wStopped;
    retrieved  := @lRetrieved;
    overrun    := @wOverrun;
    HalfReady  := @wHalfReady;
  end;
end;

procedure TfrmConverting.Terminate();
var
  i         : DWORD;
  lErrCde   : Longint;
  bOk       : Boolean;
  ptFaiData : PT_FAITransfer;
  p         : Pointer;
begin
  {Stop Timer action}
  tmrDataCounts.Enabled := False;
  frmConverting.Enabled := False;
  butTerminate.Caption := 'Waiting...';

  {Stop getEvent thread}
  frmInit.ghThreadGetEvent.Terminate;

  {Get the last conversion status}
  lErrCde := DRV_FAICheck(frmInit.ghDev, ptAiCheck);  

  {Get the AI conversion data}
  With ptFaiData do
  begin
    ActiveBuf  := 0;               {Read buffer A}
    overrun    := @wOverrun;
    count      := frmInit.glConvCount;
    start      := 0;               {Start from buffer begging}
    DataType   := Word(frmInit.chkFloatData.Checked);

    {If want floating data}
    if DataType = 1 Then
      i := SizeOf(single)
    {Else need Raw data}
    else
      i := SizeOf(Word);
    GetMem(DataBuffer, i* count );    {Alolocate memory for data}
  end;

  {  Read buffer A data}
  lErrCde := DRV_FAITransfer(frmInit.ghDev, ptFaiData);
  if DoesErr(lErrCde) = 1 then
  begin
    FreeMem(ptFaiData.DataBuffer);
    DRV_FreeDMABuffer(frmInit.ghDev, @(frmInit.glDmaBufPtr));
    DRV_DeviceClose(frmInit.ghDev);
    Exit;
  end;

  {Determind the conversion counts.}
  p := ptFaiData.DataBuffer;
  if (gbCyclic = False) and (wActiveBuf = 0) Then
    lRetrieved := ptAiCheck.retrieved^ - 1
  else
    lRetrieved := ptFaiData.count - 1;

  {show to buffer A edit}
  frmDataShow.memBufA.Lines.Clear;
  for i:=0 to lRetrieved  do
  begin
    if ptFaiData.DataType = 1 then
    begin
      {Converting to Floating data}
      frmDataShow.memBufA.Lines.Append(IntToStr(i)+': '+FloatToStr(Single(p^)));
      Longint(p) := Longint(p) + SizeOf(Single);
    end
    else
    begin
      {Convert to Hex data}
      frmDataShow.memBufA.Lines.Append(IntToStr(i)+': '+IntToHex(Word(p^), 16) );
      Longint(p) := Longint(p) + SizeOf(Word);
    end;
  end;

  { Read buffer B data}
  ptFaiData.ActiveBuf  := 1;       {Read buffer B}
  lErrCde := DRV_FAITransfer(frmInit.ghDev, ptFaiData);
  if DoesErr(lErrCde) = 1 then
  begin
    FreeMem(ptFaiData.DataBuffer);
    DRV_FreeDMABuffer(frmInit.ghDev, @(frmInit.glDmaBufPtr));
    DRV_DeviceClose(frmInit.ghDev);
    Exit;
  end;

  {determined the conversion counts.}
  p := ptFaiData.DataBuffer;
  {  if it is non-cyclic mode and current active channel is buffer B}
  if (gbCyclic = False) and (wActiveBuf = 1) Then
    {Only convert the data that conversiobn stopped on}
    lRetrieved := ptAiCheck.retrieved^ - 1
  else
    {convert all data}
    lRetrieved := ptFaiData.count - 1;

  {store to buffer B}
  frmDataShow.memBufB.Lines.Clear;
  for i:=0 to lRetrieved  do
  begin
    if ptFaiData.DataType = 1 then
    begin
      {Converting to Floating data}
      frmDataShow.memBufB.Lines.Append(IntToStr(i)+': '+FloatToStr(Single(p^)) );
      Longint(p) := Longint(p) + SizeOf(Single);
    end
    else
    begin
      {Convert to Hex data}
      frmDataShow.memBufB.Lines.Append(IntToStr(i)+': '+IntToHex(Word(p^), 16) );
      Longint(p) := Longint(p) + SizeOf(Word);
    end;
  end;

  {Free data buffer}
  FreeMem(ptFaiData.DataBuffer);
  DRV_FreeDMABuffer(frmInit.ghDev, @(frmInit.glDmaBufPtr));

  {Close device}
  DRV_DeviceClose(frmInit.ghDev);

  {Display the Data Show Form}
  frmDataShow.Show;
  frmConverting.Enabled := True;
  butTerminate.Caption := '&Terminate';
  frmConverting.Close;
  frmInit.Enabled := True;   
end;

end.