adc.cpp

wince下AD驱动模块的编写.已经编译通过.对于低成本的数据采集很有意义

// ADC.cpp : Defines the entry point for the DLL application.
//

#include <windows.h>
#include <tchar.h>
#include "C:\WINCE420\PUBLIC\COMMON\OAK\INC\nkintr.h"
#include <string.h>
#include "C:\WINCE420\PUBLIC\COMMON\OAK\INC\pkfuncs.h"
#include "C:\WINCE420\PLATFORM\SMDK2410\INC\s2410.h"
#include "C:\WINCE420\PLATFORM\SMDK2410\INC\oalintr.h"
//#include "adc.h"


HANDLE g_hevInterrupt;//中断事件句柄
HANDLE g_htIST;
DWORD dwThreadID;
volatile INTreg *pINTreg;

struct ADC_DEV{

	CRITICAL_SECTION	ADC_CS;//临界区
	volatile ADCreg 		*pADCreg;// 指向ADC寄存器的指针
	char					channel;//通道选择
	char					prescale;//预分频
	DWORD				OpenCnt;		// @field Protects use of this port 
	
}adcdev;
struct ADC_DEV *pADC_Dev;

//necessary entry in every DLL file
BOOL WINAPI DllEntryPoint ( HANDLE hinstDLL, 
							DWORD  dwReason, 
							LPVOID lpvReserved)
{	
	switch (dwReason)
	{
		case DLL_PROCESS_ATTACH:
			RETAILMSG(1,(TEXT("ADC:DLL_PROCESS_ATTACH\t\n")));
			return TRUE;
		case DLL_THREAD_ATTACH:
			RETAILMSG(1,(TEXT("ADC:DLL_THREAD_ATTACH\t\n")));
			break;
		case DLL_THREAD_DETACH:
			RETAILMSG(1,(TEXT("ADC:DLL_THREAD_DETACH\t\n")));
			break;
		case DLL_PROCESS_DETACH:
			RETAILMSG(1,(TEXT("ADC:DLL_PROCESS_DETACH\t\n")));
			break;
	#ifdef UNDER_CE
		case DLL_PROCESS_EXITING:
			RETAILMSG(1,(TEXT("ADC:DLL_PROCESS_EXITING\t\n")));
			break;
		case DLL_SYSTEM_STARTED:
			RETAILMSG(1,(TEXT("ADC:DLL_SYSTEM_STARTED\t\n")));
			break;
	#endif
		default:
			break;
	}
    return TRUE;
}

DWORD WINAPI AdcEventHandler(LPVOID a)//
{
		RETAILMSG(1,(TEXT("ADCEvent Handler,Waiting for Interrupution!\r\n")));
		////////////////////////Only for Test////////////////////////////
//		TCHAR RegValue1[20];
//		TCHAR RegValue2[20];
//		TCHAR MSGString[60];

		WaitForSingleObject(g_hevInterrupt,INFINITE);
//		RETAILMSG(1,(TEXT("Interruption has happend! Exit ADC Handler\r\n")));
		InterruptDone(SYSINTR_ADC);
		
		return 0;

}

void ADC_Init (void)
{
	pADC_Dev=&adcdev;
	pADC_Dev->pADCreg=(volatile ADCreg *)ADC_BASE;
	pINTreg=(volatile INTreg*)INT_BASE;
	InitializeCriticalSection(&(pADC_Dev->ADC_CS));
	
	/////////////////////Set the Rigisters of ADC//////////////////////////////
	pADC_Dev->pADCreg->rADCCON&=0x8000;//Enable Prescale
	//pADC_Dev->pADCreg->rADCCON&=0xfff8;//Normal operation mode,Disable start by read operation,No operation;
	////////////////////Set the Rigisters of ADC Over//////////////////////////

		////////////////Initialize Event/////////////////
	g_hevInterrupt = CreateEvent(NULL,FALSE,FALSE,NULL);//create event

	if(g_hevInterrupt==NULL)
	{
		RETAILMSG(1,(TEXT("Event creation failed!\r\n")));
		return;
	}

	//注册中断
	if(!InterruptInitialize(SYSINTR_ADC,g_hevInterrupt,NULL,0))
	{
		RETAILMSG(1,(TEXT("InterruptInitialize failed!\r\n")));
		return;
	}
		////////////////Initialize Event Over//////////////

	
}
/////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////
DWORD ADC_Open(HANDLE hDeviceContext,
			   DWORD AccessCode,
			   DWORD ShareMode)
{
	return(1);
}

BOOL ADC_Close(DWORD hOpenContext)
{
	return TRUE;
}


DWORD ADC_Deinit(DWORD dwDeviceContext)
{
	return FALSE;
}


BOOL ADC_IOControl(DWORD hOpenContext,
					DWORD dwCode,
					PBYTE pBufIn,
					DWORD dwLenIn,
					PBYTE pBufOut,
					DWORD dwLenOut,
					PDWORD pdwActualOut)
{
	return(TRUE);
}

////////////OK
DWORD ADC_Read(DWORD hOpenContext,
			   LPVOID pBuffer,
			   DWORD Count)
{
	//int m_nISTPriority;
	DWORD ReturnValue;
	RETAILMSG(1,(TEXT("ADC Read!\r\n")));
	////////////////Initialize Thread/////////////////
	g_htIST= CreateThread(NULL,
						  0,
						  AdcEventHandler,
						  NULL,
						  CREATE_SUSPENDED,
						  &dwThreadID);
	//设置优先级
	if(!CeSetThreadPriority(g_htIST,251))
	{
		RETAILMSG(1,(TEXT("ADC_READ: Failed setting Thread Priority.\r\n")));
		return 0;
	}
	//恢复IST
	ResumeThread(g_htIST);
	///////////////Initialize Thread Over///////////////
	
	///////////////////Enable ADC//////////////////
	
	EnterCriticalSection(&(pADC_Dev->ADC_CS));
//	RETAILMSG(1,(TEXT("ADC_READ: Entered Critical Section!\r\n")));
//	RETAILMSG(1,(TEXT("ADC_READ: ADCCON '%x'\r\n"),pADC_Dev->pADCreg->rADCCON));
	
	pADC_Dev->pADCreg->rADCCON|= 1;//Enable Convertion

	LeaveCriticalSection(&(pADC_Dev->ADC_CS));
//	RETAILMSG(1,(TEXT("ADC_READ: AD Conversion Enabled! Leave Critical Section!\r\n ")));
 

//	RETAILMSG(1,(TEXT("ADC_READ: ADCCON '%x'\r\n"),pADC_Dev->pADCreg->rADCCON));

	
	///////////////////Enable ADC Over/////////////

	///////////////////Wait for the ThreadObject////////////////
//	RETAILMSG(1,(TEXT("ADC_READ: Waiting For Event!\r\n")));
	ReturnValue=WaitForSingleObject(g_htIST ,50);
	
	//////////////////Wait for the Thread Object Over////////////

	if(ReturnValue==WAIT_OBJECT_0)
	{
		///////////////////Write Buffer/////////////////////////
		
		EnterCriticalSection(&(pADC_Dev->ADC_CS));

		*((DWORD *)pBuffer)=pADC_Dev->pADCreg->rADCDAT0;
		(*((DWORD *)pBuffer))&=0x03ff;

		RETAILMSG(1,(TEXT("ADC_READ: Read Success! ADCDAT0 '%x'\r\n"),*((DWORD *)pBuffer)));
		LeaveCriticalSection(&(pADC_Dev->ADC_CS));

		//////////////////Write Buffer Over/////////////////////

		return 4;
	}
	else if(ReturnValue==WAIT_TIMEOUT)
	{
		RETAILMSG(1,(TEXT("ADC_READ: Read Timeout! ADCDAT0:%x\r\n"),pADC_Dev->pADCreg->rADCDAT0&0x3ff));
//		RETAILMSG(1,(TEXT("ADC_READ: Thread Terminated!")));
		TerminateThread(g_htIST,0);
		return 1;
	}
	else
	{
		RETAILMSG(1,(TEXT("ADC_READ: Do Not Know What Was Wrong!\r\n")));
		return 0;
	}
}

///////////OK
DWORD ADC_Write(DWORD hOpenContext,
				LPCVOID pSourceBytes,
				DWORD NumberOfBytes)
{
	DWORD *ADCControl;
	EnterCriticalSection(&(pADC_Dev->ADC_CS));
	
	ADCControl=(DWORD *)pSourceBytes;
	pADC_Dev->pADCreg->rADCCON &= 0x8000;
	pADC_Dev->pADCreg->rADCCON|= 0x4000;
	pADC_Dev->pADCreg->rADCCON|=((*ADCControl)&0xff)<<6;
	pADC_Dev->pADCreg->rADCCON|=((*(++ADCControl))&7)<<3;

	LeaveCriticalSection(&(pADC_Dev->ADC_CS));
	 
	return 4;
}

/////////OK
DWORD ADC_Seek(DWORD hOpenContext,
			   long Amount,
			   DWORD Type)
{
	return FALSE;
}