maindlg.cpp

在WINCE 5.0 上基于Maxim 17040 电池采样测试程序

// maindlg.cpp : implementation of the CMainDlg class
//
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "resource.h"

#include "DebugOut.h"
#include "aboutdlg.h"
#include "maindlg.h"
#include "Monahans.h"
#include "xllp_i2c.h"
#include <ceddk.h>

#define LOGINGTIMER	1
#define SAMPLETIMER 2

DWORD	g_dwVOl[50] = {0};
DWORD	g_dwCnt = 0;
BYTE	g_byPrePercent = 0;

// 根据指定的注册表项来获得路径名，末尾带'\'
BOOL GetSpecialPathName(LPTSTR szName, size_t size, LPCTSTR szSpecial)
{
	LPCTSTR	c_szRegName = _T("Folder");
	DWORD   retCode;
    DWORD   dwType;
    DWORD   cbData;
    HKEY    hKey = NULL;
	TCHAR	*p = NULL;
	TCHAR	buf[MAX_PATH];
	
	if (!szName || size == 0)
		return FALSE;
	
	memset(szName, 0, size * sizeof(TCHAR));
	memset(buf, 0, sizeof(buf));
	
	retCode = RegOpenKeyEx (HKEY_LOCAL_MACHINE, szSpecial, 0, KEY_ALL_ACCESS, &hKey);
	if(retCode == ERROR_SUCCESS) {
		dwType = REG_SZ;
        cbData = (MAX_PATH-1)*sizeof(TCHAR);
        retCode = RegQueryValueEx(hKey, c_szRegName, NULL, &dwType, (LPBYTE) buf, (LPDWORD)&cbData);
        RegCloseKey(hKey);
		if(retCode != ERROR_SUCCESS)
			return FALSE;		
	}
	else {
		return FALSE;
	}
		
	p = buf + _tcslen(buf);
	if (p == buf || *(p-1) != _T('\\'))
	{
		*p = _T('\\');
		*(p+1) = _T('\0');
	}
	szName[0] = _T('\\');
	_tcsncat(szName, buf, size-2);
	
	return TRUE;
}

// 获得Flash存储器的路径名，末尾带'\'
BOOL GetFlashPathName(LPTSTR szName, size_t size)
{
	LPCTSTR	c_szRegPath[] =
	{
		_T("System\\StorageManager\\Profiles\\NandFls"),
		_T("System\\StorageManager\\Profiles\\SDMLC"),
		_T("System\\StorageManager\\Profiles\\iNand"),
	};
	
	for (int i = 0; i < sizeof(c_szRegPath) / sizeof(c_szRegPath[0]); i++)
	{
		if (GetSpecialPathName(szName, size, c_szRegPath[i]))
			return TRUE;
	}
	return FALSE;
}

// 获得sdmmc存储器的路径名，末尾带'\'
BOOL GetSdcardPathName(LPTSTR szName, size_t size)
{
	LPCTSTR	c_szRegPath[] =
	{
		 _T("System\\StorageManager\\Profiles\\sdmemory"),
		 _T("System\\StorageManager\\Profiles\\sdmmc"),
	};

	for (int i = 0; i < sizeof(c_szRegPath) / sizeof(c_szRegPath[0]); i++)
	{
		if (GetSpecialPathName(szName, size, c_szRegPath[i]))
			return TRUE;
	}
	return FALSE;
}

TCHAR g_szFlashPath[MAX_PATH] = {0};
TCHAR g_szSDMMCPath[MAX_PATH] = {0};

//=========================================================================================

#define MFP_SIZE 0x700

#define SLAVE_ADDRESS  0x6c>>1

#define I2C_MUTEX_NAME        TEXT("I2C_CONTROL")

#define MAX_SAP_VOL		5000			//mV
#define MIN_SAP_VOL		0

XLLP_VUINT32_T*		mfp_reg = NULL;
P_XLLP_OST_T        gs_pOstRegs = NULL;
P_XLLP_CLKMGR_T     gs_pClockRegs = NULL;
P_XLLP_I2C_T        gs_pi2cregs = NULL;

HANDLE g_hI2CMutex = NULL;
HANDLE g_hMfpRMDHandle = NULL;
volatile P_XLLP_MFP_RM_DB_ID_T g_pMfpRMDb = NULL;

static BOOL InitMFPRM()
{
    static BOOL bFirstInit=FALSE;

    g_hMfpRMDHandle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
            0, XLLP_MFP_RM_DB_SIZE, MFPRMDB_SHARED_FILENAME );

    if(g_hMfpRMDHandle == NULL )
    {
        NKDbgPrintfW(TEXT("[BATT] Fail to CreateFileMapping(MFPRMDB_SHARED_FILENAME)! \r\n"));;
        return FALSE;
    }

    if (ERROR_ALREADY_EXISTS != GetLastError()) 
    {
        // The first initialization of this memory-mapped file.
        bFirstInit = TRUE;
    }
	else 
    {
        // Memory-mapped file already existed.
        bFirstInit = FALSE;
    }

    g_pMfpRMDb = (P_XLLP_MFP_RM_DB_ID_T) MapViewOfFile(g_hMfpRMDHandle, FILE_MAP_ALL_ACCESS, 0, 0, 0 );
        
    if (NULL == g_pMfpRMDb )
    {
		NKDbgPrintfW(TEXT("[BATT] Fail to MapViewOfFile()!\r\n"));
		return FALSE;
    }

    if (TRUE == bFirstInit) 
    {
		// Need to Initialize RM    
        if (XLLP_STATUS_SUCCESS != XllpMfpResourceManagerInit(g_pMfpRMDb)) 
        {
            NKDbgPrintfW(TEXT("[BATT] Fail to XllpMfpResourceManagerInit()!\r\n"));
            return FALSE;
        }
    }
        
    return TRUE;
}

static void DeInitMFPRM()
{
	UnmapViewOfFile(g_pMfpRMDb);
	CloseHandle(g_hMfpRMDHandle);
}

static BOOL I2CInit()
{	
	XllpClockEnable((XLLP_CLKMGR_T*)gs_pClockRegs, XLLP_CLK_I2C, XLLP_TRUE);
    gs_pi2cregs->XLLP_ICR = XLLP_ICR_UR;

	if(XLLP_STATUS_SUCCESS!=XllpI2cInit((P_XLLP_I2C_T)gs_pi2cregs, (P_XLLP_VUINT32_T) mfp_reg, (P_XLLP_MFP_RM_DB_ID_T )g_pMfpRMDb, 0))
	{
		RETAILMSG(0, (TEXT("Batt: XllpI2cInit() failed!\r\n fxf")));
		return FALSE;
	}

	return TRUE;
}

static void Lock()
{
    WaitForSingleObject(g_hI2CMutex, INFINITE);
}
static void UnLock()
{
    ReleaseMutex(g_hI2CMutex);
}

static XLLP_STATUS_T ReadChipReg(XLLP_UINT8_T reg, XLLP_UINT8_T *value, XLLP_UINT32_T cnt)
{
    XLLP_STATUS_T ret;
	
    Lock();
	ret = XllpI2CWrite(gs_pi2cregs, gs_pOstRegs, SLAVE_ADDRESS, &reg, 1, XLLP_TRUE); 
	if (ret == XLLP_STATUS_SUCCESS) 
	{
		ret = XllpI2CRead(gs_pi2cregs, gs_pOstRegs, SLAVE_ADDRESS, value, cnt, XLLP_TRUE);
	}
	else
    	RETAILMSG(0, (_T("Batt I2C Write reading address Failed, Err: 0X%x\r\n"), ret));    
    UnLock();
	
    return ret;
}

static XLLP_STATUS_T WriteChipReg(XLLP_UINT8_T reg, XLLP_UINT8_T *value, XLLP_UINT32_T cnt)
{   
    XLLP_STATUS_T ret;
   	XLLP_UINT8_T buf[3];

	if(cnt != 2)
		return XLLP_STATUS_WRONG_PARAMETER;
	
	buf[0] = reg;
	buf[1] = *value;
	buf[2] = *(value+1);
	
    Lock();
	ret = XllpI2CWrite(gs_pi2cregs, gs_pOstRegs, SLAVE_ADDRESS, buf, 3, XLLP_TRUE);
    UnLock();
	
    return ret;
}

//------------------------------------------------------------------------------------------------------------
// Function: sampleADC
// 
// Purpose:  Given an axis this function will setup the ADC correctly and then do 
//           the needfull to collect a sample.        
//  
// Returns:  a status indicating the validity of the sample.
//
//-------------------------------------------------------------------------------------------------------------

#define VOL_FACTOR	1.25
#define REVERT_USHORT(a)	(unsigned short)((((a)>>8) & 0x0FF)|(((a)<<8) & 0xFF00))

static BOOL sampleADC(BYTE* pPercent, DWORD* pVol) 
{
	XLLP_STATUS_T ret = XLLP_STATUS_SUCCESS;
	unsigned short usPercent = 0;
	unsigned short usVol = 0;
	
	ret = ReadChipReg(0x02, (XLLP_UINT8_T *)&usVol, 2);
	if(ret == XLLP_STATUS_SUCCESS)
	{
		ret = ReadChipReg(0x04, (XLLP_UINT8_T *)&usPercent, 2);
		if(ret != XLLP_STATUS_SUCCESS)
		{
			RETAILMSG(0, (_T("Batt sampleADC Failed, Reg: 0X%x, Err: 0X%x\r\n"), 0x4, ret));
			return FALSE;
		}
	}
	else
	{
		RETAILMSG(0, (_T("Batt sampleADC Failed, Reg: 0X%x, Err: 0X%x\r\n"), 0x2, ret));
		return FALSE;
	}
	
	//RETAILMSG (1, (TEXT("BatteryDriver Sample Orign Register: Vol[%x], Percent[%x]\r\n"), usVol, usPercent));
	
	*pPercent = (BYTE)(usPercent & 0xFF);
	*pPercent = *pPercent > 100 ? 100 : *pPercent;

	usVol = REVERT_USHORT(usVol);
	usVol = (usVol >> 4) & 0x0FFF;
	*pVol = (DWORD)(usVol*VOL_FACTOR);
	*pVol = *pVol > MAX_SAP_VOL ? MAX_SAP_VOL : *pVol;

	//RETAILMSG (1, (TEXT("BatteryDriver Sample Actual: Vol[%d], Percent[%d]\r\n"), *pVol, *pPercent));
	return TRUE;
}

BOOL CMainDlg::PreTranslateMessage(MSG* pMsg)
{
	return CWindow::IsDialogMessage(pMsg);
}

BOOL CMainDlg::OnIdle()
{
	return FALSE;
}

LRESULT CMainDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
	// center the dialog on the screen
	CenterWindow();

	// set icons
	HICON hIcon = (HICON)::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_MAINFRAME), 
		IMAGE_ICON, ::GetSystemMetrics(SM_CXICON), ::GetSystemMetrics(SM_CYICON), LR_DEFAULTCOLOR);
	SetIcon(hIcon, TRUE);
	HICON hIconSmall = (HICON)::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_MAINFRAME), 
		IMAGE_ICON, ::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR);
	SetIcon(hIconSmall, FALSE);

	// register object for message filtering and idle updates
	CMessageLoop* pLoop = _Module.GetMessageLoop();
	ATLASSERT(pLoop != NULL);
	pLoop->AddMessageFilter(this);
	pLoop->AddIdleHandler(this);

	UIAddChildWindowContainer(m_hWnd);
	
	GetFlashPathName(g_szFlashPath, MAX_PATH);
	GetSdcardPathName(g_szSDMMCPath, MAX_PATH);
	
	PHYSICAL_ADDRESS PA;
    USHORT value = 0;
    XLLP_STATUS_T ret = XLLP_STATUS_SUCCESS;
	
	if (NULL == mfp_reg)
	{
		PA.QuadPart = MONAHANS_BASE_REG_PA_MFP;
		mfp_reg = (XLLP_VUINT32_T*)MmMapIoSpace(PA, MFP_SIZE, FALSE);
	}

	if (NULL == gs_pOstRegs)
    {
        PA.QuadPart = MONAHANS_BASE_REG_PA_OST;
        gs_pOstRegs = (P_XLLP_OST_T)MmMapIoSpace(PA, sizeof(XLLP_OST_T), FALSE);
    }     
	  	
    if (NULL == gs_pClockRegs)
    {
        PA.QuadPart  = MONAHANS_BASE_REG_PA_CLKMGR;
        gs_pClockRegs  = (P_XLLP_CLKMGR_T) MmMapIoSpace(PA, sizeof(XLLP_CLKMGR_T), FALSE);
    }

	if (NULL == gs_pi2cregs)
    {
    	PA.QuadPart = MONAHANS_BASE_REG_PA_I2C;
		gs_pi2cregs = (XLLP_I2C_T*)MmMapIoSpace(PA, sizeof(XLLP_I2C_T), FALSE);
    }

	g_hI2CMutex = CreateMutex(NULL, FALSE, I2C_MUTEX_NAME);
    if( g_hI2CMutex == NULL)
    {
        RETAILMSG(1, (_T("CreateMutex ERROR\r\n")));
        return FALSE;