counterfrm.cpp

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

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

#include <vcl.h>
#pragma hdrstop

#include "Counterfrm.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{

    //Select Device
    if(1 == DRV_SelectDevice(Handle, True, (ULONG*)&lDeviceNum, szDescription)){
        Application->MessageBoxA("Can not Open Select Device Dialog", "Error");
    }
    labDeviceName->Caption = AnsiString(szDescription);
    
    //Open Device
    ErrCde = DRV_DeviceOpen(lDeviceNum, (LONG far *) &lDriverHandle);
    if (ErrCde != SUCCESS){
       DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
       Application->MessageBoxA((char*)szErrMsg,"Driver Message");
    }
    //Get Device Features
    ptDevGetFeatures.buffer = (LPDEVFEATURES )&DevFeatures;
    ptDevGetFeatures.size   = sizeof(DEVFEATURES);
    ErrCde = DRV_DeviceGetFeatures(lDriverHandle, &ptDevGetFeatures);
    if (ErrCde != SUCCESS){
       DRV_GetErrorMessage(ErrCde, (LPSTR)szErrMsg);
       Application->MessageBoxA((char*)szErrMsg, "Driver Message");
       DRV_DeviceClose(&lDriverHandle);
    }
    //Close Device
    DRV_DeviceClose(&lDriverHandle);
    //store some device specific parameters
    usMaxCntNum = DevFeatures.usMaxTimerChl;
    dwBoardID = DevFeatures.dwBoardID;

    //updata UI
    //Channel
    cmbChannel->Clear();
    for(int i=0; i<usMaxCntNum; i++){
       cmbChannel->Items->Add(AnsiString(i));
    }
    //Cnt Src
    cmbCntSrc->Clear();
    cmbCntSrc->Items->Add("OUT N-1");
    cmbCntSrc->Items->Add("CLK N");
    cmbCntSrc->Items->Add("CLK N-1");
    cmbCntSrc->Items->Add("FOUT 0");
    cmbCntSrc->Items->Add("FOUT 1");
    if(dwBoardID != BD_PCM3780){
       cmbCntSrc->Items->Add("FOUT 2");
       cmbCntSrc->Items->Add("FOUT 3");
    }
    cmbCntSrc->Items->Add("GATE N-1");

    //Init the UI
    cmbChannel->Text = "0";
    cmbChannel->ItemIndex = 0;
    cmbCntMode->Text = "A";
    cmbCntMode->ItemIndex = 0;
    cmbCntSrc->Text = "CLK N";
    cmbCntSrc->ItemIndex = 1;
    cmbGateSrc->Text = "GATE N";
    cmbGateSrc->ItemIndex = 1;
    cmbOutputMode->Text = "ACTIVE HIGH PULSE";
    cmbOutputMode->ItemIndex = 0;
    rdgCountEdg->ItemIndex = 0;
    rdgCntDir->ItemIndex = 0;
    rdgOPCrtl->ItemIndex = 0;
    rdgGatePl->ItemIndex = 0;
    rdgTCInt->ItemIndex = 1;
    txtIniVal->Text = "1";
    grpGateMode->Enabled = False;
    bRun = False;


}
//---------------------------------------------------------------------------
void __fastcall TForm1::btnDeviceSelectClick(TObject *Sender)
{
    FormCreate(Sender);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::btnStartClick(TObject *Sender)
{
    //Device open
    ErrCde = DRV_DeviceOpen(lDeviceNum, (LONG far *) &lDriverHandle);
    bRun = True;
    if (ErrCde != SUCCESS){
        strcpy(szErrMsg,"Device open error !");
        Application->MessageBoxA((char* )szErrMsg,"Device Open");
        return;
    }
    //Get Device feature
    ptDevGetFeatures.buffer = (LPDEVFEATURES )&DevFeatures;
    ptDevGetFeatures.size   = sizeof(DEVFEATURES);
    ErrCde = DRV_DeviceGetFeatures(lDriverHandle, (PT_DeviceGetFeatures*)&ptDevGetFeatures);
    if (ErrCde != SUCCESS){
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBoxA((char*)szErrMsg,"Driver Message");
        DRV_DeviceClose((LONG far *)&lDriverHandle);
        return;
    }
    if (0 == DevFeatures.usMaxTimerChl){
        Application->MessageBoxA((char*)"No Counter Channel","Driver Message");
        DRV_DeviceClose((LONG far *)&lDriverHandle);
        return;
    }

    //Start counter
    //step 1: select count source
    switch(cmbCntSrc->ItemIndex){
      case 0: usCountSrc = PA_MODE_COUNT_SRC_OUT_N_M1; break;
      case 1: usCountSrc = PA_MODE_COUNT_SRC_CLK_N; break;
      case 2: usCountSrc = PA_MODE_COUNT_SRC_CLK_N_M1; break;
      case 3: usCountSrc = PA_MODE_COUNT_SRC_FOUT_0; break;
      case 4: usCountSrc = PA_MODE_COUNT_SRC_FOUT_1; break;
      case 5:
      if(dwBoardID != BD_PCM3780){
         usCountSrc = PA_MODE_COUNT_SRC_FOUT_2;
      }else{
         usCountSrc = PA_MODE_COUNT_SRC_GATE_N_M1;
      }
      break;
      case 6: usCountSrc = PA_MODE_COUNT_SRC_FOUT_3; break;
      case 7: usCountSrc = PA_MODE_COUNT_SRC_GATE_N_M1; break;

      default: usCountSrc = PA_MODE_COUNT_SRC_CLK_N;
    }
    
    //step 2: select count mode
    switch(cmbCntMode->ItemIndex){
      case 0: usMode = MODE_A; break;
      case 1: usMode = MODE_B; break;
      case 2: usMode = MODE_C; break;
      case 3: usMode = MODE_D; break;
      case 4: usMode = MODE_E; break;
      case 5: usMode = MODE_F; break;
      case 6: usMode = MODE_G; break;
      case 7: usMode = MODE_H; break;
      case 8: usMode = MODE_I; break;
      case 9: usMode = MODE_J; break;
      case 10: usMode = MODE_K; break;
      case 11: usMode = MODE_L; break;
      case 12: usMode = MODE_O; break;
      case 13: usMode = MODE_R; break;
      case 14: usMode = MODE_U; break;
      case 15: usMode = MODE_X; break;
      default: usMode = MODE_A;
    }
    //step 3: select channel
    usChannel = cmbChannel->Text.ToInt();
    //step 4: select initial value
    usInitValue = txtIniVal->Text.ToInt();
    //step 5: select counting edge
    if(0 == rdgCountEdg->ItemIndex){
        usCntEdge = PA_MODE_COUNT_RISE_EDGE;
    }else{
        usCntEdge = PA_MODE_COUNT_FALL_EDGE;
    }
    //step 6: select counting direction
    if(0 == rdgCntDir->ItemIndex){
        usCntDir = PA_MODE_COUNT_UP;
    }else{
        usCntDir = PA_MODE_COUNT_DOWN;
    }
    //step 7 select output control
    if(0 == rdgOPCrtl->ItemIndex){
        usOutputEnable = PA_MODE_ENABLE_OUTPUT;
        switch(cmbOutputMode->ItemIndex){
          case 0: usOutputMode = PA_MODE_ACT_HIGH_TC_PULSE; break;
          case 1: usOutputMode = PA_MODE_ACT_LOW_TC_PULSE; break;
          case 2: usOutputMode = PA_MODE_TC_TOGGLE_FROM_LOW; break;
          case 3: usOutputMode = PA_MODE_TC_TOGGLE_FROM_HIGH; break;
          default:usOutputMode = PA_MODE_ACT_HIGH_TC_PULSE;
       }
    }else{
        usOutputEnable = PA_MODE_DISABLE_OUTPUT;
        usOutputMode = 0;
    }
    //step 8 slect the Gate parameters
    if(grpGateMode->Enabled == True){
        bGateEnable = True;
        switch(cmbGateSrc->ItemIndex){
          case 0: usGateSrc = PA_MODE_GATE_SRC_OUT_N_M1; break;
          case 1: usGateSrc = PA_MODE_GATE_SRC_GATE_N; break;
          case 2: usGateSrc = PA_MODE_GATE_SRC_GATE_N_M1; break;
          default:usGateSrc = PA_MODE_GATE_SRC_OUT_N_M1;
        }
        if(0 == rdgGatePl->ItemIndex){
            usGatePl = PA_MODE_GATE_POSITIVE;
        }else{
            usGatePl = PA_MODE_GATE_NEGATIVE;
        }
    }else{
        usGateSrc = PA_MODE_GATE_SRC_GATE_NO;
        usGatePl = 0;
        bGateEnable = False;
    }
    //start counter
    ptCounterConfig.usCounter = usChannel;
    ptCounterConfig.usInitValue = usInitValue;
    ptCounterConfig.usCountMode = usMode;
    ptCounterConfig.usCountDirect = usCntDir;
    ptCounterConfig.usCountEdge = usCntEdge;
    ptCounterConfig.usOutputEnable = usOutputEnable;
    ptCounterConfig.usOutputMode = usOutputMode;
    ptCounterConfig.usClkSrc = usCountSrc;
    ptCounterConfig.usGateSrc = usGateSrc;
    ptCounterConfig.usGatePolarity = usGatePl;

    ErrCde =  DRV_CounterConfig(lDriverHandle,(LPT_CounterConfig)&ptCounterConfig);
    if(ErrCde != SUCCESS){
         DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
         Application->MessageBoxA((char*)szErrMsg,"Driver Message");
         DRV_DeviceClose((LONG far *)&lDriverHandle);
         return;
    }

    ptCounterEventStart.counter = usChannel;
    ErrCde = DRV_CounterEventStart(lDriverHandle,(LPT_CounterEventStart)&ptCounterEventStart);
    if(ErrCde != SUCCESS){
         DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
         Application->MessageBoxA((char*)szErrMsg,"Driver Message");
         DRV_DeviceClose((LONG far *)&lDriverHandle);
         return;
    }

    //enable event
    if(0 == rdgTCInt->ItemIndex){
        ptEnableEvent.Enabled = True;
        ptEnableEvent.Count = 1;
        switch(usChannel){
            case 0: ptEnableEvent.EventType = ADS_EVT_TERMINATE_CNT0;break;
            case 1: ptEnableEvent.EventType = ADS_EVT_TERMINATE_CNT1;break;
            case 2: ptEnableEvent.EventType = ADS_EVT_TERMINATE_CNT2;break;
            case 3: ptEnableEvent.EventType = ADS_EVT_TERMINATE_CNT3;break;
            case 4: ptEnableEvent.EventType = ADS_EVT_TERMINATE_CNT4;break;
            case 5: ptEnableEvent.EventType = ADS_EVT_TERMINATE_CNT5;break;
            case 6: ptEnableEvent.EventType = ADS_EVT_TERMINATE_CNT6;break;
            case 7: ptEnableEvent.EventType = ADS_EVT_TERMINATE_CNT7;break;
        }
        ErrCde = DRV_EnableEvent(lDriverHandle,(LPT_EnableEvent)&ptEnableEvent);
        if(ErrCde != SUCCESS){
         DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
         Application->MessageBoxA((char*)szErrMsg,"Driver Message");
         DRV_DeviceClose((LONG far *)&lDriverHandle);
         return;
        }
        //start thread
        EventThread = new TEventThread(False, lDriverHandle);
    }
    ReadTimer->Enabled = True;
    btnStart->Enabled = False;
    grpChannel->Enabled = False;
    grpCntMode->Enabled = False;
    grpCntSrc->Enabled = False;
    grpDeviceSelection->Enabled = False;
    if(True == bGateEnable){
        grpGateMode->Enabled = False;
    }
    grpIniVal->Enabled = False;
    rdgCntDir->Enabled = False;
    rdgCountEdg->Enabled = False;
    if(0 == rdgOPCrtl->ItemIndex){
        cmbOutputMode->Enabled = False;
    }
    rdgOPCrtl->Enabled = False;
    rdgTCInt->Enabled = False;
    btnStop->Enabled = True;

}
//---------------------------------------------------------------------------
void __fastcall TForm1::ReadTimerTimer(TObject *Sender)
{
        PT_CounterEventRead  ptCounterEventRead;
	USHORT gwOverflow;
	USHORT gdwReading;
        ptCounterEventRead.counter = usChannel;
	ptCounterEventRead.overflow = (USHORT far *)&gwOverflow;
	ptCounterEventRead.count = (ULONG far *)&gdwReading;
        ErrCde = DRV_CounterEventRead(lDriverHandle,(LPT_CounterEventRead)&ptCounterEventRead);
        if(ErrCde != SUCCESS){
         DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
         Application->MessageBoxA((char*)szErrMsg,"Driver Message");
         btnStopClick(Sender);
         return;
        }
        stResult->Caption = AnsiString(gdwReading);

}
//---------------------------------------------------------------------------
void __fastcall TForm1::btnStopClick(TObject *Sender)
{
    ReadTimer->Enabled = False;

    if(0 == rdgTCInt->ItemIndex){
    //stop thread
        EventThread->Terminate();
        EventThread->WaitFor();

     //stop event
        ptEnableEvent.Enabled = False;
        ptEnableEvent.Count = 1;
        ErrCde = DRV_EnableEvent(lDriverHandle,(LPT_EnableEvent)&ptEnableEvent);

        if(ErrCde != SUCCESS){
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            Application->MessageBoxA((char*)szErrMsg,"Driver Message");
        }
     }
    //reset counter
    ErrCde = DRV_CounterReset(lDriverHandle,(LPARAM)usChannel);
    if(ErrCde != SUCCESS){
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            Application->MessageBoxA((char*)szErrMsg,"Driver Message");
    }
    //close device
    DRV_DeviceClose(&lDriverHandle);
    bRun = False;

    btnStart->Enabled = True;
    grpChannel->Enabled = True;
    grpCntMode->Enabled = True;
    grpCntSrc->Enabled = True;
    grpDeviceSelection->Enabled = True;
    if(True == bGateEnable){
        grpGateMode->Enabled = True;
    }
    grpIniVal->Enabled = True;
    rdgCntDir->Enabled = True;
    rdgCountEdg->Enabled = True;
    if(0 == rdgOPCrtl->ItemIndex){
        cmbOutputMode->Enabled = True;
    }
    rdgOPCrtl->Enabled = True;
    rdgTCInt->Enabled = True;
    btnStop->Enabled = False;


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

void __fastcall TForm1::cmbCntModeChange(TObject *Sender)
{
    if((cmbCntMode->ItemIndex!=0) && (cmbCntMode->ItemIndex!=3) &&(cmbCntMode->ItemIndex!=6) && (cmbCntMode->ItemIndex!=9)){
        grpGateMode->Enabled = True;
    }else{
        grpGateMode->Enabled = False;
    }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::rdgOPCrtlClick(TObject *Sender)
{
    if(0 == rdgOPCrtl->ItemIndex){
        cmbOutputMode->Enabled = True;
    }else{
        cmbOutputMode->Enabled = False;
    }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
    if(True == bRun){
        btnStopClick(Sender);
    }
}
//---------------------------------------------------------------------------