1 files changed, 142 insertions, 8 deletions

diff --git a/firmware/powermgmt.c b/firmware/powermgmt.c
index 93d3192904..0db751161c 100644
--- a/firmware/powermgmt.c
+++ b/firmware/powermgmt.c
@@ -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");