mainform.cpp

来自「16 relay output channels and 16 isolated」· C++ 代码 · 共 403 行

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "MainForm.h"
#include "SettingForm.h"
#include "ShowDataForm.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmMain *frmMain;
#define Mega 0x100000;
//---------------------------------------------------------------------------
__fastcall TfrmMain::TfrmMain(TComponent* Owner)
        : TForm(Owner)
{
    lErrCde = 0;
    ghDev = 0;  //      {Device handle for every device}
    lDeviceNumber = 0;
    dwDataWidth = 0;
    dwDIStartMode = 0;
    dwDITriggerSource = 0;
    dwDIStopMode = 0;
    dwDIOperationMode = 0;
    dwDIMatchValue = 0;
    dwCount = 0;
    dwUserBufferSize = 0;
    dwCyclicMode = 0;    // cyclic or non-cyclic mode
    hGUserBuf = 0;
    hUserBuf = 0;
    dwDIBufferChangeCounter  = 0 ;
    dwDIOverRunCounter = 0;
    dwDITerminateCounter = 0;
    dwRetrieved = 0 ,dwFdiStatus = 0;
    pThread=NULL;
}

int DoesErr( ULONG lErrCode)
{
  char szErrMsg[100];
  //{Check the pressed error code}
  if( lErrCode != 0 )
  {
    DRV_GetErrorMessage(lErrCode, szErrMsg);
    Application->MessageBox(szErrMsg, "Error!!", MB_OK);
    return 1;
  }
  else
    return 0;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::BtSelectClick(TObject *Sender)
{


  //{Select devcie from device list}
  lErrCde = DRV_SelectDevice( Handle, false, &lDeviceNumber,
             szDeviceName);
  if( DoesErr(lErrCde) == 1 )
      return;

 // {Get the device number}
  txtDevice->Text = szDeviceName;

  //{Open the device, get device handle}
  lErrCde = DRV_DeviceOpen(lDeviceNumber, &ghDev);
  if( DoesErr(lErrCde) == 1 )
      return;

  //{Get device feature}
  ptDevFeatures.buffer = &dfCurDevice;
  ptDevFeatures.size = sizeof(DEVFEATURES);
  lErrCde = DRV_DeviceGetFeatures(ghDev, &ptDevFeatures);
  if( DoesErr(lErrCde) == 1 )
  {
    DRV_DeviceClose(&ghDev);
    return;
  }

  //{Get properties}
  ULONG dwCount = sizeof(long);
  // {Get Board ID}
  lErrCde = DRV_DeviceGetProperty(ghDev, CFG_BoardID, &dwBoardId, &dwCount);
  if( DoesErr(lErrCde) == 1 )
     return;

  //{Get data width}
  lErrCde = DRV_DeviceGetProperty(ghDev, CFG_DioFdioDirection, &dwDataWidth, &dwCount);
  if( DoesErr(lErrCde) == 1 )
     return;

  //{Get start type}
  lErrCde = DRV_DeviceGetProperty(ghDev, CFG_DiStartMethod, &dwDIStartMode, &dwCount);
  if( DoesErr(lErrCde) == 1 )
     return;

  //{Get stop type}
  lErrCde = DRV_DeviceGetProperty(ghDev, CFG_DiStopMethod, &dwDIStopMode, &dwCount);
  if( DoesErr(lErrCde) == 1 )
     return;

  //{Get trigger source}
  lErrCde = DRV_DeviceGetProperty(ghDev, CFG_DiPacerSource, &dwDITriggerSource, &dwCount);
  if( DoesErr(lErrCde) == 1 )
     return;

  //{Get Operation Mode value}
  lErrCde = DRV_DeviceGetProperty(ghDev, CFG_DiOperationMode , &dwDIOperationMode, &dwCount);
  if( DoesErr(lErrCde) == 1 )
     return;

  //{Get Pattern Match value}
  lErrCde = DRV_DeviceGetProperty(ghDev, CFG_DiPatternMatchValue, &dwDIMatchValue, &dwCount);
  if( DoesErr(lErrCde) == 1 )
     return;

  //{Get DI DMA mode}
  if (dwBoardId == BD_MIC3755)
  {
     lErrCde = DRV_DeviceGetProperty(ghDev, CFG_DiTransferRequestMode, &dwDiDmaMode, &dwCount);
     if( DoesErr(lErrCde) == 1 )
        return;
  }

  //{Get counter value}
  dwCount = 3 * sizeof(Longint);
  lErrCde = DRV_DeviceGetProperty(ghDev, CFG_CounterCountValue, &dwCounterValue, &dwCount);
  if( DoesErr(lErrCde) == 1 )
     return;

  BtRun->Enabled = TRUE;
  BtSetting->Enabled = TRUE;
          
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::BtSettingClick(TObject *Sender)
{
  frmSetting->Show();
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::BtExitClick(TObject *Sender)
{
   if ( ghDev == 0 )
       Application->Terminate();

     // disable event
    ptEnableEvent.Enabled = 0;
    ptEnableEvent.EventType = ADS_EVT_DI_OVERRUN;
    lErrCde = DRV_EnableEvent(ghDev, &ptEnableEvent);
    ptEnableEvent.EventType = ADS_EVT_DI_LOBUFREADY;
    lErrCde = DRV_EnableEvent(ghDev, &ptEnableEvent);
    ptEnableEvent.EventType = ADS_EVT_DI_HIBUFREADY;
    lErrCde = DRV_EnableEvent(ghDev, &ptEnableEvent);
    ptEnableEvent.EventType = ADS_EVT_DI_TERMINATED;
    lErrCde = DRV_EnableEvent(ghDev, &ptEnableEvent);
      VirtualFree( hUserBuf, dwUserBufferSize, MEM_DECOMMIT );
      VirtualFree( hUserBuf, 0, MEM_RELEASE);

    if ( ghDev != 0 )
        DRV_DeviceClose( &ghDev );
    Application->Terminate();
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::BtStopClick(TObject *Sender)
{
 //    usThreadLoop = 0;
     lErrCde = DRV_FDIStop( ghDev );
     if( DoesErr(lErrCde) ==1  )
       return;
     pThread->Terminate();
      BtRun->Enabled  = TRUE;
     BtStop->Enabled = FALSE;
     BtExit->Enabled = TRUE;
     btShow->Enabled = true;

}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::BtRunClick(TObject *Sender)
{

    dwDIBufferChangeCounter = 0;
    dwDIOverRunCounter  = 0;
    dwDITerminateCounter = 0;
    EditBufferChange->Text = "0";
    EditOverrun->Text = "0";
    EditTerminate->Text = "0";
    txtBuffName->Text ="";


    if( dwUserBufferSize == 0)     // 1 mega
        dwUserBufferSize = Mega;
    if( dwUserBufferSize == 1)  // 2 mega
        dwUserBufferSize = 2 * Mega;
    if( dwUserBufferSize == 2)   // 4 mega
        dwUserBufferSize = 4 * Mega
    if ( dwUserBufferSize == 3 )   // 8 mega
        dwUserBufferSize = 8 * Mega;
    if (dwUserBufferSize == 4 )    // 16 mega
        dwUserBufferSize = 16 * Mega

    // allocate user buffer
     if(hUserBuf != NULL )
    {
      VirtualFree( hUserBuf, dwUserBufferSize, MEM_DECOMMIT );
      VirtualFree( hUserBuf, 0, MEM_RELEASE);
    }
    hUserBuf = VirtualAlloc( NULL,                    // region to reserve or commit
                             dwUserBufferSize,          // size of region
                             MEM_COMMIT,  // type of allocation
                             PAGE_READWRITE );        // type of access protection
    if ( hUserBuf == 0 )
    {
        Application->MessageBox("Allocate memory error!", "Error!!", MB_OK);
        DRV_DeviceClose(&ghDev);
        return;
    }

    // enable event
    ptEnableEvent.Enabled = 1;
    ptEnableEvent.Count = 1;
    ptEnableEvent.EventType = ADS_EVT_DI_OVERRUN;
    lErrCde = DRV_EnableEvent(ghDev,  &ptEnableEvent);
    ptEnableEvent.EventType = ADS_EVT_DI_LOBUFREADY;
    lErrCde = DRV_EnableEvent(ghDev,  &ptEnableEvent);
    ptEnableEvent.EventType = ADS_EVT_DI_HIBUFREADY;
    lErrCde = DRV_EnableEvent(ghDev,  &ptEnableEvent);
    ptEnableEvent.EventType = ADS_EVT_DI_TERMINATED;
    lErrCde = DRV_EnableEvent(ghDev, &ptEnableEvent);
    if( DoesErr(lErrCde) == 1 )
    {
      VirtualFree( hUserBuf, dwUserBufferSize, MEM_DECOMMIT );
      VirtualFree( hUserBuf, 0, MEM_RELEASE);
      return;
    }

    // calculate the count
    if (dwDataWidth == 3)                 // 8-bit
        dwCount = dwUserBufferSize;
    else if( dwDataWidth == 2 )           // 16- bit
        dwCount = dwUserBufferSize / 2 ;
    else                                    // 32-bit
        dwCount = dwUserBufferSize / 4;

    // set the parameters
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_CounterCountValue, &(dwCounterValue[0]), 12);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DiOperationMode, &dwDIOperationMode, 4);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DioFdioDirection, &dwDataWidth, 4);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DiStartMethod, &dwDIStartMode, 4);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DiStopMethod, &dwDIStopMode, 4);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DiPatternMatchValue, &dwDIMatchValue, 4);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DiPacerSource, &dwDITriggerSource, 4);
    if (frmMain->dwBoardId == BD_MIC3755)
     {
        lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DiTransferRequestMode, &dwDiDmaMode, 4);
     }

    if( DoesErr(lErrCde) == 1 )
    {
      VirtualFree( hUserBuf, dwUserBufferSize, MEM_DECOMMIT );
      VirtualFree( hUserBuf, 0, MEM_RELEASE);
      return;
    }

    // Start fast DI
    lErrCde = DRV_FDIStart(ghDev, dwCyclicMode, dwCount, hUserBuf);
    if( DoesErr(lErrCde) == 1 )
    {
      VirtualFree( hUserBuf, dwUserBufferSize, MEM_DECOMMIT );
      VirtualFree( hUserBuf, 0, MEM_RELEASE);
      return;
    }

    ptCheckEvent.EventType = &usEventType;
    ptCheckEvent.Milliseconds = 10000;
    // creat thread to check event
    bThreadLoop = 1;
    pThread=new CheckEventThread(false);
     // gray the button
    BtRun->Enabled  = FALSE;
    BtStop->Enabled = TRUE;
    BtExit->Enabled = FALSE;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::btShowClick(TObject *Sender)
{
     frmShowData->Show();
}

//---------------------------------------------------------------------------


bool TfrmMain::CheckEvent()
{
  //TODO: Add your source code here
 //{Prepare structure for checking conversion status}
  //{Cyclic get deiver's event}
  while ( bThreadLoop )
  {
   // {1. Get the Device event}
    if( DRV_CheckEvent(ghDev, &ptCheckEvent) != 0)
    {
      //{If cannot get event close and terminate thread}
      Application->MessageBox("Check Event Error !","Thread Message",MB_OK);
      return false;
    }

   // {2. Does it contain the Interrupt event?}
    if (usEventType == ADS_EVT_DI_LOBUFREADY)
    {
      //{process buffer change event}
      dwDIBufferChangeCounter = dwDIBufferChangeCounter + 1;
      lErrCde = DRV_ClearFlag(ghDev, ADS_EVT_DI_OVERRUN);
      lErrCde = DRV_FDICheck( ghDev, &dwFdiStatus, &dwRetrieved);
      txtBuffName->Text ="Lower half buffer";

      if( DoesErr(lErrCde) == 1 )
        return false;
    }

   // {3. Does it contain the buffer change event?}
    if (usEventType == ADS_EVT_DI_HIBUFREADY)
    {
      //{process buffer change event}
      dwDIBufferChangeCounter = dwDIBufferChangeCounter + 1;
      lErrCde = DRV_ClearFlag(ghDev, ADS_EVT_DI_OVERRUN);
      txtBuffName->Text ="Higher half buffer";
      if( DoesErr(lErrCde) == 1 )
        return false;
      }


   // {4. Does it contain Overrun event?}
    if (usEventType == ADS_EVT_DI_OVERRUN)
    {
      //{process overrun event}
      dwDIOverRunCounter = dwDIOverRunCounter + 1;
      lErrCde = DRV_ClearFlag(ghDev, ADS_EVT_DI_OVERRUN);
      if( DoesErr(lErrCde) == 1 )
        return false;
    }

   // {5. Does it contain terminate event?}
    if (usEventType == ADS_EVT_DI_TERMINATED)
    {
      //{process terminate event}
      dwDITerminateCounter = dwDITerminateCounter + 1;
      bThreadLoop = 0;
      EditTerminate->Text = IntToStr( dwDITerminateCounter );
      BtStop->Click();
      lErrCde = DRV_ClearFlag(ghDev, ADS_EVT_DI_OVERRUN);
      if( DoesErr(lErrCde) == 1 )
        return false;
      return true;
    }

    EditBufferChange->Text = IntToStr( dwDIBufferChangeCounter );
    EditOverrun->Text = IntToStr( dwDIOverRunCounter );
    EditTerminate->Text = IntToStr( dwDITerminateCounter );

  }

 return true;

}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

//   Important: Methods and properties of objects in VCL can only be
//   used in a method called using Synchronize, for example:
//
//      Synchronize(UpdateCaption);
//
//   where UpdateCaption could look like:
//
//      void __fastcall CheckEventThread::UpdateCaption()
//      {
//        Form1->Caption = "Updated in a thread";
//      }
//---------------------------------------------------------------------------

__fastcall CheckEventThread::CheckEventThread(bool CreateSuspended)
        : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
void __fastcall CheckEventThread::Execute()
{
        //---- Place thread code here ----
       frmMain->CheckEvent(); 
}

void __fastcall TfrmMain::FormCreate(TObject *Sender)
{
       BtSelectClick(Sender);
}
//---------------------------------------------------------------------------