maddma.c

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

            ptAllocateDMABuffer.RequestBufSize = gulConvNum * 2;
            ptAllocateDMABuffer.ActualBufSize = &gwActualBufSize;
            ptAllocateDMABuffer.buffer = &pBuffer;
            if ((ErrCde = DRV_AllocateDMABuffer(DriverHandle,
                (LPT_AllocateDMABuffer)&ptAllocateDMABuffer)) != SUCCESS)
            {
                DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                DRV_DeviceClose((LONG far *)&DriverHandle);
                return 0;
            }

            // Step 4: Allocate memory for Voltage data or Raw data
            if((hUserBuf=(FLOAT far *)GlobalAlloc(GHND,
                sizeof(FLOAT) * gulConvNum)) == 0)
            {
                MessageBox(hWnd,"Not enough memory for buffer ",
                    "High Speed",MB_OK);
                DRV_FreeDMABuffer(DriverHandle, (LPARAM)&pBuffer);
                DRV_DeviceClose((LONG far *)&DriverHandle);
                return 0;
            }

            ptFAITransfer.DataBuffer = (FLOAT far  *)GlobalLock(hUserBuf);

            // Step 5: Enable event feature
            ptEnableEvent.EventType = ADS_EVT_INTERRUPT  |
                ADS_EVT_BUFCHANGE  |
                ADS_EVT_TERMINATED |
                ADS_EVT_OVERRUN;
            ptEnableEvent.Enabled = gwEvtFlag;
            ptEnableEvent.Count   = 512;

            if ((ErrCde = DRV_EnableEvent(DriverHandle,
                (LPT_EnableEvent)&ptEnableEvent)) != 0)
            {
                DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                GlobalUnlock(hUserBuf);
                GlobalFree(hUserBuf);
                DRV_FreeDMABuffer(DriverHandle, (LPARAM)&pBuffer);
                DRV_DeviceClose((LONG far *)&DriverHandle);
                return 0;
            }

//          for (i=0 ; i < gwNumChl ; i++)
            for (i=0 ; i < 16 ; i++)        // B980529: Modify by Charley
            {
                if (!gwGainList)
                {
                    gwGainCde[i] = DevFeatures.glGainList[gwGainCode].usGainCde;      // no gain list
                }
                else
                {
                    temp = gwGain[i];
                    gwGainCde[i] = DevFeatures.glGainList[temp].usGainCde;
                }
            }

            // Step 6: Start DMA transfer
            ptFAIDmaScanStart.TrigSrc    = gwExtTrig;
            ptFAIDmaScanStart.StartChan  = gwStartChl;
            ptFAIDmaScanStart.NumChans   = gwNumChl;
//          ptFAIDmaScanStart.GainList   = &gwGainCde[0];
            ptFAIDmaScanStart.GainList   = &gwGainCde[gwStartChl];    // B980529: Modify by Charley
            ptFAIDmaScanStart.SampleRate = gdwPacerRate;
            ptFAIDmaScanStart.count  = gulConvNum;
            ptFAIDmaScanStart.buffer = (USHORT far *)pBuffer;

            if ((ErrCde = DRV_FAIDmaScanStart(DriverHandle,
                (LPT_FAIDmaScanStart)&ptFAIDmaScanStart)) != 0)
            {
                DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                GlobalUnlock(hUserBuf);
                GlobalFree(hUserBuf);
                DRV_FreeDMABuffer(DriverHandle, (LPARAM)&pBuffer);
                DRV_DeviceClose((LONG far *)&DriverHandle);
                return 0;
            }

            gwCyclicCount = 0;

            if (gwEvtFlag)
			{
                hThreadHandle = CreateThread(0, 0,
                (LPTHREAD_START_ROUTINE) UserThread,
                0, 0, (LPDWORD)&dwThreadID);

				bThreadloop = TRUE;
			}

            Sleep(0);

            EnableMenuItem(hMenu, IDM_RUN, MF_DISABLED | MF_BYCOMMAND);

            // Enable stop and status buttons
            EnableWindow(hwndStopButton, TRUE);
            EnableWindow(hwndStatusButton, TRUE);
            bRun = TRUE;      
            
            return 0;
            //end IDM_RUN

        case IDC_STOPBUTTON:
			{ 
               // Disable stop and status buttons
               // EnableWindow(hwndStopButton, FALSE);
               // EnableWindow(hwndStatusButton, FALSE);

               // Stop A/D conversion for high speed
               if ((ErrCde = DRV_FAITerminate(DriverHandle)) != 0)
			   {
                  DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                  MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                  GlobalUnlock(hUserBuf);
                  GlobalFree(hUserBuf);
                  DRV_FreeDMABuffer(DriverHandle, (LPARAM)&pBuffer);
                  DRV_DeviceClose((LONG far *)&DriverHandle);  
				  return 0 ;
			   }            
			   if (gwEvtFlag == 0)
			   {
				   adTerminateEvent();
			   }
               
               return 0;			
			}			

        case IDC_STATUSBUTTON:

            // Get DMA transfer status
            ptFAICheck.ActiveBuf = &gwActiveBuf;
            ptFAICheck.stopped   = &gwStopped;
            ptFAICheck.retrieved = &gulRetrieved;
            ptFAICheck.overrun   = &gwOverrun;
            ptFAICheck.HalfReady = &gwHalfReady;

            if ((ErrCde = DRV_FAICheck(DriverHandle,
                (LPT_FAICheck)&ptFAICheck)) != 0)
            {
                DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
                GlobalUnlock(hUserBuf);
                GlobalFree(hUserBuf);
                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", ulBuffCount);
                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_CLOSE:
      
   case WM_DESTROY:
      if( bRun )
      {
         MessageBox(hWnd, "The DMA is running, please stop and exit","Running",MB_OK);
         break;
      }
      PostQuitMessage(0);
      break;

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

    return ((LONG)NULL);
}
//------------------------------------------------------------------
void UserThread()
{
    USHORT usEventType;
    LONG  ErrCde;
    char  szBuff[50];
    HDC hdc;
    
    ulInterruptCount = 0;
    ulOverRunCount = 0;
    ulBuffCount = 0;
    ptCheckEvent.EventType = &usEventType;
    ptCheckEvent.Milliseconds = INFINITE;
    while(bThreadloop)
    {
        // Check message

		bThreadflag = TRUE;
        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();
           ulInterruptCount++;
        }
        
        
        // Process buffer change event
        if (usEventType & ADS_EVT_BUFCHANGE)
        {
           ulBuffCount++;           
           adBufChangeEvent();
        }
        
        // Process overrun event
        if (usEventType & ADS_EVT_OVERRUN)
        {
           ulOverRunCount++;
           adOverrunEvent();
        }
        
        // Process terminate event
        if (usEventType & ADS_EVT_TERMINATED)
        {
           adTerminateEvent();
           return ;
        }
        hdc=GetDC(hWnd);
        sprintf(szBuff,"Buff Change Count: %d", ulBuffCount );
        TextOut(hdc,200,50, szBuff, strlen(szBuff));
        sprintf(szBuff,"Interrupt Count: %d", ulInterruptCount );
        TextOut(hdc,200,70, szBuff, strlen(szBuff));
        sprintf(szBuff,"Overrun Count: %d", ulOverRunCount );
        TextOut(hdc,200,90, szBuff, strlen(szBuff));
        ReleaseDC(hWnd,hdc);
        bThreadflag = FALSE;
    }

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

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

//------------------------------------------------------------------
void adBufChangeEvent()
{
   HDC hdc;
   LPVOID temp;
   int i;
   
   ptFAICheck.ActiveBuf = &gwActiveBuf;
   ptFAICheck.stopped   = &gwStopped;
   ptFAICheck.retrieved = &gulRetrieved;
   ptFAICheck.overrun   = &gwOverrun;
   ptFAICheck.HalfReady = &gwHalfReady;
   
   if ((ErrCde = DRV_FAICheck(DriverHandle,
      (LPT_FAICheck)&ptFAICheck)) != 0)
   {
      DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
      MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
      return ;
   }
   ptFAITransfer.ActiveBuf = 0;   // single buffer
   ptFAITransfer.DataType = gwDataType;
   ptFAITransfer.start    = 0;
   ptFAITransfer.count    = gulConvNum;
   ptFAITransfer.overrun  = &gwOverrun;
   
   if ((ErrCde = DRV_FAITransfer(DriverHandle,
      (LPT_FAITransfer)&ptFAITransfer)) != 0)
   {
      DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
      MessageBox(hWnd,(LPCSTR)szErrMsg,"Thread Message",MB_OK);
      return ;
   }
   
   if (gwDataType == 0)
      temp = (USHORT far *)ptFAITransfer.DataBuffer;
   else
      temp = (FLOAT far *)ptFAITransfer.DataBuffer;
   
   hdc=GetDC(hWnd);     
   for(i = 0; i < 20; ++i)
   {        
      if (gwDataType == 0)
         sprintf(szBuffer, "Buf[%ld] = %4x",i, ((USHORT far *)temp)[i]);
      else
         sprintf(szBuffer, "Buf[%ld] = %10.6f", i, ((FLOAT far *)temp)[i]);
      TextOut( hdc, 200, 150 + 20*i, szBuffer, strlen(szBuffer));
   }
   ReleaseDC(hWnd,hdc);
   
   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);    

    // Get real voltage of buffer from driver
    ptFAITransfer.ActiveBuf = 0;   // single buffer
    ptFAITransfer.DataType = gwDataType;
    ptFAITransfer.start    = 0;
    ptFAITransfer.count    = gulConvNum;
    ptFAITransfer.overrun  = &gwOverrun;

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

    // Display data
    DialogBox (hInstance, MAKEINTRESOURCE(IDD_DATA),
        hWnd, lpfnShowDataDlgProc) ;

    // Free buffer
    GlobalUnlock(hUserBuf);
    GlobalFree(hUserBuf);
    DRV_FreeDMABuffer(DriverHandle, (LPARAM)&pBuffer);

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

    EnableMenuItem(hMenu, IDM_RUN, MF_ENABLED | MF_BYCOMMAND);
    bRun = FALSE;      
    
    return;
}