wdadmabm.cpp

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

   ptFAOWaveFormStart.EnabledChannel     = usEnabledChannel;   // which channel
   
   printf("\nNow outputting 10 waveform, please waiting...\n");
   if ((dwErrCde = DRV_FAOWaveFormStart(DriverHandle,
      (LPT_FAOWaveFormStart)&ptFAOWaveFormStart)) != 0)
   {
      ErrorHandler(dwErrCde);
      MyFreeBuffer();
      GlobalUnlock(hCommonBuf);
      GlobalFree(hCommonBuf);
      DRV_DeviceClose((LONG far *)&DriverHandle);
      printf("Program terminated!\n");
      printf("Press any key to exit....");
      getchar();
      return;
   }
   
   // if event feature is enabled , then create one thread.
   hThreadHandle = CreateThread(0, 0,
      (LPTHREAD_START_ROUTINE) UserThread,
      0, 0, (LPDWORD)&dwThreadID);
   bThreadloop = TRUE;
   WaitForSingleObject(hThreadHandle, INFINITE);
   CloseHandle(hThreadHandle);   // close thread handle

   // Step 7: Stop D/A conversion
   if ((dwErrCde = DRV_FAOTerminate(DriverHandle)) != 0)
   {
      ErrorHandler(dwErrCde);
      MyFreeBuffer();
      GlobalUnlock(hCommonBuf);
      GlobalFree(hCommonBuf);
      DRV_DeviceClose((LONG far *)&DriverHandle);
      printf("Program terminated!\n");
      printf("Press any key to exit....");
      getchar();
      return;
   }

   // Step 9: Free buffer
   MyFreeBuffer();
   GlobalUnlock(hCommonBuf);
   GlobalFree(hCommonBuf);

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

   printf("\n\nProgram end successfully!\n");
   printf("Press any key to exit....");
   getchar();
}

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.2831853*(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;
   case SINE_TRIANGLE:
      {
         ULONG x;
         double y;
         
         slope = lpWave->fMagnitude * 4.0f / (float)lpWave->wPeriod;
         for (i = 0; i < num; i ++)
         {
            if(i%2)
            {
               modf(((double)i/2.0),(double *)&y);
               y = y + 1;
               r = ((USHORT)y) % 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;
            }
            else
            {
               x = i/2;
               *(lpBuf+i) = (float)(lpWave->fMagnitude
                  * sin(6.28318*(double)x/(double)lpWave->wPeriod)
                  + lpWave->fOffset);
            }
         }
         break;
      }
   }
}

void SetMultiToOneBuffer(USHORT usEnabledChannel, int count)
{
   int i,TotalCount;
   
   TotalCount=0;
   
   for (i = 0; i < count; i ++)
   {
      if(usEnabledChannel & ADV_CHANNEL0)
      {
         ((USHORT far *)lpCommonBuf)[TotalCount] = 
            ((USHORT)((USHORT far *) lpBuf[0])[i]) & 0x0fff;
         TotalCount++;
      }
      if(usEnabledChannel & ADV_CHANNEL1)
      {
         ((USHORT far *)lpCommonBuf)[TotalCount] = 
            ((USHORT)((USHORT far *) lpBuf[1])[i] | ( 0x01 << 12)) & 0x3fff;
         TotalCount++;
      }
      if(usEnabledChannel & ADV_CHANNEL2)
      {
         ((USHORT far *)lpCommonBuf)[TotalCount] = 
            ((USHORT)((USHORT far *) lpBuf[2])[i] | ( 0x02 << 12)) & 0x3fff;
         TotalCount++;
      }
      if(usEnabledChannel & ADV_CHANNEL3)
      {
         ((USHORT far *)lpCommonBuf)[TotalCount] = 
            ((USHORT)((USHORT far *) lpBuf[3])[i] | ( 0x03 << 12)) & 0x3fff;
         TotalCount++;
      }
   }
}

void MyFreeBuffer()
{
   int i;
   
   for(i=0; i<4; i++)
   {
      
      if(hBuf[i]) 
      {
         GlobalFree(hBuf[i]);
         hBuf[i] = NULL;
      }
      if(hVoltageBuf[i])
      {
         GlobalFree(hVoltageBuf[i]);
         hVoltageBuf[i] = NULL;
      }
   }
}

void UserThread()
{
   USHORT usEventType;
   PT_CheckEvent     ptCheckEvent;   // Check event
   PT_FAOCheck		   ptFAOCheck;

   USHORT gwActiveBuf = 0;     // return by FAOCheck
   USHORT gwOverrun   = 0;     // return by FAOCheck
   USHORT gwStopped   = 0;     // return by FAOCheck
   ULONG  ulCurrentCount = 0;  // return by FAOCheck
   USHORT gwHalfReady = 0;     // return by FAOCheck
   USHORT gwUnderrun  = 0;
   ULONG gwTransfered = 0;
   
   while(bThreadloop)
   {
      // Check message
      ptCheckEvent.EventType = &usEventType;
      ptCheckEvent.Milliseconds = 100;
      
      DRV_CheckEvent(DriverHandle, (LPT_CheckEvent)&ptCheckEvent);
      
      // 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();

      // Get transfer status
      ptFAOCheck.ActiveBuf    = &gwActiveBuf;
      ptFAOCheck.stopped      = &gwStopped;
      ptFAOCheck.CurrentCount = &ulCurrentCount;
      ptFAOCheck.overrun      = &gwOverrun;
      ptFAOCheck.HalfReady    = &gwHalfReady;
	  ptFAOCheck.Underrun     = &gwUnderrun;
	  ptFAOCheck.Transfered   = &gwTransfered;
      DRV_FAOCheck(DriverHandle,(LPT_FAOCheck)&ptFAOCheck);
      printf("Wave Count  = %ld\r", ulCurrentCount);
   }
}

void adInterruptEvent()
{
   return;
}

void adBufChangeEvent()
{
   return;
}

void adOverrunEvent()
{
   return;
}

void adTerminateEvent()
{
   bThreadloop = FALSE;

   return;
}

/**********************************************************************
* Function: ErrorHandler
*           Show the error message for the corresponding error code
* input:    dwErrCde, IN, Error code
* return:   none
**********************************************************************/
void ErrorHandler(DWORD dwErrCde)
{
   char szErrMsg[180];
   
   DRV_GetErrorMessage(dwErrCde, szErrMsg);
   printf("\nError(%d): %s\n", dwErrCde & 0xffff, szErrMsg);
}//ErrorHandler