mainform.cpp

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

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

#include <vcl.h>
#pragma hdrstop

#include "MainForm.h"
#include "SettingForm.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;
    dwDOStartMode = 0;
    dwDOTriggerSource = 0;
    dwDOStopMode = 0;
    dwDOOperationMode = 0;
    dwDigitalValue = 0;
    dwCount = 0;
    dwUserBufferSize = 0;
    dwCyclicMode = 0;    // cyclic or non-cyclic mode
    hGUserBuf = 0;
    hUserBuf = 0;
    dwDOBufferChangeCounter  = 0 ;
    dwDOOverRunCounter = 0;
    dwDOTerminateCounter = 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_DoStartMethod, &dwDOStartMode, &dwCount);
  if( DoesErr(lErrCde) == 1 )
     return;
     
  //{Get stop type}
  lErrCde = DRV_DeviceGetProperty(ghDev, CFG_DoStopMethod, &dwDOStopMode, &dwCount);
  if( DoesErr(lErrCde) == 1 )
     return;

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

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

  //{Get DO DMA mode}
  if (dwBoardId == BD_MIC3755)
  {
     lErrCde = DRV_DeviceGetProperty(ghDev, CFG_DoTransferRequestMode, &dwDoDmaMode, &dwCount);
     if( DoesErr(lErrCde) == 1 )
        return;
  }

  //{Get counter value}
  dwCount = 3 * sizeof(long);
  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);
    GlobalUnlock(hGUserBuf);
    GlobalFree(hGUserBuf);
     if( pThread)
          pThread->Terminate();

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

void __fastcall TfrmMain::BtStopClick(TObject *Sender)
{
 //    usThreadLoop = 0;
     lErrCde = DRV_FDOStop( ghDev );
     if( DoesErr(lErrCde) ==1  )
       return;
    GlobalUnlock(hGUserBuf);
    GlobalFree(hGUserBuf);
      BtRun->Enabled  = TRUE;
     BtStop->Enabled = FALSE;
     BtExit->Enabled = TRUE;

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

void __fastcall TfrmMain::BtRunClick(TObject *Sender)
{
    DWORD i=0;
    dwDOBufferChangeCounter = 0;
    dwDOOverRunCounter  = 0;
    dwDOTerminateCounter = 0;

    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 )   // 4 mega
        dwUserBufferSize = 8 * Mega;
    // Else If dwUserBufferSize = 4 Then  ' 16 mega
    //    dwUserBufferSize = 16 * Mega

    // allocate user buffer
    hGUserBuf=GlobalAlloc(GPTR, dwUserBufferSize);
    hUserBuf = GlobalLock(hGUserBuf);
    if ( hUserBuf == NULL )
    {
        Application->MessageBox("Allocate memory error!", "Error!!", MB_OK);
        DRV_DeviceClose(&ghDev);
        return;
    }

    // enable event
    ptEnableEvent.Enabled = 1;
    ptEnableEvent.Count = 1;
    ptEnableEvent.EventType = ADS_EVT_DO_UNDERRUN;
    lErrCde = DRV_EnableEvent(ghDev,  &ptEnableEvent);
    ptEnableEvent.EventType = ADS_EVT_DO_LOBUFTRANS;
    lErrCde = DRV_EnableEvent(ghDev,  &ptEnableEvent);
    ptEnableEvent.EventType = ADS_EVT_DO_HIBUFTRANS;
    lErrCde = DRV_EnableEvent(ghDev,  &ptEnableEvent);
    ptEnableEvent.EventType = ADS_EVT_DO_TERMINATED;
    lErrCde = DRV_EnableEvent(ghDev, &ptEnableEvent);
    if( DoesErr(lErrCde) == 1 )
    {
      GlobalUnlock(hGUserBuf);
      GlobalFree(hGUserBuf);
      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;

    switch( dwDataWidth )
    {
    case 3:
       for ( i = 0 ; i < dwCount; i++)
       {
          ((Byte *)hUserBuf)[i] = (Byte)dwDigitalValue;
       }
       break;

    case 2:
       for ( i = 0 ; i < dwCount; i++)
       {
          ((USHORT *)hUserBuf)[i] = (USHORT)dwDigitalValue;
       }
      break;

    default:
       for ( i = 0 ; i <dwCount; i++)
       {
          ((ULONG *)hUserBuf)[i] = (ULONG)dwDigitalValue;
       }
       break;
    }

    // set the parameters
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_CounterCountValue, &(dwCounterValue[0]), 12);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DoOperationMode, &dwDOOperationMode, 4);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DioFdioDirection, &dwDataWidth, 4);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DoStartMethod, &dwDOStartMode, 4);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DoStopMethod, &dwDOStopMode, 4);
    lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DoPacerSource, &dwDOTriggerSource, 4);
    if (frmMain->dwBoardId == BD_MIC3755)
    {
       lErrCde = DRV_DeviceSetProperty(ghDev, CFG_DoTransferRequestMode, &dwDoDmaMode, 4);
    }
 
    if( DoesErr(lErrCde) == 1 )
    {
      GlobalUnlock(hGUserBuf);
      GlobalFree(hGUserBuf);
      return;
    }

    // Start fast DI
    lErrCde = DRV_FDOStart(ghDev, dwCyclicMode, dwCount, hUserBuf);
    if( DoesErr(lErrCde) == 1 )
    {
      GlobalUnlock(hGUserBuf);
      GlobalFree(hGUserBuf);
      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;
}
//---------------------------------------------------------------------------

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


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_DO_LOBUFTRANS)
    {
      //{process buffer change event}
      dwDOBufferChangeCounter = dwDOBufferChangeCounter + 1;
      lErrCde = DRV_ClearFlag(ghDev, ADS_EVT_DO_UNDERRUN);
      lErrCde = DRV_FDICheck( ghDev, &dwFdiStatus, &dwRetrieved);
      txtBuffName->Text ="Lower half buffer";


    }

   // {3. Does it contain the buffer change event?}
    if (usEventType == ADS_EVT_DO_HIBUFTRANS)
    {
      //{process buffer change event}
      dwDOBufferChangeCounter = dwDOBufferChangeCounter + 1;
      lErrCde = DRV_ClearFlag(ghDev, ADS_EVT_DO_UNDERRUN);
      txtBuffName->Text ="Higher half buffer";
    }


   // {4. Does it contain Overrun event?}
    if (usEventType == ADS_EVT_DO_UNDERRUN)
    {
      //{process overrun event}
      dwDOOverRunCounter = dwDOOverRunCounter + 1;
      lErrCde = DRV_ClearFlag(ghDev, ADS_EVT_DO_UNDERRUN);

    }

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

    EditBufferChange->Text = IntToStr( dwDOBufferChangeCounter );
    EditOverrun->Text = IntToStr( dwDOOverRunCounter );
    EditTerminate->Text = IntToStr( dwDOTerminateCounter );

  }

 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);
}
//---------------------------------------------------------------------------