mainform.cpp

来自「16 relay output channels and 16 isolated」· C++ 代码 · 共 657 行 · 第 1/2 页

    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox(szErrMsg,"Driver Message",MB_OK);
        GlobalUnlock(hBuf); GlobalFree(hBuf);
        GlobalUnlock(hVoltageBuf); GlobalFree(hVoltageBuf);
        GlobalUnlock(hBinaryBuf); GlobalFree(hBinaryBuf);
        DRV_FreeDMABuffer(lDriverHandle, (LPARAM)&pBuffer);
        DRV_DeviceClose((LONG far *)&lDriverHandle);
        return ;
    }


    // Step 7: Enable event feature
    ptEnableEvent.EventType = ADS_EVT_AO_INTERRUPT;
    ptEnableEvent.Enabled = gwEvtFlag;
    ptEnableEvent.Count   = 1;
    if ((ErrCde = DRV_EnableEvent(lDriverHandle,
        (LPT_EnableEvent)&ptEnableEvent)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox(szErrMsg,"Driver Message",MB_OK);
        GlobalUnlock(hBuf); GlobalFree(hBuf);
        GlobalUnlock(hVoltageBuf); GlobalFree(hVoltageBuf);
        GlobalUnlock(hBinaryBuf); GlobalFree(hBinaryBuf);
        DRV_FreeDMABuffer(lDriverHandle, (LPARAM)&pBuffer);
        DRV_DeviceClose((LONG far *)&lDriverHandle);
        return ;
    }

    ptEnableEvent.EventType = ADS_EVT_AO_BUFCHANGE;
     if ((ErrCde = DRV_EnableEvent(lDriverHandle,
        (LPT_EnableEvent)&ptEnableEvent)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox(szErrMsg,"Driver Message",MB_OK);
        GlobalUnlock(hBuf); GlobalFree(hBuf);
        GlobalUnlock(hVoltageBuf); GlobalFree(hVoltageBuf);
        GlobalUnlock(hBinaryBuf); GlobalFree(hBinaryBuf);
        DRV_FreeDMABuffer(lDriverHandle, (LPARAM)&pBuffer);
        DRV_DeviceClose((LONG far *)&lDriverHandle);
        return ;
    }

    ptEnableEvent.EventType = ADS_EVT_AO_TERMINATED;
    if ((ErrCde = DRV_EnableEvent(lDriverHandle,
        (LPT_EnableEvent)&ptEnableEvent)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox(szErrMsg,"Driver Message",MB_OK);
        GlobalUnlock(hBuf); GlobalFree(hBuf);
        GlobalUnlock(hVoltageBuf); GlobalFree(hVoltageBuf);
        GlobalUnlock(hBinaryBuf); GlobalFree(hBinaryBuf);
        DRV_FreeDMABuffer(lDriverHandle, (LPARAM)&pBuffer);
        DRV_DeviceClose((LONG far *)&lDriverHandle);
        return ;
    }
    ptEnableEvent.EventType =  ADS_EVT_AO_UNDERRUN;
         if ((ErrCde = DRV_EnableEvent(lDriverHandle,
        (LPT_EnableEvent)&ptEnableEvent)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox(szErrMsg,"Driver Message",MB_OK);
        GlobalUnlock(hBuf); GlobalFree(hBuf);
        GlobalUnlock(hVoltageBuf); GlobalFree(hVoltageBuf);
        GlobalUnlock(hBinaryBuf); GlobalFree(hBinaryBuf);
        DRV_FreeDMABuffer(lDriverHandle, (LPARAM)&pBuffer);
        DRV_DeviceClose((LONG far *)&lDriverHandle);
        return ;
    }


    // Step 8: call FAOIntStart for start action
    // Default steting - conversion number = 1000
    // start channel = 1, pacer rate = 1000 Hz
    // cyclic , enable event
    ptFAODmaStart.buffer     = (LONG far *)lpBuf;        // analog output data
    ptFAODmaStart.TrigSrc    = gwExtTrig;    // triggering
    ptFAODmaStart.SampleRate = gdwPacerRate; // pacer rate = 1K
    ptFAODmaStart.chan       = gwChannel;   // start channel
    ptFAODmaStart.count      = gulConvNum;   // DA conversion number

    if ((ErrCde = DRV_FAODmaStart(lDriverHandle,
        (LPT_FAODmaStart)&ptFAODmaStart)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox(szErrMsg,"Driver Message",MB_OK);
        GlobalUnlock(hBuf); GlobalFree(hBuf);
        GlobalUnlock(hVoltageBuf); GlobalFree(hVoltageBuf);
        GlobalUnlock(hBinaryBuf); GlobalFree(hBinaryBuf);
        DRV_FreeDMABuffer(lDriverHandle, (LPARAM)&pBuffer);
        DRV_DeviceClose((LONG far *)&lDriverHandle);
        return ;
    }

    pThread = new CheckThread(false);

    //
        frmCheck->labInterrupt->Caption="0";
        frmCheck->labBuffChange->Caption="0";
        frmCheck->labOverrun->Caption="0";
     frmCheck->ShowModal();
  //  Hide();

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


void TfrmMain::CheckEvent()
{
    //TODO: Add your source code here
    USHORT usEventType;
    gulIntCounter = 0;
    gulBfChgCounter = 0;
    gulOverrunCounter = 0;


    while(bThreadloop)
    {
        // Check message
        ptCheckEvent.EventType = &usEventType;
        ptCheckEvent.Milliseconds = INFINITE;

        if ((ErrCde = DRV_CheckEvent(lDriverHandle,
            (LPT_CheckEvent)&ptCheckEvent)) != 0)
        {
            Application->MessageBox("Check Event Error !","Thread Message",MB_OK);
            return ;
        }

        // Process interrupt event
        if (usEventType == ADS_EVT_AO_INTERRUPT)
            InterruptEvent();

        // Process buffer change event
        if (usEventType == ADS_EVT_AO_BUFCHANGE)
            BufChangeEvent();

        // Process overrun event
        if (usEventType == ADS_EVT_AO_UNDERRUN)
            OverrunEvent();

        // Process terminate event
        if (usEventType == ADS_EVT_AO_TERMINATED)
            TerminateEvent();

        frmCheck->labInterrupt->Caption=IntToStr(gulIntCounter);
        frmCheck->labBuffChange->Caption=IntToStr(gulBfChgCounter);
        frmCheck->labOverrun->Caption=IntToStr(gulOverrunCounter);
    }

}


void TfrmMain::InterruptEvent()
{
   //TODO: Add your source code here
   gulIntCounter++;



}

void TfrmMain::BufChangeEvent()
{
    //TODO: Add your source code here
    USHORT usWaveIndex;
    LPSWAVE lpWave;
    gulBfChgCounter++;

    usWaveIndex = (gwRepeatCount + 1) % 3;
    switch (usWaveIndex)
    {
      case 0:
          lpWave = &sWave[0];
          break;
      case 1:
          lpWave = &sWave[1];
          break;
      case 2:
          lpWave = &sWave[2];
          break;
    }

    // Step 1: get status
    ptFAOCheck.ActiveBuf    = &gwActiveBuf;
    ptFAOCheck.stopped      = &gwStopped;
    ptFAOCheck.CurrentCount = &gulRetrieved;
    ptFAOCheck.overrun      = &gwOverrun;
    ptFAOCheck.HalfReady    = &gwHalfReady;

    if ((ErrCde = DRV_FAOCheck(lDriverHandle,
         (LPT_FAOCheck)&ptFAOCheck)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox(szErrMsg,"Thread Message",MB_OK);
        return ;
    }

    // Set real voltage to first half buffer
    SetRealBuffer(lpVoltageBuf, gulConvNum/2, lpWave);

    // Step 2: call FAOScale for transfer voltage to binary data
    ptFAOScale.VoltArray = lpVoltageBuf;
    ptFAOScale.BinArray  = lpBinaryBuf;
    ptFAOScale.chan      = gwChannel;
    ptFAOScale.count     = gulConvNum/2;
    if ((ErrCde = DRV_FAOScale(lDriverHandle,
        (LPT_FAOScale)&ptFAOScale)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox(szErrMsg,"Thread Message",MB_OK);
        return ;
    }

    if (gwHalfReady == 2) // second half ready
    {
        // Step 3: call FAOLoad to pass data to driver
    //  ptFAOLoad.ActiveBuf  = 0;  // single buffer
    //  ptFAOLoad.DataBuffer = lpBinaryBuf;
    //  ptFAOLoad.start    = 0;
    //  ptFAOLoad.count    = gulConvNum;

    //  if ((ErrCde = DRV_FAOLoad(DriverHandle,
    //      (LPT_FAOLoad)&ptFAOLoad)) != 0)
    //  {
    //      DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
    //      MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
    //      return ;
    //  }

        gwRepeatCount ++;
    }

    return;
}

void TfrmMain::OverrunEvent()
{
        //TODO: Add your source code here
    gulOverrunCounter++;
    DRV_ClearOverrun(  lDriverHandle );
}

void TfrmMain::TerminateEvent()
{
        //TODO: Add your source code here
    // frmCheck->StopClick(NULL) ; l
    //    StopEvent();
    bThreadloop = FALSE;
    // Step1:  Stop D/A conversion for high speed
    if ((!gwCyclicMode) && (ErrCde = DRV_FAOTerminate(lDriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox((LPCSTR)szErrMsg,"Driver Message",MB_OK);
        GlobalUnlock(hBuf); GlobalFree(hBuf);
        GlobalUnlock(hVoltageBuf); GlobalFree(hVoltageBuf);
        GlobalUnlock(hBinaryBuf); GlobalFree(hBinaryBuf);
        DRV_FreeDMABuffer(lDriverHandle, (LPARAM)&pBuffer);
        DRV_DeviceClose((LONG far *)&lDriverHandle);
    }

    // Step 2: Free buffer
    GlobalUnlock(hBuf);
    GlobalFree(hBuf);
    GlobalUnlock(hVoltageBuf);
    GlobalFree(hVoltageBuf);
    GlobalUnlock(hBinaryBuf);
    GlobalFree(hBinaryBuf);

    DRV_FreeDMABuffer(lDriverHandle, (LPARAM)&pBuffer);

    // Step 4: Close driver
    DRV_DeviceClose((LONG far *)&lDriverHandle);

}

void TfrmMain::StopEvent()
{
/*
     //TODO: Add your source code here
     bThreadloop = FALSE;
     Sleep(500);
     pThread->Terminate();
 //    frmCheck->Show();
 //   Show();
*/
    //  Stop D/A conversion for high speed
    if ((ErrCde = DRV_FAOTerminate(lDriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox((LPCSTR)szErrMsg,"Driver Message",MB_OK);
        GlobalUnlock(hBuf); GlobalFree(hBuf);
        GlobalUnlock(hVoltageBuf); GlobalFree(hVoltageBuf);
        GlobalUnlock(hBinaryBuf); GlobalFree(hBinaryBuf);
        DRV_FreeDMABuffer(lDriverHandle, (LPARAM)&pBuffer);
        DRV_DeviceClose((LONG far *)&lDriverHandle);
    }
/*
    // Step 2: Free buffer
    GlobalUnlock(hBuf);
    GlobalFree(hBuf);
    GlobalUnlock(hVoltageBuf);
    GlobalFree(hVoltageBuf);
    GlobalUnlock(hBinaryBuf);
    GlobalFree(hBinaryBuf);

    DRV_FreeDMABuffer(lDriverHandle, (LPARAM)&pBuffer);

    // Step 4: Close driver
    DRV_DeviceClose((LONG far *)&lDriverHandle);
 */
}

//---------------------------------------------------------------------------
__fastcall CheckThread::CheckThread(bool CreateSuspended)
        : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
void __fastcall CheckThread::Execute()
{
        //---- Place thread code here ----

         frmMain->CheckEvent();


}