dipattn.c

16 relay output channels and 16 isolated digital input channels LED indicators to show activated

                return TRUE;

         }
         break;
    }
    return FALSE ;
}


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

    PURPOSE:  Processes messages

    MESSAGES:

        WM_CREATE     - create window
        WM_COMMAND    - application menu (About dialog box)
        WM_DESTROY    - destroy window
****************************************************************************/

long FTYPE MainWndProc
(
    HWND        hWnd,                          // window handle
    unsigned    message,                       // type of message
    WPARAM      wParam,                        // additional information
    LPARAM      lParam                         // additional information
)
{
    static  HANDLE  hInstance ;
    HMENU           hMenu;
    HDC             hdc;
    char            szBuffer[120];
    RECT            rect;
    DWORD           dwCurrentTime;
    DWORD           dwErrorTime;
    BOOL            bTimerOverrun;
    PT_EnableEventEx      Zero = {0};

    switch (message)
    {
        case WM_CREATE:

            //
            // initialize Stop Menu
            //

            hMenu = GetMenu(hWnd);
            EnableMenuItem(hMenu, IDM_STOP, MF_BYCOMMAND | MF_GRAYED);

            hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;

            lpfnConfigDlgProc = MakeProcInstance (ConfigDlgProc, hInstance) ;

            lpfnScanDlgProc = MakeProcInstance (ScanDlgProc, hInstance) ;
            
            lpfnConfigCounterProc =  MakeProcInstance (ConfigCounterProc, hInstance) ;

            lpfnConfigFilterProc = MakeProcInstance (ConfigFilterProc, hInstance) ;
            
		    lpfnConfigPatternProc = MakeProcInstance (ConfigPatternProc, hInstance) ;
            
		    lpfnConfigStatusProc = MakeProcInstance (ConfigStatusProc, hInstance) ;
			return 0 ;

       case WM_COMMAND:     /* message: from application menu */

            hMenu = GetMenu(hWnd);

            switch (LOWORD(wParam))
            {
                case IDM_SETTING :
                    DialogBox (hInstance, MAKEINTRESOURCE(IDD_SETTING),
                         hWnd, lpfnConfigDlgProc) ;
                    return 0;

                case IDM_SCAN :
                    DialogBox (hInstance, MAKEINTRESOURCE(IDD_SCAN),
                         hWnd, lpfnScanDlgProc) ;
                    return 0;

                case IDM_STOP :
					{
                     BOOL bflag = TRUE;

                     // Close thread
                     m_bContinue = FALSE;
                     Sleep(10);

                    while(bflag)
					{
			         if(bThreadflag==FALSE)
				        bflag=FALSE;
					}


					ptEnableEventEx = Zero;
                    if ((ErrCde = DRV_EnableEventEx(DriverHandle,
                                                (LPT_EnableEventEx)&ptEnableEventEx)) != 0)
					  {
                       DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                       MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                       DRV_DeviceClose((LONG far *)&DriverHandle);
                       return 0;
					  }
                    
                     // kill timer and close driver
                     //
                     KillTimer(hWnd, 1);
					 bRun = FALSE;

					DRV_DeviceClose((LONG far *)&DriverHandle);

                    //
                    // reset menu item status
                    //

                    EnableMenuItem(hMenu, IDM_STOP, MF_BYCOMMAND | MF_GRAYED);
                    EnableMenuItem(hMenu, IDM_START, MF_BYCOMMAND | MF_ENABLED);

                    return 0;
					}

                case IDM_START :

                    //
                    // Open Device
                    //

                    if (gnNumOfSubdevices == 0)
                        ErrCde = DRV_DeviceOpen(
                            DeviceList[gwDevice].dwDeviceNum,
                                (LONG far *)&DriverHandle);
                    else
                        ErrCde = DRV_DeviceOpen(
                            SubDeviceList[gwSubDevice].dwDeviceNum,
                                (LONG far *)&DriverHandle);

                    if (ErrCde != SUCCESS)
                    {
                        strcpy(szErrMsg,"Device open error !");
                        MessageBox(hWnd,(LPCSTR)szErrMsg,"Device Open",MB_OK);
                        return 0;
                    }

                    //
                    // enable Stop Menu item and disable the others
                    //

                    EnableMenuItem(hMenu, IDM_STOP, MF_BYCOMMAND | MF_ENABLED);
                    EnableMenuItem(hMenu, IDM_START, MF_BYCOMMAND | MF_GRAYED);

                   // Enable Pattern Match event feature
                    if(usPEnable)
					{
				      ptEnableEventEx.Pattern.usEventType = ADS_EVT_PATTERNMATCH;
                      ptEnableEventEx.Pattern.usEventEnable = TRUE;
                      ptEnableEventEx.Pattern.usCount   = 1;
					  ptEnableEventEx.Pattern.usEnable = usPEnable;
					  ptEnableEventEx.Pattern.usValue = usPValue;
                      if ((ErrCde = DRV_EnableEventEx(DriverHandle,
                                                (LPT_EnableEventEx)&ptEnableEventEx)) != 0)
					  {
                       DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                       MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                       DRV_DeviceClose((LONG far *)&DriverHandle);
                       return 0;
					  }

					}

					// Enable counter event feature
                    if(usCEnable)
					{
				      ptEnableEventEx.Counter.usEventType = ADS_EVT_COUNTER;
                      ptEnableEventEx.Counter.usEventEnable = TRUE;
                      ptEnableEventEx.Counter.usCount   = 1;
					  ptEnableEventEx.Counter.usEnable = usCEnable;
					  ptEnableEventEx.Counter.usTrigEdge = usTrigEdge;
					  ptEnableEventEx.Counter.usPreset = &usCPreset[0];
					  ptEnableEventEx.Counter.usMatchEnable = usCMatchEnable;
					  ptEnableEventEx.Counter.usValue = &usCMatchValue[0];
					  ptEnableEventEx.Counter.usOverflow = usCOverflow;
					  ptEnableEventEx.Counter.usDirection = 0;

                      if ((ErrCde = DRV_EnableEventEx(DriverHandle,
                                                (LPT_EnableEventEx)&ptEnableEventEx)) != 0)
					  {
                       DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                       MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                       DRV_DeviceClose((LONG far *)&DriverHandle);
                       return 0;
					  }

					}
                   // Enable Status Change event feature
                    if(usSEnable)
					{
				      ptEnableEventEx.Status.usEventType = ADS_EVT_STATUSCHANGE;
                      ptEnableEventEx.Status.usEventEnable = TRUE;
                      ptEnableEventEx.Status.usCount   = 1;
					  ptEnableEventEx.Status.usEnable = usSEnable;
					  ptEnableEventEx.Status.usRisingedge = usSRiseEdge;
					  ptEnableEventEx.Status.usFallingedge = usSFallEdge;
                      if ((ErrCde = DRV_EnableEventEx(DriverHandle,
                                                (LPT_EnableEventEx)&ptEnableEventEx)) != 0)
					  {
                       DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                       MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                       DRV_DeviceClose((LONG far *)&DriverHandle);
                       return 0;
					  }

					}
                   // Enable Filter event feature
                    if(usFEnable)
					{
				      ptEnableEventEx.Filter.usEventType = ADS_EVT_FILTER;
                      ptEnableEventEx.Filter.usEventEnable = TRUE;
                      ptEnableEventEx.Filter.usCount   = 1;
					  ptEnableEventEx.Filter.usEnable = usFEnable;
					  ptEnableEventEx.Filter.usHiValue = &usFHiValue[0];
					  ptEnableEventEx.Filter.usLowValue = &usFLowValue[0];
                      if ((ErrCde = DRV_EnableEventEx(DriverHandle,
                                                (LPT_EnableEventEx)&ptEnableEventEx)) != 0)
					  {
                       DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                       MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                       DRV_DeviceClose((LONG far *)&DriverHandle);
                       return 0;
					  }

					}

					
					// create thread
					if(usPEnable || usCEnable || usSEnable)
					{
                     hThreadHandle = CreateThread(0, 0, (LPTHREAD_START_ROUTINE) UserThread,
                                                 0, 0, (LPDWORD)&dwThreadID);
                     m_bContinue = TRUE;
					}
					//
                    // Set the new timer type and start it up.
                    //

                    if (SetTimer(hWnd, 1, gwScanTime, NULL) == (UINT)NULL)
                    {
                        MessageBox(hWnd, "Couldn't create timer.", "Notice!",
                            MB_OK);
                        DRV_DeviceClose((LONG far *)&DriverHandle);
                        return 0;
                    }

                    bRun = TRUE;

                    gdwStartTime = GetTickCount();
                    gwOverrunCount = 0;

                    return 0;
            }
            return 0;

        case WM_TIMER:

            //
            // Timer set to dispatch a WM_TIMER message has gone off.
            //

            //
            // check if timer is overrun
            //

            dwCurrentTime = GetTickCount();

            gdwElapseTime = gdwElapseTime + (DWORD)gwScanTime;
            dwErrorTime = dwCurrentTime - gdwElapseTime - gdwStartTime;
            if (dwErrorTime > (DWORD)40)        // maximum 40 ms scan time
            {
                gdwElapseTime = dwCurrentTime - gdwStartTime;
                gwOverrunCount ++;
                if (gwOverrunCount >= 10)
                {
                    bTimerOverrun = TRUE;
                    gwOverrunCount = 0;
                }
                else
                    bTimerOverrun = FALSE;
            }
            else
            {
                bTimerOverrun = FALSE;
                gwOverrunCount = 0;
            }


            //
            // read data
            //

            
		
			ptDioReadBit.port = gwChannel/8;
			ptDioReadBit.bit = gwChannel%8;
			ptDioReadBit.state = (USHORT far *)&gwState;

           	if ((ErrCde = DRV_DioReadBit(DriverHandle,
               (LPT_DioReadBit)&ptDioReadBit)) != 0)
            {
                DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                KillTimer(hWnd, 1);
                MessageBox(hWnd,(LPCSTR)szErrMsg, "Driver Message", MB_OK);
                return TRUE;
            }

            //
            // Display Data
            //

            hdc = GetDC(hWnd);
            GetClientRect(hWnd, &rect);
            InvalidateRect(hWnd, NULL, TRUE);
            UpdateWindow(hWnd);
            if (bTimerOverrun == FALSE)
				sprintf(szBuffer, "Data (Hex) = %2X ",gwState);
            else
                sprintf(szBuffer, "Timer Overrun!");

            TextOut(hdc, 200, 50, szBuffer, strlen(szBuffer));
            
			sprintf(szBuff