battdrvr.cpp

freescale i.mx31 BSP CE5.0全部源码

//      pfBatteriesChangedSinceLastCall
//          [in] Pointer to a flag that the function sets to TRUE if the user replaced or changed 
//                  the system's batteries since the last call to this function. 
//
// Returns:
//      TRUE if success FALSE if error
//
//-----------------------------------------------------------------------------
BOOL WINAPI BatteryPDDGetStatus(PSYSTEM_POWER_STATUS_EX2 pstatus, PBOOL pfBatteriesChangedSinceLastCall)
{
    BATT_INFO    BattInfo;       // batt information structure obtained from bsp layer
    DWORD batt_V;
    DWORD charger_V;
    BOOL    fCharge;
    BOOL    fChargeTemp;
    DWORD current;
    
    DEBUGMSG(ZONE_FUNCTION, (TEXT("BatteryPDDGetStatus\r\n")));    
    
    //Get Info from BSP layer
    if(BSPBattdrvrGetInfo(&BattInfo) != TRUE)

    { 
        ERRORMSG(TRUE, (TEXT("BSPBattdrvrGetInfo fail !!\r\n")));
        return FALSE;
    }  

    if(BSPBattdrvrGetParameters(&batt_V, &charger_V, &fCharge, &current) != TRUE)
    { 
        ERRORMSG(TRUE, (TEXT("BSPBattdrvrGetParameters fail !!\r\n")));
        pstatus->ACLineStatus = AC_LINE_UNKNOWN;
        pstatus->BatteryFlag = BATTERY_FLAG_UNKNOWN;
        return FALSE;
    } 

#if FAKE_CHARGER  
    pstatus->ACLineStatus = AC_LINE_ONLINE;
    capacity = Batt_FullCapacity*C_HR_TO_SEC;       //in mAsec
#else
    // update the ACLineStatus according to charger threshold voltage
    if (charger_V < BattInfo.charger_V_limit )
        pstatus->ACLineStatus = AC_LINE_OFFLINE;
    else
        pstatus->ACLineStatus = AC_LINE_ONLINE;
#endif

    if (charger_V < BattInfo.charger_V_limit)
        next_state = STATE_DISCHARGING_WITHOUTCHARGER;
    // determine whether battery is available according to the min batt voltage from batt spec
    // there are two reasons for battery voltage under minvoltage, one is no battery, other is dead battery
    // since ADC battery range from 2.5V-4.65V, so we can not distinguish no battery and dead battery when 
    // voltage under Batt_MinVoltage(2.5V), we consider it as no battery
    else if (batt_V <= BattInfo.adc_batt_min_V) //Batt_MinVoltage
    {
        DEBUGMSG(ZONE_BATTERY, (TEXT("No Battery!!!\r\n"))); 
        next_state = STATE_EXTERNAL;     
    } 
    else if (batt_V < Batt_BATTLVoltage)
    {
        if (prev_state != STATE_NORMALCHARGING && prev_state != STATE_DISCHARGING_WITHCHARGER)
            next_state = STATE_TRICKLECHARGING_I;
    }
    else if (batt_V < Batt_BATTONVoltage)
    {
        if (prev_state != STATE_NORMALCHARGING && prev_state != STATE_DISCHARGING_WITHCHARGER)
            next_state = STATE_TRICKLECHARGING_II;
    }
    else if (batt_V <= VOLTAGE_LIMIT_VALUE)
    {
        if ((VOLTAGE_LIMIT_VALUE - batt_V) > VOLTAGE_LIMIT_DELTA)
            next_state = STATE_NORMALCHARGING;
        //Check if complete charging
        else if (IS_NORMALCHARGING(prev_state))
        {
            if (abs(batt_V - VOLTAGE_LIMIT_VALUE) < VOLTAGE_LIMIT_DELTA)  
            {
                timesForCurrentCount++;
                totalCurrent += current;
                if (timesForCurrentCount >= CURRENT_COUNT_CALC_TIMES)
                {
                    if ((totalCurrent/timesForCurrentCount) < CHARGE_END_CURRENT)
                    {
                         next_state = STATE_DISCHARGING_WITHCHARGER;
                    }    
                    timesForCurrentCount = 0;
                    totalCurrent = 0;
                }
            }
        }

    }
    else // Batt_v > VOLTAGE_LIMIT_VALUE
        next_state = STATE_DISCHARGING_WITHCHARGER;

    switch(next_state)
    {
    case STATE_TRICKLECHARGING_I:
        if (IS_NORMALCHARGING(prev_state))
            BSPBattdrvrDisableCharger();
        if (prev_state != STATE_TRICKLECHARGING_I)
            BSPBattdrvrSetTrickleCurrent(TRICKLEL);
        break;

    case STATE_TRICKLECHARGING_II:
        if (IS_NORMALCHARGING(prev_state))
            BSPBattdrvrDisableCharger();
        if (prev_state != STATE_TRICKLECHARGING_II)
            BSPBattdrvrSetTrickleCurrent(TRICKLEM);
        break;
    case STATE_NORMALCHARGING:
        if (IS_TRICKLECHARGING(prev_state))
            BSPBattdrvrSetTrickleCurrent(TRICKLEN); //Disable trickle charging
        
        if (BSPBattdrvrIsChargeDetect())
        {
            BSPBattdrvrDisableCharger();
            BSPBattdrvrSetCharger(VOLTAGE_LIMIT_LEVEL, CURRENT_LIMIT_LEVEL);
            BSPBattdrvrClearChargeDetectFlag();
        }
        else if (!IS_NORMALCHARGING(prev_state))
        {
            BSPBattdrvrSetCharger(VOLTAGE_LIMIT_LEVEL, CURRENT_LIMIT_LEVEL);
        }
        break;

    case STATE_DISCHARGING_WITHCHARGER:
        if (IS_TRICKLECHARGING(prev_state))
            BSPBattdrvrSetTrickleCurrent(TRICKLEN); //Disable trickle charging

        if (IS_NORMALCHARGING(prev_state))
        {
            BSPBattdrvrDisableCharger();
        }
        break;

    case STATE_DISCHARGING_WITHOUTCHARGER:
        if (IS_TRICKLECHARGING(prev_state))
            BSPBattdrvrSetTrickleCurrent(TRICKLEN); //Disable trickle charging
        if (IS_NORMALCHARGING(prev_state))
        {
            BSPBattdrvrDisableCharger();
        }
        break;

    case STATE_EXTERNAL:
        if (IS_TRICKLECHARGING(prev_state))
            BSPBattdrvrSetTrickleCurrent(TRICKLEN); //Disable trickle charging
        if (IS_NORMALCHARGING(prev_state))
            BSPBattdrvrDisableCharger();
        //tread it as dead battery ??
        //Upate pstatus:
        pstatus->BatteryFlag =  BATTERY_FLAG_NO_BATTERY;
        pstatus->BatteryLifePercent = 0;
        pstatus->Reserved1 = 0;
        pstatus->BatteryLifeTime = 0;
        pstatus->BatteryFullLifeTime =  0;
        pstatus->Reserved2 = 0;
        pstatus->BackupBatteryFlag = BATTERY_FLAG_UNKNOWN;
        pstatus->BackupBatteryLifePercent = 0;
        pstatus->Reserved3 = 0;
        pstatus->BackupBatteryLifeTime = BATTERY_LIFE_UNKNOWN;
        pstatus->BackupBatteryFullLifeTime = BATTERY_LIFE_UNKNOWN;
        pstatus->BatteryChemistry = BATTERY_CHEMISTRY_UNKNOWN;
        pstatus->BatteryVoltage = 0; 
        pstatus->BatteryCurrent = 0;
        pstatus->BatteryAverageCurrent = 0;
        pstatus->BatteryAverageInterval = 0;
        pstatus->BatterymAHourConsumed = 0;
        pstatus->BatteryTemperature = 0;
        pstatus->BackupBatteryVoltage = 0;

        *pfBatteriesChangedSinceLastCall = FALSE;

        goto END;
        break; //Never reach here

    case STATE_OTHERS:
        break;

    default:
        break;
    }

  
    // update the SYSTEM_POWER_STATUS_EX2 structure
    if (pstatus->ACLineStatus == AC_LINE_ONLINE)    
    {
        if (IS_NORMALCHARGING(next_state))
        {
            timesForBtteryVoltage ++;
            if ((timesForBtteryVoltage >= BATTERY_VOL_CALC_TIMES) || (percentage_charging == 0))
            {
                BSPBattdrvrDisableCharger();
                BSPBattdrvrGetParameters(&batt_V, &charger_V, &fChargeTemp, &current);
                BSPBattdrvrSetCharger(VOLTAGE_LIMIT_LEVEL, CURRENT_LIMIT_LEVEL);
                percentage_charging = 100*(batt_V - Batt_MinVoltage)/(Batt_MaxVoltage - Batt_MinVoltage);
                timesForBtteryVoltage = 0;   
            }
            percentage = percentage_charging;
        }
    }
    else
    {
        percentage = 
                100*(batt_V - Batt_MinVoltage)/(Batt_MaxVoltage - Batt_MinVoltage);
        percentage_charging = 0;
    }

    if (percentage > 100)
        percentage = 100;
    
    // Level Indicator 
    if(percentage >= LIMIT_HIGH)   
        pstatus->BatteryFlag  = BATTERY_FLAG_HIGH;
    else if (( percentage <LIMIT_HIGH) && (percentage >=LIMIT_LOW))
        pstatus->BatteryFlag  = BATTERY_FLAG_LOW;
    else if(percentage<=LIMIT_LOW)
        pstatus->BatteryFlag  = BATTERY_FLAG_CRITICAL;

    if (IS_NORMALCHARGING(next_state) || IS_TRICKLECHARGING(next_state))    //charging
        pstatus->BatteryFlag  = BATTERY_FLAG_CHARGING;

    pstatus->BatteryLifePercent = (BYTE)percentage;
    pstatus->Reserved1 = 0;
    pstatus->BatteryLifeTime = (DWORD) (percentage*Batt_FullLifeTime);
    pstatus->BatteryFullLifeTime = Batt_FullLifeTime*C_HR_TO_SEC;
    pstatus->Reserved2 = 0;
    pstatus->BackupBatteryFlag = BATTERY_FLAG_UNKNOWN;
    pstatus->BackupBatteryLifePercent = 0;
    pstatus->Reserved3 = 0;
    pstatus->BackupBatteryLifeTime = BATTERY_LIFE_UNKNOWN;
    pstatus->BackupBatteryFullLifeTime = BATTERY_LIFE_UNKNOWN;
    pstatus->BatteryChemistry = BATTERY_CHEMISTRY_LION;
    pstatus->BatteryVoltage = batt_V; 
    pstatus->BatteryCurrent = 0;
    pstatus->BatteryAverageCurrent = 0;
    pstatus->BatteryAverageInterval = 0;
    pstatus->BatterymAHourConsumed = 0;
    pstatus->BatteryTemperature = 0;
    pstatus->BackupBatteryVoltage = 0;
    
    *pfBatteriesChangedSinceLastCall = FALSE;

END:
    prev_state = next_state;

    return TRUE;
}


//-----------------------------------------------------------------------------
//
// Function: BatteryPDDGetLevels
//
// 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.
//
// Parameters:
//      void
//
// Returns:
//      Number of battery levels
//
//-----------------------------------------------------------------------------
long BatteryPDDGetLevels(void)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+BatteryPDDGetLevels\r\n")));
    LONG lLevels = MAKELONG (3 /* main battery levels   */,  
                             3 /* backup battery levels */);
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-BatteryPDDGetLevels\r\n")));
    return lLevels;
}


//-----------------------------------------------------------------------------
//
// Function: BatteryPDDSupportsChangeNotification
//
// 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.
//
// Parameters:
//      void
//
// Returns:
//      false
//
//-----------------------------------------------------------------------------
BOOL BatteryPDDSupportsChangeNotification(void)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+BatteryPDDSupportsChangeNotification\r\n")));
    BOOL fSupportsChange = FALSE;
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-BatteryPDDSupportsChangeNotification\r\n")));
    return fSupportsChange;
}