dadma.c

研华da采集例程

                }

                // Step 2: Free buffer
                GlobalUnlock(hBuf);
                GlobalFree(hBuf);
                GlobalUnlock(hVoltageBuf);
                GlobalFree(hVoltageBuf);
                GlobalUnlock(hBinaryBuf);
                GlobalFree(hBinaryBuf);

                DRV_FreeDMABuffer(DriverHandle, (LPARAM)&pBuffer);

                // Step 4: Close driver
                DRV_DeviceClose((LONG far *)&DriverHandle);

                EnableMenuItem(hMenu, IDM_RUN, MF_ENABLED | MF_BYCOMMAND);

                return 0;

           case IDC_STATUSBUTTON:

                // Get Interrupt transfer status
                ptFAOCheck.ActiveBuf    = &gwActiveBuf;
                ptFAOCheck.stopped      = &gwStopped;
                ptFAOCheck.CurrentCount = &gulRetrieved;
                ptFAOCheck.overrun      = &gwOverrun;
                ptFAOCheck.HalfReady    = &gwHalfReady;

                if ((ErrCde = DRV_FAOCheck(DriverHandle,
                    (LPT_FAOCheck)&ptFAOCheck)) != 0)
                {
                    DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                    MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                    GlobalUnlock(hBuf); GlobalFree(hBuf);
                    GlobalUnlock(hVoltageBuf); GlobalFree(hVoltageBuf);
                    GlobalUnlock(hBinaryBuf); GlobalFree(hBinaryBuf);
                    DRV_FreeDMABuffer(DriverHandle, (LPARAM)&pBuffer);
                    DRV_DeviceClose((LONG far *)&DriverHandle);
                    return 0;
                }
                else
                {   // Display the status of the A/D conversion
                    sprintf(szDest, "Cyclic Counts: %d\n", gwRepeatCount);
                    if (gwHalfReady == 0)
                        strcpy(szTemp, "Buffer : not  ready\n");
                    else if (gwHalfReady == 1)
                        strcpy(szTemp, "Buffer : half ready\n");
                    else if (gwHalfReady == 2)
                        strcpy(szTemp, "Buffer : full ready\n");
                    else
                        strcpy(szTemp, "Buffer : unknow \n");
                    strcat(szDest, szTemp);
                    ratio = 100.0 * gulRetrieved / gulConvNum;
                    szStr = fcvt((double)ratio, 0, &dec, &sign);
                    strcat(szDest, "Finish:  ");
                    strcat(szDest, szStr);
                    strcat(szDest, "%...");
                    MessageBox(hWnd,(LPCSTR)szDest, "Check Status", MB_OK);
                }

                return 0;
          }

    case WM_DESTROY:

         PostQuitMessage(0);
         break;

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

   return ((LONG)NULL);
}

void SetRealBuffer(float far *lpBuf, long num, LPSWAVE lpWave)
{
    int i, r, half;
    float slope;

    switch (lpWave->wWaveform)
    {
        case WAVE_SINE:
             for (i = 0; i < num; i ++)
               *(lpBuf+i) = (float)(lpWave->fMagnitude
                            * sin(6.28318*(double)i/(double)lpWave->wPeriod)
                            + lpWave->fOffset);
             break;
        case WAVE_TRIANGLE:
             slope = lpWave->fMagnitude * 4.0f / (float)lpWave->wPeriod;
             for (i = 0; i < num; i ++)
                {
                    r = i % lpWave->wPeriod;
                    half = (int)((float)lpWave->wPeriod / 2.0f);
                    if (r <= half)
                       *(lpBuf + i) = slope * r - lpWave->fMagnitude
                                      + lpWave->fOffset;
                    else
                       *(lpBuf + i) = slope * (lpWave->wPeriod - r)
                                      - lpWave->fMagnitude + lpWave->fOffset;
                }
             break;
        case WAVE_SQUARE:
             for (i = 0; i < num; i ++)
                {
                    r = i % lpWave->wPeriod;
                    half = (int)((float)lpWave->wPeriod / 2.0f);
                    if (r <= half)
                       *(lpBuf + i) = lpWave->fOffset - lpWave->fMagnitude;
                    else
                       *(lpBuf + i) = lpWave->fOffset + lpWave->fMagnitude;
                }
             break;
    }

}

//------------------------------------------------------------------
void UserThread()
{
    USHORT usEventType;
    LONG  ErrCde;
    DWORD TickValue;

    TickValue = GetTickCount();
    TickValue = TickValue + 500000;

    while(TickValue > GetTickCount())
    {
        // Check message
        ptCheckEvent.EventType = &usEventType;
        ptCheckEvent.Milliseconds = 5000;

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

        // Process interrupt event
        if (usEventType & ADS_EVT_INTERRUPT)
            adInterruptEvent();

        // Process buffer change event
        if (usEventType & ADS_EVT_BUFCHANGE)
            adBufChangeEvent();

        // Process overrun event
        if (usEventType & ADS_EVT_OVERRUN)
            adOverrunEvent();

        // Process terminate event
        if (usEventType & ADS_EVT_TERMINATED)
        {
            adTerminateEvent();
            return ;
        }
    }

    MessageBox(hWnd,"Never Get Any Event !","Thread Message",MB_OK);
}

//------------------------------------------------------------------
void adInterruptEvent()
{
    return;
}

//------------------------------------------------------------------
void adBufChangeEvent()
{
    USHORT usWaveIndex;
    LPSWAVE lpWave;

    usWaveIndex = (gwRepeatCount + 1) % 3;
    switch (usWaveIndex)
    {
      case 0:
          lpWave = &sWaveA;
          break;
      case 1:
          lpWave = &sWaveB;
          break;
      case 2:
          lpWave = &sWaveC;
          break;
    }

    // Step 1: get status
    ptFAOCheck.ActiveBuf    = &gwActiveBuf;
    ptFAOCheck.stopped      = &gwStopped;
    ptFAOCheck.CurrentCount = &gulRetrieved;
    ptFAOCheck.overrun      = &gwOverrun;
    ptFAOCheck.HalfReady    = &gwHalfReady;

    if ((ErrCde = DRV_FAOCheck(DriverHandle,
         (LPT_FAOCheck)&ptFAOCheck)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
        return ;
    }

    // Set real voltage to first half buffer
    SetRealBuffer(lpVoltageBuf, gulConvNum/2, lpWave);

    // Step 2: call FAOScale for transfer voltage to binary data
    ptFAOScale.VoltArray = lpVoltageBuf;
    ptFAOScale.BinArray  = lpBinaryBuf;
    ptFAOScale.chan      = gwStartChl;
    ptFAOScale.count     = gulConvNum/2;
    if ((ErrCde = DRV_FAOScale(DriverHandle,
        (LPT_FAOScale)&ptFAOScale)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
        return ;
    }

    if (gwHalfReady == 2) // second half ready
    {
        // Step 3: call FAOLoad to pass data to driver
    //  ptFAOLoad.ActiveBuf  = 0;  // single buffer
    //  ptFAOLoad.DataBuffer = lpBinaryBuf;
    //  ptFAOLoad.start    = 0;
    //  ptFAOLoad.count    = gulConvNum;

    //  if ((ErrCde = DRV_FAOLoad(DriverHandle,
    //      (LPT_FAOLoad)&ptFAOLoad)) != 0)
    //  {
    //      DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
    //      MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
    //      return ;
    //  }

        gwRepeatCount ++;
    }

    return;
}
//------------------------------------------------------------------
void adOverrunEvent()
{
    // clear overrun
    if ((ErrCde = DRV_ClearOverrun(DriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
        return ;
    }

    return;
}
//------------------------------------------------------------------
void adTerminateEvent()
{
    // Disable stop and status buttons
    EnableWindow(hwndStopButton, FALSE);
    EnableWindow(hwndStatusButton, FALSE);

    // Stop A/D conversion
    if ((ErrCde = DRV_FAOStop(DriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
        return ;
    }

    // Free buffer
    GlobalUnlock(hBuf);
    GlobalFree(hBuf);
    GlobalUnlock(hVoltageBuf);
    GlobalFree(hVoltageBuf);
    GlobalUnlock(hBinaryBuf);
    GlobalFree(hBinaryBuf);

    DRV_FreeDMABuffer(DriverHandle, (LPARAM)&pBuffer);

    // Close driver
    DRV_DeviceClose((LONG far *)&DriverHandle);

    EnableMenuItem(hMenu, IDM_RUN, MF_ENABLED | MF_BYCOMMAND);

    return;
}