adt700_impl.cpp

ADT700的小程序

// ADT700_Impl.cpp: implementation of the CADT700_Impl class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ADT700_Impl.h"
#include <nkintr.h>
#include <ceddk.h>
#include <giisr.h>
#include "Pkfuncs.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
/*
void WriteMsg(int i,int j,float fValue)
{
	FILE *fp;
	fp=fopen("\\look.htm","ab+");
	if(fp==0)
		return;
	char str[100];
	memset(str,0,100);
	sprintf(str,"Channel:%d,Num:%d,Value:%f\r\n",i,j,fValue);
	fputs(str,fp);
	fclose(fp);
}
*/

void WriteMsg(int i,float nValue)
{
	return;
	FILE *fp;
	fp=fopen("\\adt650.htm","ab+");
	if(fp==0)
		return;
	char strMsg[20];
	sprintf(strMsg,"%d:%f\r\n",i,nValue);
	fputs(strMsg,fp);
	fclose(fp);
}

DWORD  WINAPI  ThreadIST( LPVOID lpvParam )
{
	int nPosIndex=0;
	DWORD  dwStatus;
	BOOL  fState = TRUE;
	CADT700_Impl *gObj=(CADT700_Impl *)lpvParam;
	// Always chec the running flag
	//
	while(gObj->m_fRun )
	{
		dwStatus  = WaitForSingleObject(gObj->m_hISTInterruptEvent, INFINITE);

		// Check to see if we are finished
		//
		if(!gObj->m_fRun ) 
			return 0;

		// Make sure we have the object
		//
		if( dwStatus == WAIT_OBJECT_0 )
		{
			//	MessageBox(0,_T("susceadl!"),_T("hgoodasdf!@"),MB_OK);
			gObj->m_bBusy=true;
			while (gObj->ADT700_ConversionDone() == 1);
			gObj->m_fGatheredVolt[gObj->m_nDataStoreIndex][gObj->m_Channel]=gObj->ADT700_ReadData();
			if(gObj->m_Channel ==0)
				WriteMsg(gObj->m_Channel,gObj->m_fGatheredVolt[gObj->m_nDataStoreIndex][gObj->m_Channel]);

			gObj->ADT700_ClearIRQ();     //  清除中断
			if(nPosIndex>gObj->m_Channel)
			{
				gObj->m_nDataStoreIndex++;
				gObj->m_nDataStoreIndex=gObj->m_nDataStoreIndex%GATHERNUM;
			}
			nPosIndex=gObj->m_Channel;
			InterruptDone( gObj->m_SysIntr );

			if(nPosIndex+1==CHANNELNUM&&gObj->m_nDataStoreIndex==0)
				gObj->m_bBusy =false;
			else
				gObj->ADT700_StartConversion ();
//			WriteMsg(gObj->m_Channel ,gObj->m_nDataStoreIndex ,gObj->m_fGatheredVolt[gObj->m_nDataStoreIndex][gObj->m_Channel]);
		}
	}

  return 0;
}

void CADT700_Impl::WriteErrorMsg()
{
	return;
	FILE *fp;
	fp=fopen("\\error.txt","ab+");
	if(fp==0)
		return;
	char str[20];
	memset(str,0,20);
	sprintf(str,"Error:%d\r\n",ErrorCode);
	fputs(str,fp);
	fclose(fp);
}

CADT700_Impl::CADT700_Impl()
{
	m_fIsMapped=FALSE;
	m_fRun=FALSE;
	m_hISTInterruptEvent=0;
	m_SysIntr=0;
	m_Channel=0;
	m_VoltageRange=10;
	m_ConversionFactor=0;
	m_Baseline=0;
	m_nUseNumber=0;
	m_BaseAddr=0;
	memset(m_fGatheredVolt,0,sizeof(float)*GATHERNUM*CHANNELNUM);  //存储采集到的数据
	m_nDataStoreIndex=0;  //the position index of data store
	ErrorCode=0;
	for(int i=0;i<6;i++)
	{
		m_arrFrequency[i].fFrequency=0;
		m_arrFrequency[i].nLastNum=-1;
		m_arrFrequency[i].nLastTime=-1;
		m_arrFrequency[i].nMaxCounter=65535;
	}

	m_bBusy=false;
	m_nTimerID=-1;
}

CADT700_Impl::~CADT700_Impl()
{

}



HANDLE CADT700_Impl::ADT700_DevLoad()
{
	ErrorCode=1000;
	WriteErrorMsg();
	if(m_nUseNumber>0)
	{
		ErrorCode=100;
		WriteErrorMsg();
		return m_BaseAddr;
	}

	m_nDataStoreIndex=0;

	HANDLE hReAddress=INVALID_HANDLE_VALUE;
	DWORD IrqResource,dwBaseAddress;
	WCHAR IsrDllName[20],IsrFunName[20];
	DWORD dwStatus, dwSize, dwValue, dwType;

	memset(IsrDllName,0,sizeof(WCHAR)*20);
	memset(IsrFunName,0,sizeof(WCHAR)*20);

	HKEY hk;
	dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Drivers\\IOCards\\ADT700"), 0, 0, &hk);
	if(dwStatus == ERROR_SUCCESS) 
	{
		dwSize = sizeof(dwValue);
		//Read m_SysIntr value
		dwStatus = RegQueryValueEx(hk, _T("SysIntr"), NULL, &dwType, (LPBYTE) &dwValue, &dwSize);
		if(dwStatus == ERROR_SUCCESS && dwType == REG_DWORD)
		{
			m_SysIntr = dwValue;
		}
		else
		{
			RegCloseKey(hk);
			ErrorCode=1;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}

		//read Irq
		dwStatus = RegQueryValueEx(hk, _T("IrqResource"), NULL, &dwType, (LPBYTE) &dwValue, &dwSize);
		if(dwStatus == ERROR_SUCCESS && dwType == REG_DWORD) 
		{
			IrqResource = dwValue;
		}
		else
		{
			RegCloseKey(hk);
			ErrorCode=2;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}

		//read baseaddress
		dwStatus = RegQueryValueEx(hk, _T("BaseAddr"), NULL, &dwType, (LPBYTE) &dwValue, &dwSize);
		if(dwStatus == ERROR_SUCCESS && dwType == REG_DWORD) 
		{
			dwBaseAddress = dwValue;
			ErrorCode=dwBaseAddress;
			WriteErrorMsg();
		}
		else
		{
			ErrorCode=3;
			RegCloseKey(hk);
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}
		//read IsrDllName
		dwSize=20*sizeof(WCHAR);
		dwStatus = RegQueryValueEx(hk, _T("IsrDllName"), NULL, &dwType, (LPBYTE) &IsrDllName, &dwSize);
		if(dwStatus == ERROR_SUCCESS && dwType == REG_SZ) ;
		else
		{
			RegCloseKey(hk);
			ErrorCode=dwStatus;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}

		//read IsrFunName
		dwSize=20*sizeof(WCHAR);
		dwStatus = RegQueryValueEx(hk, _T("IsrFunName"), NULL, &dwType, (LPBYTE) &IsrFunName, &dwSize);
		if(dwStatus == ERROR_SUCCESS && dwType == REG_SZ);
		else
		{
			RegCloseKey(hk);
			ErrorCode=dwStatus;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}
		RegCloseKey(hk);

		//
		HANDLE  hHandle=LoadIntChainHandler(IsrDllName,IsrFunName,IrqResource);
		if(hHandle==NULL||hHandle==INVALID_HANDLE_VALUE)
		{
			ErrorCode=14;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}
		
		GIISR_INFO Info;
		memset(&Info,0,sizeof(GIISR_INFO));
		PVOID dwPhysAddr=0;
		DWORD inIoSpace = 1;    // io space
		PHYSICAL_ADDRESS PortAddress  = {dwBaseAddress, 0};
		
		if (!TransBusAddrToStatic(Isa, 0, PortAddress, sizeof(DWORD), &inIoSpace, &dwPhysAddr)) 
		{
			ErrorCode=13;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}
		if(KernelIoControl( IOCTL_HAL_REQUEST_SYSINTR,
                &IrqResource,
                sizeof(IrqResource),
                &m_SysIntr,
                sizeof(m_SysIntr),
                NULL )==FALSE)
		{
			ErrorCode=6;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}
		
		// Set up ISR handler
		Info.SysIntr = m_SysIntr;
		Info.CheckPort = TRUE;
		Info.PortIsIO = TRUE;
		Info.UseMaskReg = FALSE;
		Info.PortAddr = (DWORD)((PUCHAR)dwPhysAddr+ENABLE_IRQ);
		Info.PortSize = sizeof(BYTE);
		Info.Mask = 0x4;

        
		if (!KernelLibIoControl(hHandle, IOCTL_GIISR_INFO, &Info, sizeof(Info), NULL, 0, NULL)) 
		{
			KernelIoControl( IOCTL_HAL_RELEASE_SYSINTR,
                &m_SysIntr,
                sizeof(m_SysIntr),
                NULL,
                0,
                NULL );
		//	MessageBox(0,_T("KernelLibIoControl error"),_T("sdrlsadf"),MB_OK);
			ErrorCode=7;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}
		//
		// Translate IO address 
		//
		ULONG fInIoSpace = TRUE;	// io space  
		PHYSICAL_ADDRESS MappedAddress;
		if ( ! HalTranslateBusAddress( Isa, 0, PortAddress, &fInIoSpace, &MappedAddress)) 
		{
			//	MessageBox(0,_T("HalTranslateBusAddress error"),_T("sdrlsadf"),MB_OK);
			KernelIoControl( IOCTL_HAL_RELEASE_SYSINTR,
                &m_SysIntr,
                sizeof(m_SysIntr),
                NULL,
                0,
                NULL );
			ErrorCode=8;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}
		
		if ( fInIoSpace )
		{
			hReAddress = (HANDLE) MappedAddress.LowPart;
			m_fIsMapped = FALSE;
		}
		else 
		{
			hReAddress = (HANDLE) MmMapIoSpace(MappedAddress, 0xFF, FALSE);
			m_fIsMapped = TRUE;
		}
		
		m_fRun=TRUE;
		m_hISTInterruptEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
		if (m_hISTInterruptEvent == NULL)
		{	
			//MessageBox(0,_T("CreateEvent error"),_T("sdrlsadf"),MB_OK);
			KernelIoControl( IOCTL_HAL_RELEASE_SYSINTR,
							&m_SysIntr,
							sizeof(m_SysIntr),
							NULL,
							0,
							NULL );
			ErrorCode=9;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}
		
		DWORD dwThreadID;
		HANDLE g_htIST      = CreateThread(NULL,  // Security
			0,     // No Stack Size
			ThreadIST,  // Interrupt Thread                
			(LPVOID)this,    // No Parameters
			CREATE_SUSPENDED, // Create Suspended
			&dwThreadID  // Thread Id
			);
		// Set the thread priority – arbitrarily 5
		//
		int nISTPriority = 5;
		if( !CeSetThreadPriority( g_htIST, nISTPriority ))
		{
			KernelIoControl( IOCTL_HAL_RELEASE_SYSINTR,
										&m_SysIntr,
										sizeof(m_SysIntr),
										NULL,
										0,
										NULL );
			//MessageBox(0,_T("CeSetThreadPriority error"),_T("sdrlsadf"),MB_OK);
			ErrorCode=10;
			WriteErrorMsg();
			return INVALID_HANDLE_VALUE;
		}
		
		if (!InterruptInitialize(m_SysIntr, m_hISTInterruptEvent, NULL, NULL) )
		{
		//	MessageBox(0,_T("InterruptInitialize error"),_T("sdrlsadf"),MB_OK);
			KernelIoControl( IOCTL_HAL_RELEASE_SYSINTR,
							&m_SysIntr,
							sizeof(m_SysIntr),
							NULL,
							0,
							NULL );