Finally, merged the improved power code from Uwe Freese:
- The battery level (percentage) is more realistic and considers if the charger is on. - It considers the "lazyness" a battery shows when the charging has just turned on or off (see below). But this is not perfect by now. - The battery level is good enough to estimate the remaining running time and the remaining charging time. And so the info screen now shows this info. - The maximum time of a charging cycle is now dynamically calculated out of the battery level (percentage) and is not a fixed value. - A minimum of 60 minutes is waited after a charging cycle stops before another one starts. - Added another screen in the battery debug screen (press down three times). git-svn-id: svn://svn.rockbox.org/rockbox/trunk@2913 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Björn Stenberg
parent
67938f3451
commit
f09c5f4c63
|
|
@ -78,9 +78,8 @@ bool dbg_os(void)
|
|||
}
|
||||
|
||||
lcd_update();
|
||||
sleep(HZ/10);
|
||||
|
||||
button = button_get(false);
|
||||
button = button_get_w_tmo(HZ/10);
|
||||
|
||||
switch(button)
|
||||
{
|
||||
|
|
@ -112,9 +111,7 @@ bool dbg_os(void)
|
|||
snprintf(buf, 32, "%d: %d%% ", currval, usage);
|
||||
lcd_puts(0, 1, buf);
|
||||
|
||||
sleep(HZ/10);
|
||||
|
||||
button = button_get(false);
|
||||
button = button_get_w_tmo(HZ/10);
|
||||
|
||||
switch(button)
|
||||
{
|
||||
|
|
@ -333,7 +330,7 @@ bool dbg_partitions(void)
|
|||
lcd_puts(0, 0, "Partition");
|
||||
lcd_puts(0, 1, "list");
|
||||
lcd_update();
|
||||
sleep(HZ);
|
||||
sleep(HZ/2);
|
||||
|
||||
while(1)
|
||||
{
|
||||
|
|
@ -431,9 +428,7 @@ bool dbg_ports(void)
|
|||
lcd_puts(0, 7, buf);
|
||||
|
||||
lcd_update();
|
||||
sleep(HZ/10);
|
||||
|
||||
button = button_get(false);
|
||||
button = button_get(HZ/10);
|
||||
|
||||
switch(button)
|
||||
{
|
||||
|
|
@ -513,9 +508,7 @@ bool dbg_ports(void)
|
|||
snprintf(buf, 32, "Batt: %d.%02dV", batt_int, batt_frac);
|
||||
lcd_puts(0, 1, buf);
|
||||
|
||||
sleep(HZ/5);
|
||||
|
||||
button = button_get(false);
|
||||
button = button_get_w_tmo(HZ/5);
|
||||
|
||||
switch(button)
|
||||
{
|
||||
|
|
@ -566,9 +559,8 @@ bool dbg_rtc(void)
|
|||
}
|
||||
|
||||
lcd_update();
|
||||
sleep(HZ/2);
|
||||
|
||||
button = button_get(false);
|
||||
button = button_get_w_tmo(HZ/2);
|
||||
|
||||
switch(button)
|
||||
{
|
||||
|
|
@ -623,9 +615,8 @@ bool dbg_mas(void)
|
|||
}
|
||||
|
||||
lcd_update();
|
||||
sleep(HZ/16);
|
||||
|
||||
switch(button_get(false))
|
||||
switch(button_get_w_tmo(HZ/16))
|
||||
{
|
||||
#ifdef HAVE_RECORDER_KEYPAD
|
||||
case BUTTON_DOWN:
|
||||
|
|
@ -674,9 +665,8 @@ bool dbg_mas_codec(void)
|
|||
}
|
||||
|
||||
lcd_update();
|
||||
sleep(HZ/16);
|
||||
|
||||
switch(button_get(false))
|
||||
switch(button_get_w_tmo(HZ/16))
|
||||
{
|
||||
case BUTTON_DOWN:
|
||||
addr += 4;
|
||||
|
|
@ -805,12 +795,42 @@ bool view_battery(void)
|
|||
lcd_puts(0, i+1, buf);
|
||||
}
|
||||
break;
|
||||
|
||||
case 3: /* remeining time estimation: */
|
||||
lcd_clear_display();
|
||||
lcd_puts(0, 0, "Remaining time:");
|
||||
|
||||
snprintf(buf, 30, "Cycle time: %d m", powermgmt_last_cycle_startstop_min);
|
||||
lcd_puts(0, 1, buf);
|
||||
|
||||
snprintf(buf, 30, "Lev.at cycle start: %d%%", powermgmt_last_cycle_level);
|
||||
lcd_puts(0, 2, buf);
|
||||
|
||||
snprintf(buf, 30, "Last PwrHist val: %d.%02d V",
|
||||
power_history[POWER_HISTORY_LEN-1] / 100,
|
||||
power_history[POWER_HISTORY_LEN-1] % 100);
|
||||
lcd_puts(0, 3, buf);
|
||||
|
||||
snprintf(buf, 30, "Lazy time amount: %d%%",
|
||||
(powermgmt_last_cycle_startstop_min < 20)
|
||||
? battery_lazyness[powermgmt_last_cycle_startstop_min]
|
||||
: 0);
|
||||
lcd_puts(0, 4, buf);
|
||||
|
||||
snprintf(buf, 30, "resulting act.lev: %d%%", battery_level());
|
||||
lcd_puts(0, 5, buf);
|
||||
|
||||
snprintf(buf, 30, "Est. remaining: %d m", powermgmt_est_runningtime_min);
|
||||
lcd_puts(0, 6, buf);
|
||||
|
||||
#ifdef HAVE_CHARGE_CTRL
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
|
||||
lcd_update();
|
||||
sleep(HZ/2);
|
||||
|
||||
switch(button_get(false))
|
||||
switch(button_get_w_tmo(HZ/2))
|
||||
{
|
||||
case BUTTON_UP:
|
||||
if (view)
|
||||
|
|
@ -818,7 +838,7 @@ bool view_battery(void)
|
|||
break;
|
||||
|
||||
case BUTTON_DOWN:
|
||||
if (view < 2)
|
||||
if (view < 3)
|
||||
view++;
|
||||
break;
|
||||
|
||||
|
|
|
|||
|
|
@ -1162,3 +1162,7 @@ desc: show only playlist
|
|||
eng: "Playlists"
|
||||
new:
|
||||
|
||||
id: LANG_BATTERY_TIME
|
||||
desc: battery level in % and estimated time remaining
|
||||
eng: "%d%% %dh %dm"
|
||||
new:
|
||||
|
|
|
|||
|
|
@ -183,21 +183,13 @@ bool show_info(void)
|
|||
#endif
|
||||
lcd_puts(0, y++, s);
|
||||
|
||||
#ifdef HAVE_LCD_CHARCELLS
|
||||
snprintf(s, sizeof(s), str(LANG_BATTERY_LEVEL_PLAYER),
|
||||
battery_level(), battery_level_safe() ? "" : "!");
|
||||
#else
|
||||
#ifdef HAVE_CHARGE_CTRL
|
||||
if (charger_enabled)
|
||||
snprintf(s, sizeof(s), str(LANG_BATTERY_CHARGE));
|
||||
else
|
||||
snprintf(s, sizeof(s), str(LANG_BATTERY_LEVEL_RECORDER),
|
||||
battery_level(), battery_level_safe() ? "" : " !!");
|
||||
#else
|
||||
snprintf(s, sizeof(s), str(LANG_BATTERY_LEVEL_RECORDER),
|
||||
battery_level(), battery_level_safe() ? "" : " !!");
|
||||
#endif
|
||||
#endif
|
||||
snprintf(s, sizeof(s), str(LANG_BATTERY_TIME), battery_level(),
|
||||
battery_time() / 60, battery_time() % 60);
|
||||
lcd_puts(0, y++, s);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -41,6 +41,11 @@ int battery_level(void)
|
|||
return 100;
|
||||
}
|
||||
|
||||
int battery_time(void)
|
||||
{
|
||||
return 500;
|
||||
}
|
||||
|
||||
bool battery_level_safe(void)
|
||||
{
|
||||
return true;
|
||||
|
|
@ -58,18 +63,62 @@ static int poweroff_idle_timeout_value[15] =
|
|||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 30, 45, 60
|
||||
};
|
||||
|
||||
static int percent_to_volt_nocharge[11] = /* voltages (centivolt) of 0%, 10%, ... 100% when charging disabled */
|
||||
{
|
||||
450, 481, 491, 497, 503, 507, 512, 514, 517, 528, 560
|
||||
};
|
||||
|
||||
static int percent_to_volt_charge[11] = /* voltages (centivolt) of 0%, 10%, ... 100% when charging enabled */
|
||||
{
|
||||
476, 544, 551, 556, 561, 564, 566, 576, 582, 584, 585
|
||||
};
|
||||
|
||||
int battery_lazyness[20] = /* how does the battery react when plugging in/out the charger */
|
||||
{
|
||||
0, 17, 31, 42, 52, 60, 67, 72, 77, 81, 84, 87, 89, 91, 92, 94, 95, 95, 96, 97
|
||||
};
|
||||
|
||||
static char power_stack[DEFAULT_STACK_SIZE];
|
||||
static char power_thread_name[] = "power";
|
||||
|
||||
static int poweroff_timeout = 0;
|
||||
static long last_charge_time = 0;
|
||||
static int powermgmt_est_runningtime_min = -1;
|
||||
|
||||
unsigned short power_history[POWER_HISTORY_LEN];
|
||||
#ifdef HAVE_CHARGE_CTRL
|
||||
char power_message[POWER_MESSAGE_LEN] = "";
|
||||
char charge_restart_level = CHARGE_RESTART_HI;
|
||||
|
||||
int powermgmt_last_cycle_startstop_min = 20; /* how many minutes ago was the charging started or stopped? */
|
||||
int powermgmt_last_cycle_level = 0; /* which level had the batteries at this time? */
|
||||
#endif
|
||||
|
||||
|
||||
int battery_time(void)
|
||||
{
|
||||
return powermgmt_est_runningtime_min;
|
||||
}
|
||||
|
||||
/* look into the percent_to_volt_* table and get a realistic battery level percentage */
|
||||
int voltage_to_percent(int voltage, int* table)
|
||||
{
|
||||
if (voltage <= table[0])
|
||||
return 0;
|
||||
else
|
||||
if (voltage >= table[10])
|
||||
return 100;
|
||||
else {
|
||||
/* search nearest value */
|
||||
int i = 0;
|
||||
while ((i < 10) && (table[i+1] < voltage))
|
||||
i++;
|
||||
/* interpolate linear between the smaller and greater value */
|
||||
return i * 10 /* 10th */
|
||||
+ (voltage - table[i]) * 10 / (table[i+1] - table[i]); /* 1th */
|
||||
}
|
||||
}
|
||||
|
||||
/* Returns battery level in percent */
|
||||
int battery_level(void)
|
||||
{
|
||||
|
|
@ -95,7 +144,33 @@ int battery_level(void)
|
|||
if(level < BATTERY_LEVEL_EMPTY)
|
||||
level = BATTERY_LEVEL_EMPTY;
|
||||
|
||||
return ((level-BATTERY_LEVEL_EMPTY) * 100) / BATTERY_RANGE;
|
||||
/* level now stores the voltage in centivolts */
|
||||
/* let's calculate a percentage now with using the voltage arrays */
|
||||
|
||||
#ifdef HAVE_CHARGE_CTRL
|
||||
if (powermgmt_last_cycle_startstop_min < 20) {
|
||||
/* the batteries are lazy, so take a value between the result of the two table lookups */
|
||||
if (charger_enabled)
|
||||
level = (voltage_to_percent(level, percent_to_volt_charge)
|
||||
* battery_lazyness[powermgmt_last_cycle_startstop_min]
|
||||
+ voltage_to_percent(level, percent_to_volt_nocharge)
|
||||
* (100 - battery_lazyness[powermgmt_last_cycle_startstop_min])) / 100;
|
||||
else
|
||||
level = (voltage_to_percent(level, percent_to_volt_nocharge)
|
||||
* battery_lazyness[powermgmt_last_cycle_startstop_min]
|
||||
+ voltage_to_percent(level, percent_to_volt_charge)
|
||||
* (100 - battery_lazyness[powermgmt_last_cycle_startstop_min])) / 100;
|
||||
} else {
|
||||
if (charger_enabled)
|
||||
level = voltage_to_percent(level, percent_to_volt_charge);
|
||||
else
|
||||
level = voltage_to_percent(level, percent_to_volt_nocharge);
|
||||
}
|
||||
#else
|
||||
level = voltage_to_percent(level, percent_to_volt_nocharge); /* always use the nocharge table */
|
||||
#endif
|
||||
|
||||
return level;
|
||||
}
|
||||
|
||||
/* Tells if the battery level is safe for disk writes */
|
||||
|
|
@ -180,6 +255,8 @@ static void power_thread(void)
|
|||
#ifdef HAVE_CHARGE_CTRL
|
||||
int delta;
|
||||
int charged_time = 0;
|
||||
int charge_max_time_now = 0;
|
||||
int charge_pause = 0; /* no charging pause at the beginning */
|
||||
#endif
|
||||
|
||||
while (1)
|
||||
|
|
@ -215,18 +292,43 @@ static void power_thread(void)
|
|||
/* insert new value in the end, in centivolts 8-) */
|
||||
power_history[POWER_HISTORY_LEN-1] = (avg * BATTERY_SCALE_FACTOR) / 10000;
|
||||
|
||||
/* calculate estimated remaining running time */
|
||||
/* not charging: remaining running time */
|
||||
/* charging: remaining charging time */
|
||||
#ifdef HAVE_CHARGE_CTRL
|
||||
if (charger_enabled)
|
||||
/* if taking the nocharge battery level, charging lasts 30% longer than the value says */
|
||||
/* so consider it because there's the battery lazyness inside the the battery_level */
|
||||
if (powermgmt_last_cycle_startstop_min < 20) {
|
||||
i = (100 - battery_lazyness[powermgmt_last_cycle_startstop_min]) * 30 / 100 ; /* 0..30 */
|
||||
powermgmt_est_runningtime_min = (100 - battery_level()) * BATTERY_CAPACITY / 100 * (100 + i) / 100 * 60 / CURRENT_CHARGING;
|
||||
} else {
|
||||
powermgmt_est_runningtime_min = (100 - battery_level()) * BATTERY_CAPACITY / 100 * 60 / CURRENT_CHARGING;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
powermgmt_est_runningtime_min = battery_level() * BATTERY_CAPACITY / 100 * 60 / CURRENT_NORMAL;
|
||||
|
||||
#ifdef HAVE_CHARGE_CTRL
|
||||
|
||||
if (charge_pause > 0)
|
||||
charge_pause--;
|
||||
|
||||
if (charger_inserted()) {
|
||||
if (charger_enabled) {
|
||||
/* charger inserted and enabled */
|
||||
charged_time++;
|
||||
if (charged_time > CHARGE_MAX_TIME) {
|
||||
DEBUGF("power: charged_time > CHARGE_MAX_TIME, enough!\n");
|
||||
snprintf(power_message, POWER_MESSAGE_LEN, "Chg %dm max %dm", charged_time, charge_max_time_now);
|
||||
|
||||
if (charged_time > charge_max_time_now) {
|
||||
DEBUGF("power: charged_time > charge_max_time_now, enough!\n");
|
||||
/* have charged too long and deltaV detection did not work! */
|
||||
powermgmt_last_cycle_level = battery_level();
|
||||
powermgmt_last_cycle_startstop_min = 0;
|
||||
charger_enable(false);
|
||||
snprintf(power_message, POWER_MESSAGE_LEN, "Chg tmout %d min", CHARGE_MAX_TIME);
|
||||
/* Perhaps we should disable charging for several
|
||||
hours from this point, just to be sure. */
|
||||
snprintf(power_message, POWER_MESSAGE_LEN, "Chg tmout %d min", charge_max_time_now);
|
||||
/* disable charging for several hours from this point, just to be sure */
|
||||
charge_pause = CHARGE_PAUSE_LEN;
|
||||
} else {
|
||||
if (charged_time > CHARGE_MIN_TIME) {
|
||||
/* have charged continuously over the minimum charging time,
|
||||
|
|
@ -244,8 +346,12 @@ static void power_thread(void)
|
|||
|
||||
if (delta < -100) { /* delta < -10 mV */
|
||||
DEBUGF("power: short-term negative delta, enough!\n");
|
||||
powermgmt_last_cycle_level = battery_level();
|
||||
powermgmt_last_cycle_startstop_min = 0;
|
||||
charger_enable(false);
|
||||
snprintf(power_message, POWER_MESSAGE_LEN, "end negd %d %dmin", delta, charged_time);
|
||||
/* disable charging for several hours from this point, just to be sure */
|
||||
charge_pause = CHARGE_PAUSE_LEN;
|
||||
} else {
|
||||
/* if we didn't disable the charger in the previous test, check for low positive delta */
|
||||
delta = ( power_history[POWER_HISTORY_LEN-1] * 100
|
||||
|
|
@ -256,8 +362,12 @@ static void power_thread(void)
|
|||
|
||||
if (delta < 1) { /* delta < 0.1 mV */
|
||||
DEBUGF("power: long-term small positive delta, enough!\n");
|
||||
powermgmt_last_cycle_level = battery_level();
|
||||
powermgmt_last_cycle_startstop_min = 0;
|
||||
charger_enable(false);
|
||||
snprintf(power_message, POWER_MESSAGE_LEN, "end lowd %d %dmin", delta, charged_time);
|
||||
/* disable charging for several hours from this point, just to be sure */
|
||||
charge_pause = CHARGE_PAUSE_LEN;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -266,15 +376,33 @@ static void power_thread(void)
|
|||
/* charged inserted but not enabled */
|
||||
/* if battery is not full, enable charging */
|
||||
if (battery_level() < charge_restart_level) {
|
||||
if (charge_pause) {
|
||||
DEBUGF("power: batt level < restart level, but charge pause, not enabling\n");
|
||||
snprintf(power_message, POWER_MESSAGE_LEN, "chg pause %d min", charge_pause);
|
||||
} else {
|
||||
/* calculate max charge time depending on current battery level */
|
||||
/* take 20% more because battery level is not linear */
|
||||
charge_max_time_now = CHARGE_MAX_TIME * (100 + 30 - battery_level()) / 100;
|
||||
if (charge_max_time_now > CHARGE_MAX_TIME) {
|
||||
charge_max_time_now = CHARGE_MAX_TIME;
|
||||
}
|
||||
snprintf(power_message, POWER_MESSAGE_LEN, "ChgAt %d%% max %dm", battery_level(), charge_max_time_now);
|
||||
|
||||
/* enable the charger after the max time calc is done, because battery_level */
|
||||
/* depends on if the charger is on */
|
||||
DEBUGF("power: charger inserted and battery not full, enabling\n");
|
||||
charger_enable(true);
|
||||
powermgmt_last_cycle_level = battery_level();
|
||||
powermgmt_last_cycle_startstop_min = 0;
|
||||
charged_time = 0;
|
||||
|
||||
charger_enable(true);
|
||||
|
||||
/* clear the power history so that we don't use values before
|
||||
* discharge for the long-term delta
|
||||
*/
|
||||
for (i = 0; i < POWER_HISTORY_LEN-1; i++)
|
||||
power_history[i] = power_history[POWER_HISTORY_LEN-1];
|
||||
snprintf(power_message, POWER_MESSAGE_LEN, "Chg started at %d%%", battery_level());
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
|
@ -282,11 +410,15 @@ static void power_thread(void)
|
|||
if (charger_enabled) {
|
||||
/* charger not inserted but was enabled */
|
||||
DEBUGF("power: charger disconnected, disabling\n");
|
||||
powermgmt_last_cycle_level = battery_level();
|
||||
powermgmt_last_cycle_startstop_min = 0;
|
||||
charger_enable(false);
|
||||
snprintf(power_message, POWER_MESSAGE_LEN, "Charger disc");
|
||||
}
|
||||
/* charger not inserted and disabled, so we're discharging */
|
||||
}
|
||||
powermgmt_last_cycle_startstop_min++;
|
||||
|
||||
#endif /* HAVE_CHARGE_CTRL*/
|
||||
|
||||
/* sleep for roughly a minute */
|
||||
|
|
@ -303,6 +435,8 @@ void power_init(void)
|
|||
/* initialize the history with a single sample to prevent level
|
||||
flickering during the first minute of execution */
|
||||
power_history[POWER_HISTORY_LEN-1] = (adc_read(ADC_UNREG_POWER) * BATTERY_SCALE_FACTOR) / 10000;
|
||||
/* calculate the remaining time to that the info screen displays something useful */
|
||||
powermgmt_est_runningtime_min = battery_level() * BATTERY_CAPACITY / 100 * 60 / CURRENT_NORMAL;
|
||||
|
||||
#ifdef HAVE_CHARGE_CTRL
|
||||
snprintf(power_message, POWER_MESSAGE_LEN, "Powermgmt started");
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
#define BATTERY_LEVEL_SHUTDOWN 450 /* 4.5V */
|
||||
#define BATTERY_LEVEL_EMPTY 465 /* 4.65V */
|
||||
#define BATTERY_LEVEL_DANGEROUS 475 /* 4.75V */
|
||||
#define BATTERY_LEVEL_FULL 520 /* 5.2V */
|
||||
#define BATTERY_LEVEL_FULL 585 /* 5.85V */
|
||||
|
||||
#define BATTERY_RANGE (BATTERY_LEVEL_FULL - BATTERY_LEVEL_EMPTY)
|
||||
|
||||
|
|
@ -39,15 +39,27 @@
|
|||
|
||||
#ifdef HAVE_CHARGE_CTRL
|
||||
#define POWER_MESSAGE_LEN 32 /* power thread status message */
|
||||
#define CHARGE_MAX_TIME 6*60 /* minutes: maximum charging time */
|
||||
#define CHARGE_MAX_TIME 8*60 /* minutes: maximum charging time */
|
||||
#define CHARGE_MIN_TIME 10 /* minutes: minimum charging time */
|
||||
#define CHARGE_RESTART_HI 95 /* %: when to restart charging in 'charge' mode */
|
||||
#define CHARGE_RESTART_LO 10 /* %: when to restart charging in 'discharge' mode */
|
||||
#define CHARGE_PAUSE_LEN 60 /* how many minutes to pause between charging cycles */
|
||||
|
||||
extern char power_message[POWER_MESSAGE_LEN];
|
||||
extern char charge_restart_level;
|
||||
|
||||
extern int powermgmt_last_cycle_startstop_min; /* how many minutes ago was the charging started or stopped? */
|
||||
extern int powermgmt_last_cycle_level; /* which level had the batteries at this time? */
|
||||
|
||||
extern int battery_lazyness[20]; /* how does the battery react when plugging in/out the charger */
|
||||
|
||||
#endif /* HAVE_CHARGE_CTRL */
|
||||
|
||||
#define BATTERY_CAPACITY 1800 /* battery capacity in mAh for runtime estimation */
|
||||
#define CURRENT_NORMAL 145 /* usual current in mA when using the AJB including some disk/backlight/... activity */
|
||||
#define CURRENT_BACKLIGHT 30 /* additional current when backlight is always on */
|
||||
#define CURRENT_CHARGING 300 /* charging current */
|
||||
|
||||
extern unsigned short power_history[POWER_HISTORY_LEN];
|
||||
|
||||
/* Start up power management thread */
|
||||
|
|
@ -57,6 +69,7 @@ void power_init(void);
|
|||
|
||||
/* Returns battery level in percent */
|
||||
int battery_level(void);
|
||||
int battery_time(void); /* minutes */
|
||||
|
||||
/* Tells if the battery level is safe for disk writes */
|
||||
bool battery_level_safe(void);
|
||||
|
|
|
|||
Loading…
Reference in New Issue