addma.cpp

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

 * Function:   FreeDataBuffer
 *             Free data buffer theat allocated by function AllocateDataBuffer
 * Paramaters: lDrvHandle, IN, Driver handle.
 *             plDMABuf, IN/OUT, Address of DMA pointer 
 *             pUserBuf, IN, Address of user buffer 
 * return:     none
 **********************************************************************/
void FreeDataBuffer(long lDrvHandle, long *plDMABuf, void **pUserBuf)
{
      DRV_FreeDMABuffer(lDrvHandle, (LPARAM)plDMABuf);
      free(*pUserBuf);
}//FreeDataBuffer

/**********************************************************************
 * Function:   ErrorStop
 *             Close all resource and terminate program if
 *             error occur in running transfer. 
 * Paramaters: pDrvHandle, IN/OUT, pointer to Driver handle
 *             dwErrCde, IN, Error code.
 *             plDMABuf, IN, Address of DMA buffer allocated for transfer.
 *             pUserBuf, IN, Address of User buffer.
 * return:     none             
 **********************************************************************/
void ErrorStop(long *pDrvHandle, DWORD dwErrCde, long *plDMABuf, 
               void**pUserBuf)
{
    //Free resource 
    DRV_FAIStop(*pDrvHandle);
    FreeDataBuffer(*pDrvHandle, plDMABuf, pUserBuf);

    //Error message 
    ErrorHandler(dwErrCde);
    printf("Program terminated!\n");
    
    //Close device
    DRV_DeviceClose(pDrvHandle);

    printf("Press any key to exit....");
    getch();
    exit(0);
}//ErrorStop

/*********************************************************************
 * Function: UserThread
 * Parameters: pISamples, IN, the count of DMA convertion number
 * Return value: none
 * Purpose: Check the event and handle it
 ********************************************************************/

void UserThread(LPVOID pISamples)
{
	USHORT usEventType;
	LONG   ErrCde;
	
	while (bThreadloop) {
		ptCheckEvent.EventType    = &usEventType;
		ptCheckEvent.Milliseconds = INFINITE;

		if (ErrCde = DRV_CheckEvent(lDriverHandle, (LPT_CheckEvent)&ptCheckEvent)!=0) {
			printf("Check event error!\n");
			return;
		}

		if (usEventType & ADS_EVT_INTERRUPT)
            adInterruptEvent();
		
        // Process buffer change event
        if (usEventType & ADS_EVT_BUFCHANGE)
            adBufChangeEvent(*(int *)pISamples);
		
        // Process overrun event
        if (usEventType & ADS_EVT_OVERRUN)
            adOverrunEvent();
		
        // Process terminate event
        if (usEventType & ADS_EVT_TERMINATED)
        {
            adTerminateEvent(*(int *)pISamples);
			bThreadFlag = FALSE;
            return ;
        }
	}
			
}

/**********************************************************************
 * Function: adInterruptEvent
 * Parameters:
 * Return value:
 * Purpose: Handle the Interrupt event
***********************************************************************/

void adInterruptEvent()
{
	//add your own Interrupt code here
	//printf("Interrupt event happened\n");
	return;
}

/**********************************************************************
 * Function: adBufChangeEvent
 * Parameters: 
 * Return value:
 * Purpose: Handle the Buffer Change event
***********************************************************************/

void adBufChangeEvent(int ConvCount)
{
   USHORT usOverrun;
    
   ptFAITransfer.ActiveBuf = 0;
   ptFAITransfer.DataBuffer = pfUserBuf;
   ptFAITransfer.DataType = 1;
   ptFAITransfer.start = 0;
   ptFAITransfer.count = ConvCount;
   ptFAITransfer.overrun = &usOverrun;
   if ((ErrCde = DRV_FAITransfer(lDriverHandle,
      (LPT_FAITransfer)&ptFAITransfer)) != 0)
   {
      DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
      printf("%s\n", szErrMsg);
      return;
   }

	gwCyclicCount ++;
	printf("\nThe DMA is working...\nThe times of buffer changed:%d\n", gwCyclicCount);
	printf("\nCyclic model\n");
	printf("Status or Stop? (a:b):");

	return;
}

/**********************************************************************
 * Function: adOverrunEvent
 * Parameters: none
 * Return value: none
 * Purpose: Handle the Overrun event
***********************************************************************/

void adOverrunEvent()
{

	// clear overrun
    if ((ErrCde = DRV_ClearOverrun(lDriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        printf("\n%s\n", szErrMsg);
        return ;
    }

    return;
}


/**********************************************************************
 *Function: adTerminateEvent
 *Parameters:
 *Return value:
 *Purpose: Handle the Terminate event
***********************************************************************/

void adTerminateEvent(int ConvCount)
{
	// Stop A/D conversion
    USHORT usOverrun;
	if ((ErrCde = DRV_FAIStop(lDriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        printf("\n%s\n",szErrMsg);;
        return ;
    }

    // Get real voltage of buffer from driver
    ptFAITransfer.ActiveBuf = 0;   // single buffer
	ptFAITransfer.DataBuffer = pfUserBuf;
    ptFAITransfer.DataType = 1;    // float
    ptFAITransfer.start    = 0;   
    ptFAITransfer.count    = ConvCount;
    ptFAITransfer.overrun  = &usOverrun;

    if ((ErrCde = DRV_FAITransfer(lDriverHandle,
        (LPT_FAITransfer)&ptFAITransfer)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        printf("\n%s\n",szErrMsg);;
        return ;
    }

    // Display Data
	printf("\n");
	for (int i = 0; i < 100; i ++){
        printf("Buf[%ld] = %10.6f\n", i, pfUserBuf[i]);
    }

    bThreadloop = FALSE;
	Sleep(100);

    return;
}

void GetStatus(int gulConvNum)
{
	USHORT usActiveBuf;         //for PT_FAICheck to return data 
    USHORT usStopped;
    ULONG  ulRetrieved;
    USHORT usHalfReady;
	USHORT usOverrun;
	PT_FAICheck ptFAICheck;
	double ratio;
	
	ptFAICheck.ActiveBuf = &usActiveBuf;
	ptFAICheck.stopped   = &usStopped;
	ptFAICheck.HalfReady = &usHalfReady;
	ptFAICheck.retrieved = &ulRetrieved;
	ptFAICheck.overrun   = &usOverrun;

	if (ErrCde=DRV_FAICheck(lDriverHandle, (LPT_FAICheck)&ptFAICheck) != 0) {
		DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        printf("%s\n", szErrMsg);
        return ;
	}else{
		printf("\n*************************************************************\n");
		printf("Cyclic Counts: %d\n", gwCyclicCount);
		if (usHalfReady == 0)
			printf("Buffer : not  ready\n");
		else if (usHalfReady == 1)
			printf("Buffer : half ready\n");
		else if (usHalfReady == 2)
			printf("Buffer : full ready\n");
		else
			printf("Buffer : unknow \n");
		ratio = 100.0 * ulRetrieved / gulConvNum;
		printf("Finish:   %.2f%%\n", ratio);
		printf("*************************************************************\n");
	}
	return;

}

void Stop(int ConvCount)
{
	USHORT usOverrun;
		
	if ((ErrCde = DRV_FAIStop(lDriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        printf("\n%s\n",szErrMsg);;
        return ;
    }

	ptFAITransfer.ActiveBuf = 0;   // single buffer
	ptFAITransfer.DataBuffer = pfUserBuf;
    ptFAITransfer.DataType = 1;    // float
    ptFAITransfer.start    = 0;   
    ptFAITransfer.count    = ConvCount;
    ptFAITransfer.overrun  = &usOverrun;
	
    if ((ErrCde = DRV_FAITransfer(lDriverHandle,
        (LPT_FAITransfer)&ptFAITransfer)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        printf("\n%s\n",szErrMsg);;
        return ;
    }
	
    // Display Data
	printf("\n\n");
	printf("Cyclic number: %d\n", gwCyclicCount);
	for (int i = 0; i < 100; i ++){
        printf("Buf[%ld] = %10.6f\n", i, pfUserBuf[i]);
    }
	bThreadFlag = false;
	bThreadloop = false;
	Sleep(100);
}