madsoft.c

来自「16 relay output channels and 16 isolated」· C语言 代码 · 共 1,682 行 · 第 1/5 页

        return TRUE;

    case WM_COMMAND :

         switch (LOWORD(wParam))
         {
            case IDOK :

                //
                // get scan time
                //

                if (SendDlgItemMessage(hDlg, IDC_SCAN,
                           EM_GETMODIFY, 0, 0))
                {
                    SendDlgItemMessage(hDlg, IDC_SCAN,
                            WM_GETTEXT, 10, (LPARAM)(LPSTR)szBuffer) ;
                    gwScanTime = atoi(szBuffer);
                    SendDlgItemMessage(hDlg, IDC_SCAN,
                              EM_SETMODIFY, FALSE, 0) ;
                }

            case IDCANCEL :
                EndDialog(hDlg, 0);
                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
)
{
    USHORT          i;
    static  HANDLE  hInstance ;
	 HMENU           hMenu;
    HDC             hdc;
    char            szBuffer[120];
    RECT            rect;

    float           fVoltage[MAX_CHANNELS];
    DWORD           dwCurrentTime;
    DWORD           dwErrorTime;
    BOOL            bTimerOverrun;

    USHORT          usStopChan;
    usStopChan = usStartChan + usNumChan - 1;

    switch (message)
    {
        case WM_CREATE:
            // initialize value
            usStartChan   = 0;
            usStopChan    = 0;
            usCurrentChan = 0;

            for (i = 0 ; i < MAX_CHANNELS ; i++)
            {
                usGainIndex[i]   = 0;
                usExpChan[i]     = 0;
                usExpChanTemp[i] = 0;
                usBoardID[i]     = 0;
            }

            //
            // 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) ;

            lpfnGainListDlgProc = MakeProcInstance (GainListDlgProc, 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 :

                    //
                    // kill timer and close driver
                    //

                    KillTimer(hWnd, 1);
                    DRV_DeviceClose((LONG far *)&DriverHandle);

                    bRun = FALSE;

                    //
                    // 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;
                    }

                    //
                    // get gain code
                    //

                    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;
                    }

					///Get AI Config
                    ptAIGetConfig.buffer = (LPDEVCONFIG_AI)&DevCfg;
                    ptAIGetConfig.size = sizeof(DEVCONFIG_AI);

                    // call AIGetConfig
                    if ((ErrCde = DRV_AIGetConfig(DriverHandle,
                        (LPT_AIGetConfig)&ptAIGetConfig)) != SUCCESS)
                    {
                        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                        MessageBox(hMainWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                        DRV_DeviceClose((LONG far *)&DriverHandle);
                        return 0;
                    }
                    //
                    // configures the gain for the specifed analog input channel
                    //

                    // check start and stop channel if expansion board ?
                    usExpFlag = 0;
                    for (i = usStartChan ; i <= usStopChan ; i++)
                    {
                        if (DevCfg.Daughter[i&0xf].dwBoardID != 0)
                            usExpFlag = 1;
                    }

                    if(usExpFlag == 0)
                    {
                       ptMAIConfig.NumChan   = usStopChan - usStartChan + 1;
                       ptMAIConfig.StartChan = usStartChan;
                       for (i=0 ; i< ptMAIConfig.NumChan ; i++)
					   {
						   if (gwGainList)
						   {
							   usGainCode[i+usStartChan] =
								   DevFeatures.glGainList[usGainIndex[i+PhyChanToLogChan(&DevCfg,usStartChan)]].usGainCde;
						   }
						   else
						   {
							   usGainCode[i+usStartChan] = 
								   DevFeatures.glGainList[gwGainIndex].usGainCde;
						   }
					   }
                       ptMAIConfig.GainArray = (USHORT far *) &usGainCode[usStartChan];

                       if ((ErrCde = DRV_MAIConfig(DriverHandle,
                            (LPT_MAIConfig)&ptMAIConfig)) != 0)
                       {
                           DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                           MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                           DRV_DeviceClose((LONG far *)&DriverHandle);
                           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);

                    //
                    // 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;
            }

            //
            // reads an analog input channel
            //

            // check start and stop channel if expansion board ?
            usExpFlag = 0;
            for (i = usStartChan ; i <= usStopChan ; i++)
            {
                if (DevCfg.Daughter[i&0xf].dwBoardID != 0)
                    usExpFlag = 1;
            }

            if(usExpFlag == 0)
            {
               ptMAIVoltageIn.NumChan   = usStopChan - usStartChan + 1;
               ptMAIVoltageIn.StartChan = usStartChan;

               for (i=0 ; i< ptMAIVoltageIn.NumChan ; i++)
               {
                  if (gwGainList)
                  {
                     usGainCode[i+usStartChan] =
                        DevFeatures.glGainList[usGainIndex[i+ PhyChanToLogChan(&DevCfg,usStartChan)]].usGainCde;
                  }
                  else
                  {
                     usGainCode[i+usStartChan] = 
                        DevFeatures.glGainList[gwGainIndex].usGainCde;
                  }
               }
               ptMAIVoltageIn.GainArray = (USHORT far *) &usGainCode[usStartChan];

               ptMAIVoltageIn.TrigMode = 0;            // internal trigger
               ptMAIVoltageIn.VoltageArray = (FLOAT far *)&fVoltage[usStartChan];

               if ((ErrCde = DRV_MAIVoltageIn(DriverHandle,
                          (LPT_MAIVoltageIn)&ptMAIVoltageIn)) != 0)
               {
                   DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
				       KillTimer(hWnd, 1);
                   MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                   DRV_DeviceClose((LONG far *)&DriverHandle);
                   return 0;
               }