digout.c

这个是上面的那个的输出部分

/*
 ***********************************************************************
 *  Program     : DIGOUT.C                                             *
 *  Description : Demo program for Win16 with digital output           *
 *  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
 *
 *   CvtHex() - Convert string to hexadecimal integer
 */


#include <windows.h>              /* required for all Windows applications */
#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"

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


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


static      PT_DioWritePortByte ptDioWritePortByte; // DioWritePortByte table
static      PT_DioWriteBit      ptDioWriteBit;      // DioWriteBit table
static      PT_DioGetCurrentDOByte ptDioGetCurrentDOByte;

char        szErrMsg[80];             // used for MESSAGEBOX function
LRESULT     ErrCde;                   // return error code

//
// used for dynamic allocation memory for the installed devices
//
// static  HGLOBAL     hDeviceList,hSubDeviceList;
// static  LPDEVLIST   DeviceList,SubDeviceList;
//

//
// used for fixed memory for the installed devices
//
DEVLIST     DeviceList[MAX_DEVICES];
DEVLIST     SubDeviceList[MAX_DEVICES];

LONG        DriverHandle = (LONG)NULL;          // driver handle
USHORT      gwDevice = 0, gwSubDevice = 0;  // device index
int         gwChannel = 0;                  // output channel
USHORT      gwMask = 0xff;                  // mask
USHORT      gwData = 0xaa;                  // output data
USHORT      gwOutBit = 0;                   // output bit
USHORT      gwDoState = 0;                  // current DO state
SHORT       gnNumOfDevices, gnNumOfSubdevices;  // number of installed devices
FARPROC     lpfnConfigDlgProc;                  // config. dialog procedure
FARPROC     lpfnRunDlgProc;                 // run dialog procedure


// ------------------------------------------------------------------------
// FUNCTION DECLARATION
// ------------------------------------------------------------------------
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);
WORD CvtHex(char *str);

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

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

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

    if (!hPrevInstance)
        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
(
    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
(
    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.
    hMainWnd = CreateWindow(
        "MyClass",                  // See RegisterClass() call.
        "Advantech Driver Demo : Digital Output" ,    // 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 (!hMainWnd)
        return (FALSE);

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

    ShowWindow(hMainWnd, nCmdShow);     // Show the window
    UpdateWindow(hMainWnd);             // 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,                          // window handle
    unsigned    message,                       // type of message
    WPARAM      wParam,                        // additional information
    LPARAM      lParam                         // additional information
)
{
    int         i;
    DWORD       dwIndex;
    char        szBuffer[40];
    int         nOutEntries;

    switch (message)
    {
    case WM_INITDIALOG :
	    
        // --------------------------------
        // Initialize Device List Combobox
        // --------------------------------

        // get number of the installed devices

        if ((ErrCde = DRV_DeviceGetNumOfList((SHORT far *)&gnNumOfDevices)) !=
            SUCCESS)
        {
             DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
             MessageBox(hMainWnd,(LPCSTR)szErrMsg, "Driver Message", MB_OK);
             return TRUE;
        }


        // ----------------------------------------------------------------
        // used for dynamic allocation memory for these installed devices
        //
        // if ((hDeviceList = GlobalAlloc(GHND, gnNumOfDevices *
        //      sizeof(DEVLIST))) == NULL)
        // {
        //    MessageBox(hMainWnd, (LPCSTR)"Not Enough Memory",
        //        "Memory Allocation", MB_OK);
        //    return TRUE;
        // }
        // DeviceList = (LPDEVLIST)GlobalLock(hDeviceList);
        // ----------------------------------------------------------------


        if (gnNumOfDevices > MAX_DEVICES)
            gnNumOfDevices = MAX_DEVICES;

        // retrieve the information of all installed devices

        if ((ErrCde = DRV_DeviceGetList((DEVLIST far *)&DeviceList[0],
            (SHORT)gnNumOfDevices, (SHORT far *)&nOutEntries)) != (LONG)SUCCESS)
        {
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            MessageBox(hMainWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
            return TRUE;
        }

        // initialize the Device List Combobox with the retrieved information

        for (i = 0; i < gnNumOfDevices; i ++)
            SendDlgItemMessage(hDlg, IDC_DEVICE, CB_ADDSTRING, 0,
                        (LPARAM)((LPSTR)DeviceList[i].szDeviceName));

        SendDlgItemMessage(hDlg, IDC_DEVICE, CB_SETCURSEL,(WPARAM)gwDevice,
                        (LPARAM)0);


        // -----------------------------------------------------------
        // Initialize Module List Combobox for COM port or CAN devices
        // -----------------------------------------------------------

        // check if there is any device attached on this COM port or CAN

        gnNumOfSubdevices = DeviceList[gwDevice].nNumOfSubdevices;
        if (gnNumOfSubdevices > MAX_DEVICES)
            gnNumOfSubdevices = MAX_DEVICES;


        // --------------------------------------------------------------
        // used for dynamic allocation memory for these installed devices
        //
        // if ((hSubDeviceList = GlobalAlloc(GHND, gnNumOfSubdevices *
        //    sizeof(DEVLIST))) == NULL)
        // {
        //    MessageBox(hMainWnd, (LPCSTR)"Not Enough Memory",
        //        "Memory Allocation", MB_OK);
        //    return TRUE;
        // }
        //
        // SubDeviceList = (LPDEVLIST)GlobalLock(hSubDeviceList);
        // --------------------------------------------------------------


        // retrieve the information of all installed devices
        if (gnNumOfSubdevices != 0)
        {
            if ((ErrCde = DRV_DeviceGetSubList(
                (DWORD)DeviceList[gwDevice].dwDeviceNum,
                (DEVLIST far *)&SubDeviceList[0],
                (SHORT)gnNumOfSubdevices,
                (SHORT far *)&nOutEntries)) != (LONG)SUCCESS)
            {
                DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                MessageBox(hMainWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                return TRUE;
            }


            // initialize the Module List Combobox with the retrieved
            // information

            EnableWindow(GetDlgItem(hDlg, IDC_MODULE), TRUE);
            SendDlgItemMessage(hDlg, IDC_MODULE, CB_RESETCONTENT, 0,
                    (LPARAM)((LPSTR)0));

            for (i = 0; i < gnNumOfSubdevices; i++)
                SendDlgItemMessage(hDlg, IDC_MODULE, CB_ADDSTRING, 0,
                        (LPARAM)((LPSTR)SubDeviceList[i].szDeviceName));

            SendDlgItemMessage(hDlg, IDC_MODULE, CB_SETCURSEL,
					(WPARAM)gwSubDevice, (LPARAM)0);
        }
        else
        {
            EnableWindow(GetDlgItem(hDlg, IDC_MODULE), FALSE);
            SendDlgItemMessage(hDlg, IDC_MODULE, CB_RESETCONTENT, 0,
                    (LPARAM)((LPSTR)0));
        }


        // -----------------------------
        // Initialize Output Channel
        // -----------------------------

        itoa(gwChannel, szBuffer, 10);
        SendDlgItemMessage(hDlg, IDC_ECHANNEL, EM_REPLACESEL, 0,
                        (LPARAM)((LPSTR)szBuffer));

        // -----------------------------
        // Initialize Mask
        // -----------------------------

        ltoa((long)gwMask, szBuffer, 16);
        SendDlgItemMessage(hDlg, IDC_EMASK, EM_REPLACESEL, 0,
                        (LPARAM)((LPSTR)szBuffer));

        return TRUE;

   case WM_COMMAND :
        switch (LOWORD(wParam))
        {
           case IDOK :

              //
              // get device selection
              //

              if ((dwIndex = SendDlgItemMessage(hDlg, IDC_DEVICE,
                           CB_GETCURSEL, 0, 0)) != CB_ERR)
                   gwDevice = (WORD)dwIndex;


              //
              // get sub-device selection
              //

              if ((dwIndex = SendDlgItemMessage(hDlg, IDC_MODULE,
                           CB_GETCURSEL, 0, 0)) != CB_ERR)
                   gwSubDevice = (WORD)dwIndex;


               //
               // Get channel number
               //

               if (SendDlgItemMessage(hDlg, IDC_ECHANNEL,
                        EM_GETMODIFY, 0, 0))
               {
                   SendDlgItemMessage(hDlg, IDC_ECHANNEL,
                             WM_GETTEXT, 10, (LPARAM)(LPSTR)szBuffer) ;
                   gwChannel = atoi(szBuffer);
               }

               //
               // Get mask data
               //

               if (SendDlgItemMessage(hDlg, IDC_EMASK,
                             EM_GETMODIFY, 0, 0))
               {
                   SendDlgItemMessage(hDlg, IDC_EMASK,
                             WM_GETTEXT, 10, (LPARAM)(LPSTR)szBuffer) ;
                   gwMask = CvtHex(szBuffer);
               }

                EndDialog(hDlg, 0);