madsoft.c

这是一个应用于滤料过滤除尘方面的一个原代码,解决除尘过程的控制问题.

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

                    //
                    // 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++)
                         usGainCode[i+usStartChan] =
                            DevFeatures.glGainList[usGainIndex[i+usStartChan]].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++)
                 usGainCode[i+usStartChan] =
                    DevFeatures.glGainList[usGainIndex[i+usStartChan]].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;
               }

            }
            else
            {
               for (i = usStartChan ; i <= usStopChan ; i++)
               {
                  usDasChan[i] = i;

                  // for PCLD-788
                  if  (DevCfg.Daughter[i&0xf].dwBoardID == BD_PCLD788)
                      usExpChanTemp[i] = ((usBoardID[i] << 4) | usExpChan[i]);
                  else
                      usExpChanTemp[i] = usExpChan[i];
               }

               ptMAIVoltageInExp.NumChan      = usStopChan - usStartChan + 1;
               ptMAIVoltageInExp.DasChanArray = (USHORT far *)&usDasChan[usStartChan];
               ptMAIVoltageInExp.DasGainArray = (USHORT far *)&usGainIndex[usStartChan];
               ptMAIVoltageInExp.ExpChanArray = (USHORT far *)&usExpChanTemp[usStartChan];
               ptMAIVoltageInExp.VoltageArray = (FLOAT far *)&fVoltage[usStartChan];

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

            }
            //
            // Display Data
            //

            hdc = GetDC(hWnd);
            GetClientRect(hWnd, &rect);
            InvalidateRect(hWnd, NULL, TRUE);
            UpdateWindow(hWnd);
            if (bTimerOverrun == FALSE)
            {
                for (i=usStartChan; i <= usStopChan ; i++)
                {
                    sprintf(szBuffer, "data[%d] = %10.6f", i-usStartChan, fVoltage[i]);
                    TextOut(hdc, 300, 20*(i-usStartChan), szBuffer, 20);
                }
            }
            else
            {
                sprintf(szBuffer, "Timer Overrun!\n data = %10.6f", fVoltage[0]);
                DrawText(hdc, szBuffer, -1, &rect,
                    DT_SINGLELINE | DT_CENTER | DT_VCENTER);
            }

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

PRIVATE void AllWindows(HWND hDlg)
{
    EnableWindow(GetDlgItem(hDlg, IDC_STARTCHAN),   FALSE);
    EnableWindow(GetDlgItem(hDlg, IDC_STOPCHAN),    FALSE);

    EnableWindow(GetDlgItem(hDlg, IDC_CURRENTCHAN), FALSE);
    EnableWindow(GetDlgItem(hDlg, IDC_INPRANGE),    FALSE);
    EnableWindow(GetDlgItem(hDlg, IDC_EXPCHAN),     FALSE);
    EnableWindow(GetDlgItem(hDlg, IDC_BOARDID),     FALSE);
}

PRIVATE void SetChannel(HWND hDlg)
{
    // this subroutine use variable usMaxChannel, usStartChan, usStopChan
    USHORT i;
    USHORT usStopChan;
    usStopChan = usStartChan + usNumChan - 1;

    EnableWindow(GetDlgItem(hDlg, IDC_STARTCHAN),   TRUE);
    EnableWindow(GetDlgItem(hDlg, IDC_STOPCHAN),    TRUE);
    SendDlgItemMessage(hDlg, IDC_STARTCHAN, CB_RESETCONTENT, 0, 0L);
    SendDlgItemMessage(hDlg, IDC_STOPCHAN,  CB_RESETCONTENT, 0, 0L);
    // setting dialog box for start channel setting
    for (i=0; i< usMaxChannel; ++i)
    {
        wsprintf(szBuf, "%d", i);
        /*
        if (i == DevCfg.usCjcChannel) // CJC channel
        {
            lstrcat(szBuf, " (CJC Channel)");
        }
        else */
        if (DevCfg.Daughter[i&0xf].dwBoardID!=0L)// exp. board exist
        {
            lstrcat(szBuf, " (");
            DRV_BoardTypeMapBoardName(DevCfg.Daughter[i&0xf].dwBoardID,
                                      (LPSTR)szExpName);
            lstrcat(szBuf, szExpName);
            lstrcat(szBuf, ")");
        }
        
        SendDlgItemMessage(hDlg, IDC_STARTCHAN, CB_ADDSTRING,(WPARAM) -1,
            (LPARAM)(LPSTR)szBuf);
    }

    // setting dialog box for end channel setting
    for (i=0; i< usMaxChannel; ++i)
    {
        wsprintf(szBuf, "%d", i);
        if (i == DevCfg.usCjcChannel) // CJC channel
        {
            lstrcat(szBuf, " (CJC Channel)");
        }
        else if (DevCfg.Daughter[i&0xf].dwBoardID!=0L)// exp. board exist
        {
            lstrcat(szBuf, " (");
            DRV_BoardTypeMapBoardName(DevCfg.Daughter[i&0xf].dwBoardID,
                                      (LPSTR)szExpName);
            lstrcat(szBuf, szExpName);
            lstrcat(szBuf, ")");
        }
        SendDlgItemMessage(hDlg, IDC_STOPCHAN, CB_ADDSTRING,(WPARAM) -1,
            (LPARAM)(LPSTR)szBuf);
    }

    // set usStartChan & usStopChan
    if (usStopChan < usStartChan)
        usStopChan = usStartChan;
    SendDlgItemMessage(hDlg, IDC_STARTCHAN, CB_SETCURSEL, usStartChan,0L);
    SendDlgItemMessage(hDlg, IDC_STOPCHAN,  CB_SETCURSEL, usStopChan,0L);
}

PRIVATE void SetCurrentChan(HWND hDlg, BOOL bflag)
{
    USHORT i;
    USHORT usStopChan;
    usStopChan = usStartChan + usNumChan - 1;

    if (bflag == TRUE)   // Enable current chan setting for Varied
    {
        EnableWindow(GetDlgItem(hDlg, IDC_CURRENTCHAN), TRUE);
        SendDlgItemMessage(hDlg, IDC_CURRENTCHAN, CB_RESETCONTENT,
            0, (LPARAM)((LPSTR)0));
        for (i = usStartChan; i <= usStopChan; i ++)
        {
            wsprintf(szBuf, "%d", i);
            SendDlgItemMessage(hDlg, IDC_CURRENTCHAN, CB_ADDSTRING, 0,
                (LPARAM)(LPSTR)szBuf);
        }

        wsprintf(szBuf, "%d", usCurrentChan);
        SendDlgItemMessage(hDlg, IDC_CURRENTCHAN,
           CB_SELECTSTRING, (WPARAM)(-1), (LPARAM)((LPSTR)szBuf));
    }
    else
    {
        EnableWindow(GetDlgItem(hDlg, IDC_CURRENTCHAN), FALSE);
    }
}

PRIVATE void SetGain(HWND hDlg, BOOL bflag)
{
    USHORT i;

    if (bflag == TRUE)   // Enable gain setting
    {
        EnableWindow(GetDlgItem(hDlg, IDC_INPRANGE), TRUE);
        SendDlgItemMessage(hDlg, IDC_INPRANGE, CB_RESETCONTENT,
            0, (LPARAM)((LPSTR)0));
        for (i = 0; i < DevFeatures.usNumGain; i ++)
            SendDlgItemMessage(hDlg, IDC_INPRANGE, CB_ADDSTRING, 0,
                (LPARAM)((LPSTR)(DevFeatures.glGainList[i].szGainStr)));

        SendDlgItemMessage(hDlg, IDC_INPRANGE,
           CB_SELECTSTRING, (WPARAM)(-1),
           (LPARAM)((LPSTR)(DevFeatures.glGainList[usGainIndex[usCurrentChan]].szGainStr)));
    }
    else
    {
        EnableWindow(GetDlgItem(hDlg, IDC_INPRANGE), FALSE);
    }
}

PRIVATE void SetExpChan(HWND hDlg, BOOL bflag)
{
    USHORT i;

    if (bflag == TRUE)   // Enable expansion channel
    {
        EnableWindow(GetDlgItem(hDlg, IDC_EXPCHAN), TRUE);
        SendDlgItemMessage(hDlg, IDC_EXPCHAN, CB_RESETCONTENT,
            0, (LPARAM)((LPSTR)0));

        for (i=0; i<DevCfg.Daughter[usCurrentChan&0xf].usNum; ++i)
        {
            wsprintf(szBuf, "%d", i);
            SendDlgItemMessage(hDlg, IDC_EXPCHAN, CB_ADDSTRING,(WPARAM)-1,
                (LPARAM)(LPSTR)szBuf);
        }

        SendDlgItemMessage(hDlg, IDC_EXPCHAN, CB_SETCURSEL,
            usExpChan[usCurrentChan],0L);
    }
    else
    {
        EnableWindow(GetDlgItem(hDlg, IDC_EXPCHAN), FALSE);
    }
}

PRIVATE void SetBoardID(HWND hDlg, BOOL bflag)
{
    USHORT i;

    if (bflag == TRUE)   // Enable PCLD-788 board ID setting
    {
        EnableWindow(GetDlgItem(hDlg, IDC_BOARDID), TRUE);
        SendDlgItemMessage(hDlg, IDC_BOARDID, CB_RESETCONTENT, 0, 0L);

        for (i=0; i<DevCfg.Daughter[usCurrentChan&0xf].usCards; ++i)
        {
            wsprintf(szBuf, "%d", i);
            SendDlgItemMessage(hDlg, IDC_BOARDID, CB_ADDSTRING, (WPARAM)-1,
                (LPARAM)(LPSTR)szBuf);
        }
        SendDlgItemMessage(hDlg, IDC_BOARDID, CB_SETCURSEL,
            usBoardID[usCurrentChan],0L);
    }
    else
    {
        EnableWindow(GetDlgItem(hDlg, IDC_BOARDID), FALSE);
    }
}