1753evt.c

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

		    lpfnConfigExpPatternProc = MakeProcInstance (ConfigExpPatternProc, hInstance) ;
            
		    lpfnConfigExpStatusProc = MakeProcInstance (ConfigExpStatusProc, 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;
                    // kill timer and close driver
                    //

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

					if(hThreadHandle)
					{
						GetExitCodeThread(hThreadHandle,&dwExitCode);
						if(dwExitCode==STILL_ACTIVE)
							TerminateThread(hThreadHandle,dwExitCode);
					}


                    KillTimer(hWnd, 1);

					bRun = FALSE;
					if(usPEnable || usSEnable)
					{
					  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;
					  }
					}
					if(usIEnable)
					{
                       // Disable event feature
                       ptEnableEvent.EventType = ADS_EVT_INTERRUPT;
                       ptEnableEvent.Enabled = FALSE;
                       ptEnableEvent.Count   = 1;
                       if ((ErrCde = DRV_EnableEvent(DriverHandle,
                           (LPT_EnableEvent)&ptEnableEvent)) != 0)
					   {
                         DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                         MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                         DRV_DeviceClose((LONG far *)&DriverHandle);
                         return 0;
					   }
					}
                    
					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 :

					 usSCount=0;
					 usPCount=0;
					 usICount=0;
                    //
                    // 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 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 = 0;
//					  ptEnableEventEx.Status.usFallingedge = 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;
					  }
					}
                    if(usIEnable)
					{
                       // Enable event feature
                       ptEnableEvent.EventType = ADS_EVT_INTERRUPT;
                       ptEnableEvent.Enabled = TRUE;
                       ptEnableEvent.Count   = 1;
                       if ((ErrCde = DRV_EnableEvent(DriverHandle,
                           (LPT_EnableEvent)&ptEnableEvent)) != 0)
					   {
                         DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                         MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                         DRV_DeviceClose((LONG far *)&DriverHandle);
                         return 0;
					   }
					}
					// create thread
                    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
            //

            ptDioReadPortByte.port = gwChannel;
            ptDioReadPortByte.value = (USHORT far *)&gwValue;

            if ((ErrCde = DRV_DioReadPortByte(DriverHandle,
                (LPT_DioReadPortByte)&ptDioReadPortByte)) != 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 ", gwValue);
            else
                sprintf(szBuffer, "Timer Overrun!");

            TextOut(hdc, 200, 150, szBuffer, strlen(szBuffer));
            
			sprintf(szBuffer,"Interrupt count=%d", usICount);
            TextOut(hdc, 100, 180, szBuffer, strlen(szBuffer));

			sprintf(szBuffer,"Pattern Match count=%d", usPCount);
            TextOut(hdc, 100, 210, szBuffer, strlen(szBuffer));

		    sprintf(szBuffer,"Status Change  count=%d", usSCount);
            TextOut(hdc, 100, 240, szBuffer, strlen(szBuffer));

            ReleaseDC(hWnd, hdc);

            return 0;

        case WM_DESTROY:

            if (bRun == TRUE)
            {
                KillTimer(hWnd, 1);
                DRV_DeviceClose((LONG far *)&DriverHandle);
            }
            PostQuitMessage(0);
            break;

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

   return ((LONG)NULL);
}

//------------------------------------------------------------------
void UserThread()
{
    USHORT usEventType;
    LONG  ErrCde;
    
	while(m_bContinue)
    {
        // Check message
        ptCheckEvent.EventType = &usEventType;
        ptCheckEvent.Milliseconds = 5000;

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

        // Process counter match event
        if (usEventType == ADS_EVT_INTERRUPT)
            adInterruptEvent();

		// Process pattern match event
        if (usEventType == ADS_EVT_PATTERNMATCH)
            adPatternMatchEvent();

        // Process status change event
        if (usEventType == ADS_EVT_STATUSCHANGE)
            adStatusChangeEvent();

		bThreadflag = FALSE;
    }

    return ;
}

//------------------------------------------------------------------
void adPatternMatchEvent()
{
    if(usPCount>10000)
       usPCount = 0;
	else
       usPCount++;
    return;
}

//------------------------------------------------------------------
void adInterruptEvent()
{
    if(usICount>10000)
       usICount = 0;
	else
       usICount++;
    return;
}
//------------------------------------------------------------------
void adStatusChangeEvent()
{
    if(usSCount>10000)
       usSCount = 0;
	else
       usSCount++;
    return;
}