battif.c

WINCE 下电池驱动的源代码

        ghFileMap = NULL;
        ghMutex = NULL;
    }
    
    DEBUGMSG(ZONE_PDD, (_T("%s: returning %d\r\n"), pszFname, fOk));
    
    return fOk;
}

void WINAPI 
BatteryPDDDeinitialize(void)
{
    SETFNAME(_T("BatteryPDDDeinitialize"));

    DEBUGMSG(ZONE_PDD, (_T("%s: invoked\r\n"), pszFname));
    if(gpStatus != NULL && gpfnUnmapViewOfFile != NULL) gpfnUnmapViewOfFile(gpStatus);
    if(ghFileMap != NULL) CloseHandle(ghFileMap);
    if(ghMutex != NULL) CloseHandle(ghMutex);
    if(ghBattTouchMutex != NULL )CloseHandle( ghBattTouchMutex );
    ghBattTouchMutex = NULL ;
    gpStatus = NULL;
    ghFileMap = NULL;
    ghMutex = NULL;
    if(v_pIOPregs)
    {
        VirtualFree((void*)v_pIOPregs, sizeof(IOPreg), MEM_RELEASE);
        v_pIOPregs=NULL;
    }
    if(v_pADCregs)
    {   
        VirtualFree((void*)v_pADCregs, sizeof(ADCreg), MEM_RELEASE);
        v_pADCregs = NULL;
    }     
}

void WINAPI 
BatteryPDDResume(void)
{
    SETFNAME(_T("BatteryPDDResume"));

    DEBUGMSG(ZONE_PDD, (_T("%s: invoked\r\n"), pszFname));
}

void WINAPI 
BatteryPDDPowerHandler(BOOL bOff)
{
    SETFNAME(_T("BatteryPDDPowerHandler"));

    UNREFERENCED_PARAMETER(bOff);
    
    DEBUGMSG(ZONE_PDD | ZONE_RESUME, (_T("%s: invoked w/ bOff %d\r\n"), pszFname, bOff));
}

// This routine obtains the most current battery/power status available
// on the platform.  It fills in the structures pointed to by its parameters
// and returns TRUE if successful.  If there's an error, it returns FALSE.
BOOL WINAPI
BatteryPDDGetStatus(
                    PSYSTEM_POWER_STATUS_EX2 pstatus,
                    PBOOL pfBatteriesChangedSinceLastCall
                    )
{
    BOOL fOk = TRUE;
    static unsigned char ucTemp[10];
    static unsigned char ucIndex=0xff;
    unsigned char BatteryLifePercent;
    int iAdLevel;
    int i;
    SETFNAME(_T("BatteryPDDGetStatus"));
    
    DEBUGMSG(ZONE_PDD, (_T("%s: invoked w/ pstatus 0x%08x, pfChange 0x%08x\r\n"),
        pszFname, pstatus, pfBatteriesChangedSinceLastCall));
    
    DEBUGCHK(gpStatus != NULL);
    DEBUGCHK(pstatus != NULL);
    DEBUGCHK(pfBatteriesChangedSinceLastCall != NULL);
    
#if 1/*sensen ADD*/
	DEBUGCHK(v_pIOPregs!=NULL);
	if(v_pIOPregs->rGPGDAT&(1<<1))
	{
		(gpStatus->sps).ACLineStatus        = AC_LINE_OFFLINE;
	}
	else
	{
		(gpStatus->sps).ACLineStatus        = AC_LINE_ONLINE;
	}
	
	iAdLevel =ReadAdc( 1 );
	if(iAdLevel>=MAX_BATT_MAX_LEVEL)
	{
		BatteryLifePercent         = 100;
	}
	else if(iAdLevel<=MIN_BATT_MIN_LEVEL)
	{
		BatteryLifePercent         = 0; 
	}
	else
	{
		BatteryLifePercent = (iAdLevel-MIN_BATT_MIN_LEVEL)*100/(MAX_BATT_MAX_LEVEL-MIN_BATT_MIN_LEVEL);
	}
	if(ucIndex==0xff)
	{
		
		for(i=0;i<10;i++)
		{
			ucTemp[i]=BatteryLifePercent;
			
		}
		(gpStatus->sps).BatteryLifePercent=BatteryLifePercent;
		ucIndex = 0;
	}
	else
	{
		if(ucIndex>=10)
		{
			ucIndex=0;
		}
		ucTemp[ ucIndex++ ]=BatteryLifePercent;
		for(i=0,iAdLevel=0;i<10;i++)
		{
			iAdLevel+=ucTemp[i] ;
			
		}
		iAdLevel/=10;
		(gpStatus->sps).BatteryLifePercent=iAdLevel;
		
	}
	if(v_pIOPregs->rGPFDAT&(1<<7))
	{
		switch( (gpStatus->sps).BatteryLifePercent )
		{
			case BATTERY_FLAG_HIGH :
				if( (gpStatus->sps).BatteryLifePercent <50 )
				{
					(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_LOW;
				}
				break;
			case BATTERY_FLAG_LOW :
				if( (gpStatus->sps).BatteryLifePercent >=60)
				{
					(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_HIGH;
				}
				else if( (gpStatus->sps).BatteryLifePercent < 30 )
				{
					(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_CRITICAL;
				}
				break;
			case BATTERY_FLAG_CRITICAL :
				if( (gpStatus->sps).BatteryLifePercent >=35)
				{
					(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_LOW;
				}
				break;
			default:
				if( (gpStatus->sps).BatteryLifePercent >=50)
				{
					(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_HIGH;
				}
				else if( (gpStatus->sps).BatteryLifePercent >=30)
				{
					(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_LOW;
				}
				else
				{
					(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_CRITICAL;
				}
				break;
		}
#if 0
		if( (gpStatus->sps).BatteryLifePercent >=50)
		{
			(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_HIGH;
		}
		else if( (gpStatus->sps).BatteryLifePercent >=25)
		{
			(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_LOW;
		}
		else
		{
			(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_CRITICAL;
		}
#endif
	}
	else
	{
		(gpStatus->sps).BatteryFlag                = BATTERY_FLAG_CHARGING;
	}
    (gpStatus->sps).Reserved1                  = 0;
    (gpStatus->sps).BatteryLifeTime            = BATTERY_LIFE_UNKNOWN;
    (gpStatus->sps).BatteryFullLifeTime        = BATTERY_LIFE_UNKNOWN;
    (gpStatus->sps).Reserved2                  = 0;
    (gpStatus->sps).BackupBatteryFlag          = BATTERY_FLAG_UNKNOWN;
    (gpStatus->sps).BackupBatteryLifePercent   = BATTERY_PERCENTAGE_UNKNOWN;
    (gpStatus->sps).Reserved3                  = 0;
    (gpStatus->sps).BackupBatteryLifeTime      = BATTERY_LIFE_UNKNOWN;
    (gpStatus->sps).BackupBatteryFullLifeTime  = BATTERY_LIFE_UNKNOWN;
    (gpStatus->sps).BatteryChemistry           = BATTERY_CHEMISTRY_UNKNOWN;
    (gpStatus->sps).BatteryVoltage             = 0;
    (gpStatus->sps).BatteryCurrent             = 0;
    (gpStatus->sps).BatteryAverageCurrent      = 0;
    (gpStatus->sps).BatteryAverageInterval     = 0;
    (gpStatus->sps).BatterymAHourConsumed      = 0;
    (gpStatus->sps).BatteryTemperature         = 0;
    (gpStatus->sps).BackupBatteryVoltage       = 0;
#endif   
    // get battery status information from the shared structure
    LockBattery();
    memcpy(pstatus, &gpStatus->sps, sizeof(*pstatus));
    *pfBatteriesChangedSinceLastCall = TRUE/*gpStatus->fChanged*/;
    if(*pfBatteriesChangedSinceLastCall) {
        gpStatus->fChanged = FALSE;		// reset changed flag if it's set
    }
    UnlockBattery();
    
    DEBUGMSG(ZONE_PDD, (_T("%s: returning %d\r\n"), pszFname, fOk));
    return (fOk);
}


// This routine indicates how many battery levels will be reported
// in the BatteryFlag and BackupBatteryFlag fields of the PSYSTEM_POWER_STATUS_EX2
// filed in by BatteryPDDGetStatus().  This number ranges from 0 through 3 --
// see the Platform Builder documentation for details.  The main battery
// level count is reported in the low word of the return value; the count 
// for the backup battery is in the high word.
LONG
BatteryPDDGetLevels(
    void
   	)
{
    LONG lLevels;
    SETFNAME(_T("BatteryPDDPowerHandler"));

    DEBUGCHK(gpStatus != NULL);

    LockBattery();
    lLevels = MAKELONG (gpStatus->wMainLevels, gpStatus->wBackupLevels);
    UnlockBattery();

    DEBUGMSG(ZONE_PDD, (_T("%s: returning %u (%d main levels, %d backup levels)\r\n"),
        pszFname, lLevels, LOWORD(lLevels), HIWORD(lLevels)));

    return lLevels;
}



// This routine returns TRUE to indicate that the pfBatteriesChangedSinceLastCall
// value filled in by BatteryPDDGetStatus() is valid.  If there is no way to
// tell that the platform's batteries have been changed this routine should
// return FALSE.
BOOL
BatteryPDDSupportsChangeNotification(
    void
   	)
{
    BOOL fSupportsChange;
    SETFNAME(_T("BatteryPDDPowerHandler"));

    DEBUGCHK(gpStatus != NULL);

    LockBattery();
    fSupportsChange = TRUE/*gpStatus->fSupportsChange*/;
    UnlockBattery();

    DEBUGMSG(ZONE_PDD, (_T("%s: returning %d\r\n"), pszFname, fSupportsChange));

    return fSupportsChange;
}
int ReadAdc( BYTE ch )
{
	DWORD preScaler;
  	DWORD rADCCON_save = v_pADCregs->rADCCON;
  	int iRet =50;
  	int i;
  	DEBUGCHK(v_pIOPregs!=NULL);
  	if(ghBattTouchMutex )
  	{
  		WaitForSingleObject(ghBattTouchMutex, MUTEX_TIMEOUT);
  	}
  	preScaler = 49; //A/D converter freq = PCLK/(prescaler+1),这个值是根据你采样频率来设置。
  	v_pADCregs->rADCCON = (1<<14)|(preScaler<<6)|(ch<<3); //enable prescaler,set channel}
  
  	for(i = 0;i<500;i++); //delay to set up the channel

  	v_pADCregs->rADCCON|=0x1;   //start ADC

  	while(v_pADCregs->rADCCON & 0x1);   //check if Enable_start is low
  	while(!(v_pADCregs->rADCCON&0x8000));   //check if EC(End of Conversion) flag is high
	iRet = (int)v_pADCregs->rADCDAT0 & 0x3ff;
	v_pADCregs->rADCCON = rADCCON_save;
	if(ghBattTouchMutex)
	{
		ReleaseMutex(ghBattTouchMutex);
	}
  	return iRet; 

}