adint.c

这是一个研华数据采集的源代码,可以利用此码实现工业控制和数据处理.

                GlobalFree(hUserBuf);
                DRV_DeviceClose((LONG far *)&DriverHandle);
                return 0;
            }

            gwCyclicCount = 0;

            // if event feature is enabled , then create one thread.
            if (gwEvtFlag)
            {
                hThreadHandle = CreateThread(0, 0,
                    (LPTHREAD_START_ROUTINE) UserThread,
                    0, 0, (LPDWORD)&dwThreadID);
            }

           	EnableMenuItem(hMenu, IDM_RUN, MF_DISABLED | MF_BYCOMMAND);

            // Enable stop and status buttons
            EnableWindow(hwndStopButton, TRUE);
            EnableWindow(hwndStatusButton, TRUE);

            Sleep(0);

            return 0;

            // end IDM_RUN

        case IDC_STOPBUTTON:

            // Close thread
            bThreadStatus = GetExitCodeThread(hThreadHandle, &dwExitCode);
            if ((dwExitCode== (DWORD)STILL_ACTIVE) && (bThreadStatus))
            {
                TerminateThread(hThreadHandle, 0);
                CloseHandle(hThreadHandle);
                CloseHandle(hEvent);
                Sleep(0);
            }

            // Disable stop and status buttons
            EnableWindow(hwndStopButton, FALSE);
            EnableWindow(hwndStatusButton, FALSE);

            // Step 1: Stop A/D conversion for high speed
            if ((ErrCde = DRV_FAIStop(DriverHandle)) != 0)
            {
                DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                GlobalUnlock(hBuf);
                GlobalUnlock(hUserBuf);
                GlobalFree(hBuf);
                GlobalFree(hUserBuf);
                DRV_DeviceClose((LONG far *)&DriverHandle);
                return 0;
            }

            // Step 2: Get real voltage of Buffer from driver memory buffer
            ptFAITransfer.ActiveBuf = 0;   // single buffer
            ptFAITransfer.DataType = gwDataType;
            ptFAITransfer.start    = 0;
            ptFAITransfer.count    = gulConvNum;
            ptFAITransfer.overrun  = &gwOverrun;

            if ((ErrCde = DRV_FAITransfer(DriverHandle,
                (LPT_FAITransfer)&ptFAITransfer)) != 0)
            {
                DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                GlobalUnlock(hBuf);
                GlobalUnlock(hUserBuf);
                GlobalFree(hBuf);
                GlobalFree(hUserBuf);
                DRV_DeviceClose((LONG far *)&DriverHandle);
                return 0;
            }

            // Display data
            DialogBox (hInstance, MAKEINTRESOURCE(IDD_DATA),
                hWnd, lpfnShowDataDlgProc) ;

            // Step 3: Free buffer
            GlobalUnlock(hBuf);
            GlobalUnlock(hUserBuf);
            GlobalFree(hBuf);
            GlobalFree(hUserBuf);

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

            EnableMenuItem(hMenu, IDM_RUN, MF_ENABLED | MF_BYCOMMAND);

            return 0;

        case IDC_STATUSBUTTON:

            // Get Interrupt transfer status
            ptFAICheck.ActiveBuf = &gwActiveBuf;
            ptFAICheck.stopped   = &gwStopped;
            ptFAICheck.retrieved = &gulRetrieved;
            ptFAICheck.overrun   = &gwOverrun;
            ptFAICheck.HalfReady = &gwHalfReady;

            if ((ErrCde = DRV_FAICheck(DriverHandle,
                (LPT_FAICheck)&ptFAICheck)) != 0)
            {
                DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                GlobalUnlock(hBuf);
                GlobalUnlock(hUserBuf);
                GlobalFree(hBuf);
                GlobalFree(hUserBuf);
                DRV_DeviceClose((LONG far *)&DriverHandle);
                return 0;
            }
            else
            {   // Display the status of the A/D conversion
                sprintf(szDest, "Cyclic Counts: %d\n", gwCyclicCount);
                if (gwHalfReady == 0)
                    strcpy(szTemp, "Buffer : not  ready\n");
                else if (gwHalfReady == 1)
                    strcpy(szTemp, "Buffer : half ready\n");
                else if (gwHalfReady == 2)
                    strcpy(szTemp, "Buffer : full ready\n");
                else
                    strcpy(szTemp, "Buffer : unknow \n");
                strcat(szDest, szTemp);
                ratio = 100.0 * gulRetrieved / gulConvNum;
                szStr = fcvt((double)ratio, 0, &dec, &sign);
                strcat(szDest, "Finish:  ");
                strcat(szDest, szStr);
                strcat(szDest, "%...");
                MessageBox(hWnd,(LPCSTR)szDest, "Check Status", MB_OK);
            }

            return 0;
        }

    case WM_DESTROY:

        PostQuitMessage(0);
        break;

    default:
        return (DefWindowProc(hWnd, message, wParam, lParam));
    }

    return ((LONG)NULL);
}

//------------------------------------------------------------------
void UserThread()
{
    USHORT usEventType;
    LONG  ErrCde;
    DWORD TickValue;
    ULONG gulIntCounter = 0;
    ULONG gulBfChgCounter = 0;
    ULONG gulOverrunCounter = 0;
	char szCounter[80];
	HDC hdc;
	
    TickValue = GetTickCount();
    TickValue = TickValue + 500000;
    hdc = GetDC( hWnd );
    InvalidateRect( hWnd, NULL, TRUE );
    UpdateWindow( hWnd );
	
    while(TickValue > GetTickCount())
    {
        // Check message
        ptCheckEvent.EventType = &usEventType;
        //ptCheckEvent.Milliseconds = 5000;

		//
		// Shengkui modified, 2004/02/01
		// if external trigger source enabled, set the 
		// timeout interval to INFINITE
		if ( (gwExtTrig) || (gwCyclicMode) )
		{
           ptCheckEvent.Milliseconds = INFINITE;
		}
		else
		{
           ptCheckEvent.Milliseconds = 1000 * (gulConvNum / gdwPacerRate) + 1000;
		}

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

        // Process interrupt event
        if (usEventType & ADS_EVT_INTERRUPT)
		{
			gulIntCounter++;
            adInterruptEvent();
		}

        // Process buffer change event
        if (usEventType & ADS_EVT_BUFCHANGE)
		{
			gulBfChgCounter++;
            adBufChangeEvent();
		}

        // Process overrun event
        if (usEventType & ADS_EVT_OVERRUN)
		{
			gulOverrunCounter++;
            adOverrunEvent();
		}

        // Process terminate event
        if (usEventType & ADS_EVT_TERMINATED)
        {
            adTerminateEvent();
            return ;
        }
		sprintf( szCounter, "Interrupt Counter = %4d\n", gulIntCounter );
		TextOut( hdc, 300, 50, szCounter, 24 );  
		sprintf( szCounter, "Buffer change Counter = %4d\n", gulBfChgCounter );
		TextOut( hdc, 300, 70, szCounter, 28 );
		sprintf( szCounter, "Overrun Counter = %4d\n", gulOverrunCounter );
		TextOut( hdc, 300, 90, szCounter, 22 );
		UpdateWindow( hWnd );
    }
	ReleaseDC( hWnd, hdc );
	
	
    MessageBox(hWnd,"Never Get Any Event !","Thread Message",MB_OK);
}

//------------------------------------------------------------------
void adInterruptEvent()
{
    return;
}

//------------------------------------------------------------------
void adBufChangeEvent()
{
    ptFAICheck.ActiveBuf = &gwActiveBuf;
    ptFAICheck.stopped   = &gwStopped;
    ptFAICheck.retrieved = &gulRetrieved;
    ptFAICheck.overrun   = &gwOverrun;
    ptFAICheck.HalfReady = &gwHalfReady;

    if ((ErrCde = DRV_FAICheck(DriverHandle,
         (LPT_FAICheck)&ptFAICheck)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
        return ;
    }

    if (gwHalfReady == 1)  // first ready
    {
        ptFAITransfer.ActiveBuf = 0;   // single buffer
        ptFAITransfer.DataType = gwDataType;
        ptFAITransfer.start    = 0;
        ptFAITransfer.count    = gulConvNum/2;
        ptFAITransfer.overrun  = &gwOverrun;

        if ((ErrCde = DRV_FAITransfer(DriverHandle,
            (LPT_FAITransfer)&ptFAITransfer)) != 0)
        {
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
            return ;
        }
    }
    else if (gwHalfReady == 2) // second half ready
    {
        ptFAITransfer.ActiveBuf = 0;   // single buffer
        ptFAITransfer.DataType = gwDataType;
        ptFAITransfer.start    = gulConvNum/2;
        ptFAITransfer.count    = gulConvNum/2;
        ptFAITransfer.overrun  = &gwOverrun;

        if ((ErrCde = DRV_FAITransfer(DriverHandle,
            (LPT_FAITransfer)&ptFAITransfer)) != 0)
        {
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
            return ;
        }

        gwCyclicCount ++;
    }

    return;
}
//------------------------------------------------------------------
void adOverrunEvent()
{
    // clear overrun
    if ((ErrCde = DRV_ClearOverrun(DriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
        return ;
    }

    return;
}
//------------------------------------------------------------------
void adTerminateEvent()
{
    // Disable stop and status buttons
    EnableWindow(hwndStopButton, FALSE);
    EnableWindow(hwndStatusButton, FALSE);

    // Stop A/D conversion
    if ((ErrCde = DRV_FAIStop(DriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
        return ;
    }

    // Get real voltage of buffer from driver
    ptFAITransfer.ActiveBuf = 0;   // single buffer
    ptFAITransfer.DataType = gwDataType;
    ptFAITransfer.start    = 0;
    ptFAITransfer.count    = gulConvNum;
    ptFAITransfer.overrun  = &gwOverrun;

    if ((ErrCde = DRV_FAITransfer(DriverHandle,
        (LPT_FAITransfer)&ptFAITransfer)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
        return ;
    }

    // Display data
    DialogBox (hInstance, MAKEINTRESOURCE(IDD_DATA),
        hWnd, lpfnShowDataDlgProc) ;

    // Free buffer
    GlobalUnlock(hBuf);
    GlobalUnlock(hUserBuf);
    GlobalFree(hBuf);
    GlobalFree(hUserBuf);

    // Close driver
    DRV_DeviceClose((LONG far *)&DriverHandle);

    EnableMenuItem(hMenu, IDM_RUN, MF_ENABLED | MF_BYCOMMAND);

    return;
}