adint.c

Advantech Driver Demo: Interrupt Data Transfer

/*
 **************************************************************************
 *  Program     : ADINT.C                                                 *
 *  Description : Demo program for Windows NT with interrupt data transfer*
 *  Revision    : 1.00                                                    *
 *  Date        : 10/15/1997                   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
 *
 *   ShowDataDlgProc() - Process the dialog box messages for acquired data
 *
 *   DisplayDlgProc() - Process the dialog box messages for display range
 *
 *   ConfigDlgProc() - Process the dialog box messages for configuration
 *
 *   GainListDlgProc() - Process the dialog box messages for gain list
 */


#include <windows.h>              /* required for all Windows applications */
#include <stdlib.h>
#include <windowsx.h>
#include <commdlg.h>
#include <dos.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include "..\..\..\include\driver.h"
#include "..\..\..\include\os.h"
#include "resource.h"
#include "adint.h"

// ------------------------------------------------------------------------
// CONSTANT DEFINITION
// ------------------------------------------------------------------------
#define     MAX_DEVICES     100

// ------------------------------------------------------------------------
// GLOBAL VARIABLES
// ------------------------------------------------------------------------
HANDLE      hInst;                      // current instance
HWND        hWnd;                       // main window handle

static      DEVFEATURES        DevFeatures;       // structure for device features
static      PT_FAIIntStart     ptFAIIntStart;     // FAIIntStart table
static      PT_FAITransfer     ptFAITransfer;     // FAITransfer table
static      PT_FAICheck        ptFAICheck;        // FAICheck table
static      PT_DeviceGetFeatures  ptDevFeatures;  // Devfeatures table

static      PT_EnableEvent     ptEnableEvent;     // Enable event
static      PT_CheckEvent      ptCheckEvent;      // Check event
HANDLE      hEvent;
HANDLE      hThreadHandle;
DWORD       dwThreadID;

char        szErrMsg[80];               // Use for MESSAGEBOX function
char        szBuffer[40];               // Temperatory buffer
LRESULT     ErrCde;                     // Return error code

//
// used for fixed memory for the installed devices
//

DEVLIST     DeviceList[MAX_DEVICES];
DEVLIST     SubDeviceList[MAX_DEVICES];

BOOL        bRun = FALSE;                       // flag for running
USHORT      gwScanTime = 1000;                  // scan time
DWORD       gdwStartTime;                       // start time
DWORD       gdwElapseTime = 0;                  // elapse time
USHORT      gwOverrunCount = 0;                 // overrun count

static  USHORT gwGain[16] = {0,0,0,0,0,0,0,0,
                             0,0,0,0,0,0,0,0};
static  USHORT gwGainCode;
static  ULONG  dwDeviceNum;                       // Device number

static  LONG   DriverHandle = (LONG)NULL;         // driver handle
static  USHORT gwDevice = 0, gwSubDevice = 0;     // device index
static  SHORT  gnNumOfDevices, gnNumOfSubdevices; // number of installed devices
static  DWORD  gdwPacerRate = 100;                // pacer rate
static  ULONG  gulConvNum = 100;                  // conversion number
static  USHORT gwStartChl = 0, gwStopChl = 0;     // scan channels
static  USHORT gwDataType = 1;                    // display type : FLOAT(1)
static  USHORT gwEvtFlag = 1;                     // event enable(0)
static  USHORT gwFifoEnable = 0;                  // Fifo disable(0)

static  USHORT gwGainList = 0;      // gain list flag
static  ULONG  gdwStartPt = 0, gdwStopPt = 99;   // display points
static  USHORT gwExtTrig = 0;       // external or internal trigger

static  USHORT gwCyclicMode = 0;    // cyclic or non-cyclic mode
static  USHORT gwBufferMode = 0;    // buffer: single or double
static  USHORT gwIntrCount = 1;
static  USHORT gwCyclicCount= 0;    // number of cyclic count

static  USHORT gwActiveBuf = 0;     // return by FAICheck
static  USHORT gwOverrun   = 0;     // return by FAICheck, FAITransfer
static  USHORT gwStopped   = 0;     // return by FAICheck
static  ULONG gulRetrieved = 0;     // return by FAICheck
static  USHORT gwHalfReady = 0;     // return by FAICheck

HGLOBAL hBuf, hUserBuf;

BOOL InitApplication(HANDLE hInstance);
BOOL InitInstance(HANDLE hInstance, int nCmdShow);
long FTYPE MainWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
int  FTYPE WinMain(HANDLE hInstance, HANDLE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow);
static FARPROC lpfnConfigDlgProc, lpfnShowDataDlgProc, lpfnDisplayDlgProc,
    lpfnGainListDlgProc;

static  HWND hwndStopButton, hwndStatusButton;
static  HANDLE  hInstance ;
HMENU hMenu;

void UserThread();
void adInterruptEvent();
void adBufChangeEvent();
void adOverrunEvent();
void adTerminateEvent();

/***************************************************************************
    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(NULL, IDI_APPLICATION);
    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 : Interrupt Data Transfer" ,
        /* 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: GainListDlgProc(HWND, unsigned, WPARAM, LPARAM)

    PURPOSE:  Processes dialog box messages for gain list
****************************************************************************/

BOOL FTYPE GainListDlgProc(hDlg, message, wParam, lParam)
HWND hDlg;                                /* window handle                 */
unsigned message;                         /* type of message               */
WPARAM wParam;                            /* additional information        */
LPARAM lParam;                            /* additional information        */
{
    USHORT i, j, temp;

    switch (message)
    {
    case WM_INITDIALOG :

        // ------------------------------------------------------------
        // Initialize Input Range List Combobox, it needs to get device
        // features for gain list
        // ------------------------------------------------------------

        // Step 1: Open Device
        ErrCde = DRV_DeviceOpen(dwDeviceNum,
                (LONG far *)&DriverHandle);
        if (ErrCde != SUCCESS)
        {
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
            return 0;
        }

        // Step 2: Get device features
        ptDevFeatures.buffer = (LPDEVFEATURES)&DevFeatures;
        ptDevFeatures.size = sizeof(DEVFEATURES);
        if ((ErrCde = DRV_DeviceGetFeatures(DriverHandle,
            (LPT_DeviceGetFeatures)&ptDevFeatures)) != SUCCESS)
        {
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
            DRV_DeviceClose((LONG far *)&DriverHandle);
            return 0;
        }

        // Step 3: Initialize Input Range List Combobox with device features
        for (i = 0; i < 16; i ++)
            EnableWindow(GetDlgItem(hDlg, IDC_CHL0 + i), FALSE);

        if (DevFeatures.usNumGain != 0)
        {
            for(i = (USHORT)gwStartChl; i <= (USHORT)gwStopChl; i ++)
            {
                EnableWindow(GetDlgItem(hDlg, IDC_CHL0 + i), TRUE);
                for(j = 0; j < (USHORT)DevFeatures.usNumGain; j ++)
                    SendDlgItemMessage(hDlg, IDC_CHL0+i, CB_ADDSTRING, 0,
                    (LPARAM)((LPSTR)(DevFeatures.glGainList[j].szGainStr)));

                temp = gwGain[i];

                SendDlgItemMessage(hDlg, IDC_CHL0+i,
                    CB_SELECTSTRING, (WPARAM)(-1),
                    (LPARAM)((LPSTR)(DevFeatures.glGainList[temp].szGainStr)));
            }
        }

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

        return TRUE;

    case WM_COMMAND :
        switch (LOWORD(wParam))
        {
        case IDOK :
        case IDCANCEL :
            EndDialog(hDlg, 0);
            return TRUE;

        case IDC_CHL0 :
        case IDC_CHL1 :
        case IDC_CHL2 :
        case IDC_CHL3 :
        case IDC_CHL4 :
        case IDC_CHL5 :
        case IDC_CHL6 :
        case IDC_CHL7 :
        case IDC_CHL8 :
        case IDC_CHL9 :
        case IDC_CHL10 :
        case IDC_CHL11 :
        case IDC_CHL12 :
        case IDC_CHL13 :
        case IDC_CHL14 :
        case IDC_CHL15 :
            if (HIWORD(wParam) == CBN_KILLFOCUS)
            {