addmabm.cpp

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

{
    //Free resource 
    DRV_FAIStop(*pDrvHandle);
	VirtualFree(
			hUserBuf,                   // base address of block
			2 * gulConvNum,             // bytes of committed pages
			MEM_DECOMMIT| MEM_RELEASE); // decommit the pages
    VirtualFree(
                hDisplayBuf,                   // base address of block
                2 * gulConvNum,             // bytes of committed pages
                MEM_DECOMMIT| MEM_RELEASE); // decommit the pages

    

    //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 usActiveBuf;         //for PT_FAICheck to return data 
    USHORT usStopped;
    ULONG  ulRetrieved;
    USHORT usHalfReady;
	USHORT usOverrun;
	PT_FAICheck ptFAICheck;

	ptFAICheck.ActiveBuf = &usActiveBuf; // not used for single buffer
	ptFAICheck.stopped   = &usStopped;   // returned status: 1: complete, 0: imcomplete
	ptFAICheck.retrieved = &ulRetrieved; // actual conversion count
	ptFAICheck.overrun   = &usOverrun;   // not used for non-cyclic mode
	ptFAICheck.HalfReady = &usHalfReady; // not used for single buffer

	if ((ErrCde=DRV_FAICheck(lDriverHandle,(LPT_FAICheck)&ptFAICheck) != 0)) {
		DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        printf("%s\n", szErrMsg);
        return ;
	}

	if(1 == usHalfReady){
		ptFAITransfer.ActiveBuf = 0;
		ptFAITransfer.DataType = gwDataType;
		ptFAITransfer.start = 0;
		ptFAITransfer.count = ConvCount/2;
		ptFAITransfer.overrun = &usHalfReady;
		if ((ErrCde = DRV_FAITransfer(lDriverHandle,
            (LPT_FAITransfer)&ptFAITransfer)) != 0)
        {
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            printf("%s\n", szErrMsg);
            return ;
        }
    }else if (2 == usHalfReady) {
		ptFAITransfer.ActiveBuf = 0;
		ptFAITransfer.DataType = gwDataType;
		ptFAITransfer.start = ConvCount/2;
		ptFAITransfer.count = ConvCount/2;
		ptFAITransfer.overrun = &usHalfReady;
		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);

	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;
	int i;
	char szData[40];
	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.DataType = gwDataType;    // 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 ( i=0; i<100; i++ )
    {
        if ( gwDataType )
        {
           sprintf( szData, "Buf[ %07d ]=%8.6f", i+ptFAITransfer.start, 
              ((float*)ptFAITransfer.DataBuffer)[i] );                                 
        }
        else
        {
           sprintf( szData, "Buf[ %07d ]=%   x", i+ptFAITransfer.start, 
              ((USHORT *)ptFAITransfer.DataBuffer)[i] );                                 
        }
        printf( "%s\n", szData );  
   }

	printf("\nPress any key to exit....");

    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;
	int i;
	char szData[80];
		
	if ((ErrCde = DRV_FAIStop(lDriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        printf("\n%s\n",szErrMsg);
        return ;
    }

	ptFAITransfer.ActiveBuf = 0;   // single buffer
    ptFAITransfer.DataType = gwDataType;    // 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 ( i=0; i<100; i++ )
    {
        if ( gwDataType )
        {
           sprintf( szData, "Buf[ %07d ]=%8.6f", i+ptFAITransfer.start, 
              ((float*)ptFAITransfer.DataBuffer)[i] );                                 
        }
        else
        {
           sprintf( szData, "Buf[ %07d ]=%   x", i+ptFAITransfer.start, 
              ((USHORT *)ptFAITransfer.DataBuffer)[i] );                                 
        }
        printf( "%s\n", szData );  
   }
    bThreadFlag = false;
	bThreadloop = false;
	printf("\nPress any key to exit....");
	Sleep(100);
}