qcounter.c

QCOUNTER,用来测试所安装板卡的事件发生总量。可重复加载

/*
 ***********************************************************************
 *  Program     : QCOUNTER.C                                           *
 *  Description : Demo program for QCounter function                   *
 *  Revision    : 1.00                                                 *
 *  Date        : 9/5/1996                     Advantech Co., Ltd.     *
 ***********************************************************************
 *
 * FUNCTIONS:
 *
 *   InitApplication() - Initializes window data and registers window class
 *
 *   InitInstance() - Saves instance handle and creates main window
 *
 *   MainWndProc() - Process main window messages
 *
 *   ConfigDlgProc() - Process the dialog box messages for configuration
 */

#include <windows.h>
#include <stdlib.h>
#include <dos.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include "..\..\..\include\driver.h"
#include "..\..\..\include\os.h"
#include "resource.h"

HANDLE hInst;                      /* Current instance    */
HWND   hWnd;

char      szErrMsg[80];             /* Use for MESSAGEBOX function        */
LRESULT   ErrCde;                   /* Return error code                  */

static  int  wDriver = 0;           /* Driver index                      */
static  int  wChannel = 0;          /* Input channel                     */
static  USHORT usOverflow  = 0;     /* counter over 32 bit flag          */
static  ULONG  ulLoCount   = 0;     /* low byte of counter               */
static  ULONG  ulHiCount   = 0;     /* high byte of counter              */
static  USHORT usStart = 0;			/* Start counter flag				 */
static  LONG DriverHandle = (LONG)NULL;   /* Driver Handle                     */
static  USHORT usResetAfterLatch = 0; /* Reset after latch flag          */
static  USHORT usFreeRun = 0;         /* Free run flag                   */
static  USHORT usResetValue = 0;      /* Reset Value                     */
static  USHORT usLatchSource = 0;     /* Latch source flag               */
static  USHORT usInputMode = 0;       /* Input mode flag                 */
static int szBuf[20];                 /* temp buffer */
static int szBuf1[20];                /* temp buffer */

static char *szInputMode[] = {"DISABLE    ",
                              "AB PHASE X1",
                              "AB PHASE X2",
                              "AB PHASE X4",
                              " 2 PULSE IN",
                              " 1 PULSE IN"};

static char *szLatchSource[] = {"S/W LATCH  ",
                                "ZIN LATCH  ",
                                "DI0 LATCH  ",
                                "DI1 LATCH  ",
                                "TIMER LATCH"};

BOOL InitApplication(HANDLE hInstance);
BOOL InitInstance(HANDLE hInstance, int nCmdShow);
long FTYPE MainWndProc(HWND, UINT, WPARAM, LPARAM);
int  FTYPE WinMain(HANDLE hInstance, HANDLE hPrevInstance,
     LPSTR lpCmdLine, int nCmdShow);
static  FARPROC lpfnConfigDlgProc;

/***************************************************************************
    FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

    PURPOSE: calls initialization function, processes message loop
****************************************************************************/

int FTYPE WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
HANDLE hInstance;                          /* current instance             */
HANDLE hPrevInstance;                      /* previous instance            */
LPSTR lpCmdLine;                           /* command line                 */
int nCmdShow;                              /* show-window type (open/icon) */
{
    MSG msg;                               /* message                      */

    if (!hPrevInstance)                /* Other instances of app running?  */
      if (!InitApplication(hInstance)) /* Initialize shared things         */
          return (FALSE);              /* Exits if unable to initialize    */

    // Perform initializations that apply to a specific instance
    if (!InitInstance(hInstance, nCmdShow))
        return (FALSE);

    // Acquire and dispatch messages until a WM_QUIT message is received.
    while (GetMessage(&msg,      /* message structure                      */
        (HWND)NULL,              /* handle of window receiving the message */
        (UINT)NULL,              /* lowest message to examine              */
        (UINT)NULL))             /* highest message to examine             */
    {
        TranslateMessage(&msg);  /* Translates virtual key codes           */
        DispatchMessage(&msg);   /* Dispatches message to window           */
    }
    return (msg.wParam);         /* Returns the value from PostQuitMessage */
}

/****************************************************************************
    FUNCTION: InitApplication(HANDLE)

    PURPOSE: Initializes window data and registers window class
****************************************************************************/

BOOL InitApplication(hInstance)
HANDLE hInstance;                            /* current instance           */
{
    WNDCLASS  wc;

    // Fill in window class structure with parameters that describe the
    // main window.
    wc.style = CS_HREDRAW | CS_VREDRAW; /* Class style(s).                 */
    wc.lpfnWndProc = (WNDPROC)MainWndProc;   /* window process procedure   */
    wc.cbClsExtra = 0;                  /* No per-class extra data.        */
    wc.cbWndExtra = 0;                  /* No per-window extra data.       */
    wc.hInstance = hInstance;           /* Application that owns the class.*/
    wc.hIcon = LoadIcon(hInstance, "IDI_ICON1");
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName =  "MyMenu";   /* Name of menu resource in .RC file.  */
    wc.lpszClassName = "MyClass";  /* Name used in call to CreateWindow. */

    // Register the window class and return success/failure code.
    return (RegisterClass(&wc));

}

/***************************************************************************
    FUNCTION:  InitInstance(HANDLE, int)

    PURPOSE:  Saves instance handle and creates main window
****************************************************************************/

BOOL InitInstance(hInstance, nCmdShow)
HANDLE          hInstance;          /* Current instance identifier.          */
int             nCmdShow;           /* Param for first ShowWindow() call.    */
{

    // Save the instance handle in static variable, which will be used in
    // many subsequence calls from this application to Windows.
    hInst = hInstance;

    // Create a main window for this application instance.
    hWnd = CreateWindow(
        "MyClass",                  /* See RegisterClass() call.           */
        "Advantech Driver Demo : 3-Axis Quadrature Encoder" ,     /* Window title bar  */
        WS_OVERLAPPEDWINDOW,        /* Window style.                       */
        CW_USEDEFAULT,              /* Default horizontal position.        */
        CW_USEDEFAULT,              /* Default vertical position.          */
        CW_USEDEFAULT,              /* Default width.                      */
        CW_USEDEFAULT,              /* Default height.                     */
        NULL,                       /* Overlapped windows have no parent.  */
        NULL,                       /* Use the window class menu.          */
        hInstance,                  /* This instance owns this window.     */
        NULL                        /* Pointer not needed.                 */
        );

    // If window could not be created, return "failure"
    if (!hWnd)
        return (FALSE);

    // Make the window visible; update its client area; and return "success"

    ShowWindow(hWnd, nCmdShow);   /* Show the window                       */
    UpdateWindow(hWnd);           /* Sends WM_PAINT message                */
    return (TRUE);                /* Returns the value from PostQuitMessage*/
}

/***************************************************************************
    FUNCTION: ConfigDlgProc(HWND, unsigned, WPARAM, LPARAM)

    PURPOSE:  Processes dialog box messages for configuration
****************************************************************************/

BOOL FTYPE ConfigDlgProc(HWND hDlg, unsigned message, WPARAM wParam, LPARAM lParam)
{
    char szBuffer[40];
    USHORT usCheck;

    switch (message)
    {
        case WM_INITDIALOG :

            // if usStart !=0  then do close driver
			if (usStart != 0)
			{
               if( (ErrCde = DRV_DeviceClose((LONG far *)&DriverHandle)) != 0)
               {
                  DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                  MessageBox(hWnd,(LPCSTR)szErrMsg, "Driver Message", MB_OK);
                  return TRUE;
               }
			}

			 // Initialize Start counter
			 usStart = 0;

             // Initialize Driver Number
             itoa(wDriver, szBuffer, 10);
             SendDlgItemMessage(hDlg, IDC_DEVNUMBER, EM_REPLACESEL, 0,
                             (LPARAM)((LPSTR)szBuffer));

             // Initialize Input Channel
             itoa(wChannel, szBuffer, 10);
             SendDlgItemMessage(hDlg, IDC_ECHANNEL, EM_REPLACESEL, 0,
                             (LPARAM)((LPSTR)szBuffer));

             // Create string list for Input Mode Reference ComoBox
             SendDlgItemMessage(hDlg,IDC_INPUTMODE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szInputMode[0]));
             SendDlgItemMessage(hDlg,IDC_INPUTMODE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szInputMode[1]));
             SendDlgItemMessage(hDlg,IDC_INPUTMODE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szInputMode[2]));
             SendDlgItemMessage(hDlg,IDC_INPUTMODE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szInputMode[3]));
             SendDlgItemMessage(hDlg,IDC_INPUTMODE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szInputMode[4]));
             SendDlgItemMessage(hDlg,IDC_INPUTMODE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szInputMode[5]));

             // Create string list for Latch Source Reference ComoBox
             SendDlgItemMessage(hDlg,IDC_LATCHSOURCE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szLatchSource[0]));
             SendDlgItemMessage(hDlg,IDC_LATCHSOURCE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szLatchSource[1]));
             SendDlgItemMessage(hDlg,IDC_LATCHSOURCE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szLatchSource[2]));
             SendDlgItemMessage(hDlg,IDC_LATCHSOURCE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szLatchSource[3]));
             SendDlgItemMessage(hDlg,IDC_LATCHSOURCE,CB_ADDSTRING,0,(LPARAM)((LPCSTR)szLatchSource[4]));

             if (usResetAfterLatch == 0)
                SendDlgItemMessage(hDlg,IDC_CHECKRESET,BM_SETCHECK,0,0);