di_int.cpp

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

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

#include <vcl.h>
#pragma hdrstop



#include "DI_INT.h"
#include "Thread.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmMain *frmMain;
//---------------------------------------------------------------------------
__fastcall TfrmMain::TfrmMain(TComponent* Owner)
        : TForm(Owner)
{
        gbStart = False;
        gbEnableDI0 = False;
        gbEnableDI16 = False;
        hDeviceHandle = 0;
        
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::cmdCloseClick(TObject *Sender)
{
   SendMessage(Handle,WM_CLOSE,0,0);
}
//---------------------------------------------------------------------------


void __fastcall TfrmMain::cmdSelectDeviceClick(TObject *Sender)
{
    char szDeviceName[100];

    if(gbStart || gbEnableDI0 || gbEnableDI16 )
        {
          Application->MessageBoxA("The timer or events are enabled,close them before close device."
          ,"Demo Message",MB_OK);
          return;
        }

    if(hDeviceHandle != 0)
         DRV_DeviceClose(&hDeviceHandle);

    DRV_SelectDevice(Handle,True,&lDeviceNum,szDeviceName);

    lErrCde=DRV_DeviceOpen(lDeviceNum,&hDeviceHandle);
    if(lErrCde)
    {
        Application->MessageBoxA("Device Open Error!","Driver Message",MB_OK);
        return;
    }
    ctlDeviceName->Caption = AnsiString(szDeviceName) ;

    ptDevFeatures.buffer = (LPDEVFEATURES)&DevFeatures;
    ptDevFeatures.size = sizeof(DEVFEATURES);
    if ((lErrCde = DRV_DeviceGetFeatures(hDeviceHandle,
        (LPT_DeviceGetFeatures)&ptDevFeatures)) != SUCCESS)
    {
        DRV_GetErrorMessage(lErrCde,(LPSTR)szErrMsg);
        DRV_DeviceClose((LONG far *)&hDeviceHandle);
        Application->MessageBox((char *)szErrMsg, "Driver Message", MB_OK);
        return;
    }

    ctlSpinPort->Max = DevFeatures.usMaxDIChl / 8 -1;
    ctlSpinPort->Min = 0;
    ctlSpinPort->Position = 0;
    ctlSpinPortClick(Sender,btPrev);

    cmdStart->Enabled = True;
    cmdEnableDI0->Enabled =True;
    cmdEnableDI16->Enabled = True;
    
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::FormCreate(TObject *Sender)
{
    if(hDeviceHandle != 0)
         DRV_DeviceClose(&hDeviceHandle);
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::ctlSpinPortClick(TObject *Sender,
      TUDBtnType Button)
{
       txtPort->Text = IntToStr(ctlSpinPort->Position);
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::txtPortChange(TObject *Sender)
{
        try
        {
            Port=StrToInt(txtPort->Text);
            if(Port>ctlSpinPort->Max || Port < ctlSpinPort->Min)
               txtPort->Text = IntToStr(ctlSpinPort->Min);
        }
        catch(...)
        {
               txtPort->Text = IntToStr(ctlSpinPort->Min);
        }
}
//---------------------------------------------------------------------------


void __fastcall TfrmMain::FormShow(TObject *Sender)
{
        ctlEvtFrqDI0->Caption = "0.000";
        ctlEvtFrqDI16->Caption = "0.000";
        cmdSelectDeviceClick(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::cmdStartClick(TObject *Sender)
{
   DWORD dwScanTime;
        try
        {
           dwScanTime=StrToInt(txtScanTime->Text);
           if( dwScanTime >10000 || dwScanTime <1)
            {     Application->MessageBoxA("ScanTime must be a integer between 1 and 10000"
                 ,"Demo Message",MB_OK);
                 return;
            }
            Timer1->Interval = dwScanTime;
            gbStart = True;
            cmdStart->Enabled = False;
            cmdStop->Enabled = True;
            Timer1->Enabled = True;
        }
        catch(...)
        {
           txtScanTime->Text =IntToStr(1000);
        }
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::cmdStopClick(TObject *Sender)
{
        cmdStart->Enabled = True;
        cmdStop->Enabled = False;
        Timer1->Enabled = False;
        gbStart = False;        
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::FormClose(TObject *Sender, TCloseAction &Action)
{
        if(gbStart || gbEnableDI0 || gbEnableDI16 )
        {
          Application->MessageBoxA("The timer or events are enabled,close them before close device."
          ,"Demo Message",MB_OK);
          Action=caNone;
          return;
        }
        if(hDeviceHandle != 0)
          DRV_DeviceClose(&hDeviceHandle);
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::Timer1Timer(TObject *Sender)
{
        USHORT gwValue;
        char szBuf[10];

        ptDioReadPortByte.port = Port;
        ptDioReadPortByte.value = &gwValue;

        lErrCde = DRV_DioReadPortByte(hDeviceHandle,&ptDioReadPortByte);
         if(lErrCde)
        {
             DRV_GetErrorMessage(lErrCde,(LPSTR)szErrMsg);
             Application->MessageBoxA(szErrMsg,"Driver Message",MB_OK);
             cmdStopClick(Sender);
             return;
         }
         ctlData->Caption = IntToHex(gwValue,2);
}
//---------------------------------------------------------------------------


void TfrmMain::CheckEvent()
{
   //TODO: Add your source code here
   DWORD dwTime;
   ptCheckEvent.EventType = &CheckEventType;
   ptCheckEvent.Milliseconds =  1000;

   lErrCde = DRV_CheckEvent(hDeviceHandle,&ptCheckEvent);
   if(lErrCde == 0)
   {
       if(CheckEventType==ADS_EVT_INTERRUPT_DI0)
             EvtCntDI0=EvtCntDI0+1;
       if(CheckEventType==ADS_EVT_INTERRUPT_DI16)
             EvtCntDI16 =EvtCntDI16+1;
   }
   else
   {
        if(gbEnableDI0 || gbEnableDI16)
        {
             DRV_GetErrorMessage(lErrCde,(LPSTR)szErrMsg);
             Application->MessageBoxA(szErrMsg,"Driver Message",MB_OK);
        }
   }
   dwCurrentTime = GetTickCount();
   dwTime = dwCurrentTime - dwStartTime;
   if(dwTime >=1000)
   {
      if(gbEnableDI0)
        ctlEvtFrqDI0->Caption = FormatFloat("0.0000",EvtCntDI0 *1000.0 /dwTime);
      if(gbEnableDI16)
         ctlEvtFrqDI16->Caption = FormatFloat("0.0000",EvtCntDI16 *1000.0 /dwTime);
      EvtCntDI0 = 0;
      EvtCntDI16 = 0;
      dwStartTime = GetTickCount();
   }

}
void __fastcall TfrmMain::cmdEnableDI0Click(TObject *Sender)
{
    try
    {
            ptEnableEvent.EventType = ADS_EVT_INTERRUPT_DI0;
            ptEnableEvent.Enabled = 1;
            ptEnableEvent.Count = StrToInt(txtEvtCntDI0->Text);
            lErrCde = DRV_EnableEvent( hDeviceHandle, &ptEnableEvent );
            if(lErrCde)
            {
                 DRV_GetErrorMessage(lErrCde,(LPSTR)szErrMsg);
                 Application->MessageBoxA(szErrMsg,"Driver Message",MB_OK);
                 return;
            }
            EvtCntDI0 = 0;
            gbEnableDI0 = True;
            if(gbEnableDI16 == False)
            {
                dwStartTime = GetTickCount();
                pThread = new CheckThread(false);
            }



            cmdEnableDI0->Enabled = False;
            cmdDisableDI0->Enabled = True;
    }
    catch(...)
    {
     //   {if you want to process the exception,add code here}
    }


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

void __fastcall TfrmMain::cmdEnableDI16Click(TObject *Sender)
{
    try
    {
            ptEnableEvent.EventType = ADS_EVT_INTERRUPT_DI16;
            ptEnableEvent.Enabled = 1;
            ptEnableEvent.Count = StrToInt(txtEvtCntDI16->Text);
            lErrCde = DRV_EnableEvent( hDeviceHandle, &ptEnableEvent );
            if(lErrCde)
            {
                 DRV_GetErrorMessage(lErrCde,(LPSTR)szErrMsg);
                 Application->MessageBoxA(szErrMsg,"Driver Message",MB_OK);
                 return;
            }
            EvtCntDI16 = 0;
            gbEnableDI16 = True;
            if(gbEnableDI0 == False)
            {
                dwStartTime = GetTickCount();
                pThread = new CheckThread(false);
            }



            cmdEnableDI16->Enabled = False;
            cmdDisableDI16->Enabled = True;
    }
    catch(...)
    {
     //   {if you want to process the exception,add code here}
    }

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

void __fastcall TfrmMain::cmdDisableDI0Click(TObject *Sender)
{
   try
   {
    ptEnableEvent.EventType = ADS_EVT_INTERRUPT_DI0;
    ptEnableEvent.Enabled = 0;
    ptEnableEvent.Count = StrToInt(txtEvtCntDI0->Text);
    lErrCde = DRV_EnableEvent( hDeviceHandle, &ptEnableEvent );
    if( lErrCde )
    {
        DRV_GetErrorMessage(lErrCde,(LPSTR)szErrMsg);
        Application->MessageBoxA(szErrMsg,"Driver Message",MB_OK);
        return;
    }
    gbEnableDI0 = False;

    cmdEnableDI0->Enabled = True;
    cmdDisableDI0->Enabled = False;
    ctlEvtFrqDI0->Caption = "0.000";
    }
    catch(...)
    {
     //       {if you want to process the exception,add code here}
    }

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

void __fastcall TfrmMain::cmdDisableDI16Click(TObject *Sender)
{
   try
   {
    ptEnableEvent.EventType = ADS_EVT_INTERRUPT_DI16;
    ptEnableEvent.Enabled = 0;
    ptEnableEvent.Count = StrToInt(txtEvtCntDI16->Text);
    lErrCde = DRV_EnableEvent( hDeviceHandle, &ptEnableEvent );
    if( lErrCde )
    {
        DRV_GetErrorMessage(lErrCde,(LPSTR)szErrMsg);
        Application->MessageBoxA(szErrMsg,"Driver Message",MB_OK);
        return;
    }
    gbEnableDI16 = False;

    cmdEnableDI16->Enabled = True;
    cmdDisableDI16->Enabled = False;
    ctlEvtFrqDI16->Caption = "0.000";
    }
    catch(...)
    {
     //       {if you want to process the exception,add code here}
    }

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