X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fprint_battery_info.c;h=8c85192f20f916b6544921e2740b0e0ce0424f58;hb=52e9f6f63b74db2a6a1d67524851649b18794950;hp=f131601ddd4f1fe220512493b7c3843b789e7753;hpb=9970af67e59dfbc758f6158a187c56fa4f3b557a;p=i3%2Fi3status diff --git a/src/print_battery_info.c b/src/print_battery_info.c index f131601..8c85192 100644 --- a/src/print_battery_info.c +++ b/src/print_battery_info.c @@ -1,25 +1,35 @@ // vim:ts=4:sw=4:expandtab #include -#include -#include -#include #include +#include +#include +#include #include #include #include "i3status.h" -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) +#if defined(LINUX) +#include +#include #include -#include -#include #endif -#if defined(__OpenBSD__) +#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) +#include +#include #include -#include +#endif + +#if defined(__DragonFly__) #include +#endif + +#if defined(__OpenBSD__) #include +#include +#include +#include #endif #if defined(__NetBSD__) @@ -28,39 +38,105 @@ #include #endif +typedef enum { + CS_UNKNOWN, + CS_DISCHARGING, + CS_CHARGING, + CS_FULL, +} charging_status_t; + +/* A description of the state of one or more batteries. */ struct battery_info { - int present_rate; + /* measured properties */ + int full_design; /* in uAh */ + int full_last; /* in uAh */ + int remaining; /* in uAh */ + int present_rate; /* in uA, always non-negative */ + + /* derived properties */ int seconds_remaining; float percentage_remaining; charging_status_t status; }; +#if defined(__DragonFly__) +#define ACPIDEV "/dev/acpi" +static int acpifd; + +static bool acpi_init(void) { + if (acpifd == 0) { + acpifd = open(ACPIDEV, O_RDWR); + if (acpifd == -1) + acpifd = open(ACPIDEV, O_RDONLY); + if (acpifd == -1) + return false; + } + return true; +} +#endif + +#if defined(LINUX) || defined(__NetBSD__) /* - * Estimate the number of seconds remaining in state 'status'. - * - * Assumes a constant (dis)charge rate. + * Add batt_info data to acc. */ -#if defined(LINUX) || defined(__NetBSD__) -static int seconds_remaining_from_rate(charging_status_t status, float full_design, float remaining, float present_rate) { - if (status == CS_CHARGING) - return 3600.0 * (full_design - remaining) / present_rate; - else if (status == CS_DISCHARGING) - return 3600.0 * remaining / present_rate; - else - return 0; +static void add_battery_info(struct battery_info *acc, const struct battery_info *batt_info) { + if (acc->remaining < 0) { + /* initialize accumulator so we can add to it */ + acc->full_design = 0; + acc->full_last = 0; + acc->remaining = 0; + acc->present_rate = 0; + } + + acc->full_design += batt_info->full_design; + acc->full_last += batt_info->full_last; + acc->remaining += batt_info->remaining; + + /* make present_rate negative for discharging and positive for charging */ + int present_rate = (acc->status == CS_DISCHARGING ? -1 : 1) * acc->present_rate; + present_rate += (batt_info->status == CS_DISCHARGING ? -1 : 1) * batt_info->present_rate; + + /* merge status */ + switch (acc->status) { + case CS_UNKNOWN: + acc->status = batt_info->status; + break; + + case CS_DISCHARGING: + if (present_rate > 0) + acc->status = CS_CHARGING; + /* else if batt_info is DISCHARGING: no conflict + * else if batt_info is CHARGING: present_rate should indicate that + * else if batt_info is FULL: but something else is discharging */ + break; + + case CS_CHARGING: + if (present_rate < 0) + acc->status = CS_DISCHARGING; + /* else if batt_info is DISCHARGING: present_rate should indicate that + * else if batt_info is CHARGING: no conflict + * else if batt_info is FULL: but something else is charging */ + break; + + case CS_FULL: + if (batt_info->status != CS_UNKNOWN) + acc->status = batt_info->status; + /* else: retain FULL, since it is more specific than UNKNOWN */ + break; + } + + acc->present_rate = abs(present_rate); } #endif -static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen, char *buffer, int number, const char *path, const char *format_down, bool last_full_capacity) { +static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen, char *buffer, int number, const char *path, const char *format_down) { char *outwalk = buffer; #if defined(LINUX) char buf[1024]; const char *walk, *last; bool watt_as_unit = false; - int full_design = -1, - remaining = -1, - voltage = -1; + int voltage = -1; char batpath[512]; sprintf(batpath, path, number); INSTANCE(batpath); @@ -79,21 +155,25 @@ static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen if (*walk != '=') continue; - if (BEGINS_WITH(last, "POWER_SUPPLY_ENERGY_NOW")) { + if (BEGINS_WITH(last, "POWER_SUPPLY_ENERGY_NOW=")) { watt_as_unit = true; - remaining = atoi(walk + 1); - } else if (BEGINS_WITH(last, "POWER_SUPPLY_CHARGE_NOW")) { + batt_info->remaining = atoi(walk + 1); + batt_info->percentage_remaining = -1; + } else if (BEGINS_WITH(last, "POWER_SUPPLY_CHARGE_NOW=")) { watt_as_unit = false; - remaining = atoi(walk + 1); - } else if (BEGINS_WITH(last, "POWER_SUPPLY_CURRENT_NOW")) + batt_info->remaining = atoi(walk + 1); + batt_info->percentage_remaining = -1; + } else if (BEGINS_WITH(last, "POWER_SUPPLY_CAPACITY=") && batt_info->remaining == -1) { + batt_info->percentage_remaining = atoi(walk + 1); + } else if (BEGINS_WITH(last, "POWER_SUPPLY_CURRENT_NOW=")) batt_info->present_rate = abs(atoi(walk + 1)); - else if (BEGINS_WITH(last, "POWER_SUPPLY_VOLTAGE_NOW")) + else if (BEGINS_WITH(last, "POWER_SUPPLY_VOLTAGE_NOW=")) voltage = abs(atoi(walk + 1)); /* on some systems POWER_SUPPLY_POWER_NOW does not exist, but actually * it is the same as POWER_SUPPLY_CURRENT_NOW but with μWh as * unit instead of μAh. We will calculate it as we need it * later. */ - else if (BEGINS_WITH(last, "POWER_SUPPLY_POWER_NOW")) + else if (BEGINS_WITH(last, "POWER_SUPPLY_POWER_NOW=")) batt_info->present_rate = abs(atoi(walk + 1)); else if (BEGINS_WITH(last, "POWER_SUPPLY_STATUS=Charging")) batt_info->status = CS_CHARGING; @@ -103,54 +183,60 @@ static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen batt_info->status = CS_DISCHARGING; else if (BEGINS_WITH(last, "POWER_SUPPLY_STATUS=")) batt_info->status = CS_UNKNOWN; - else { - /* The only thing left is the full capacity */ - if (last_full_capacity) { - if (!BEGINS_WITH(last, "POWER_SUPPLY_ENERGY_FULL") && - !BEGINS_WITH(last, "POWER_SUPPLY_CHARGE_FULL")) - continue; - } else { - if (!BEGINS_WITH(last, "POWER_SUPPLY_CHARGE_FULL_DESIGN") && - !BEGINS_WITH(last, "POWER_SUPPLY_ENERGY_FULL_DESIGN")) - continue; - } - - full_design = atoi(walk + 1); - } + else if (BEGINS_WITH(last, "POWER_SUPPLY_CHARGE_FULL_DESIGN=") || + BEGINS_WITH(last, "POWER_SUPPLY_ENERGY_FULL_DESIGN=")) + batt_info->full_design = atoi(walk + 1); + else if (BEGINS_WITH(last, "POWER_SUPPLY_ENERGY_FULL=") || + BEGINS_WITH(last, "POWER_SUPPLY_CHARGE_FULL=")) + batt_info->full_last = atoi(walk + 1); } /* the difference between POWER_SUPPLY_ENERGY_NOW and * POWER_SUPPLY_CHARGE_NOW is the unit of measurement. The energy is * given in mWh, the charge in mAh. So calculate every value given in * ampere to watt */ - if (!watt_as_unit) { - batt_info->present_rate = (((float)voltage / 1000.0) * ((float)batt_info->present_rate / 1000.0)); - - if (voltage != -1) { - remaining = (((float)voltage / 1000.0) * ((float)remaining / 1000.0)); - full_design = (((float)voltage / 1000.0) * ((float)full_design / 1000.0)); + if (!watt_as_unit && voltage >= 0) { + if (batt_info->present_rate > 0) { + batt_info->present_rate = (((float)voltage / 1000.0) * ((float)batt_info->present_rate / 1000.0)); + } + if (batt_info->remaining > 0) { + batt_info->remaining = (((float)voltage / 1000.0) * ((float)batt_info->remaining / 1000.0)); + } + if (batt_info->full_design > 0) { + batt_info->full_design = (((float)voltage / 1000.0) * ((float)batt_info->full_design / 1000.0)); + } + if (batt_info->full_last > 0) { + batt_info->full_last = (((float)voltage / 1000.0) * ((float)batt_info->full_last / 1000.0)); } } - - if ((full_design == -1) || (remaining == -1)) { +#elif defined(__DragonFly__) + union acpi_battery_ioctl_arg battio; + if (acpi_init()) { + battio.unit = number; + ioctl(acpifd, ACPIIO_BATT_GET_BIF, &battio); + batt_info->full_design = battio.bif.dcap; + batt_info->full_last = battio.bif.lfcap; + battio.unit = number; + ioctl(acpifd, ACPIIO_BATT_GET_BATTINFO, &battio); + batt_info->percentage_remaining = battio.battinfo.cap; + batt_info->present_rate = battio.battinfo.rate; + batt_info->seconds_remaining = battio.battinfo.min * 60; + switch (battio.battinfo.state) { + case 0: + batt_info->status = CS_FULL; + break; + case ACPI_BATT_STAT_CHARGING: + batt_info->status = CS_CHARGING; + break; + case ACPI_BATT_STAT_DISCHARG: + batt_info->status = CS_DISCHARGING; + break; + default: + batt_info->status = CS_UNKNOWN; + } OUTPUT_FULL_TEXT(format_down); - return false; } - - batt_info->percentage_remaining = (((float)remaining / (float)full_design) * 100); - /* Some batteries report POWER_SUPPLY_CHARGE_NOW= when fully - * charged, even though that’s plainly wrong. For people who chose to see - * the percentage calculated based on the last full capacity, we clamp the - * value to 100%, as that makes more sense. - * See http://bugs.debian.org/785398 */ - if (last_full_capacity && batt_info->percentage_remaining > 100) { - batt_info->percentage_remaining = 100; - } - - if (batt_info->present_rate > 0 && batt_info->status != CS_FULL) { - batt_info->seconds_remaining = seconds_remaining_from_rate(batt_info->status, full_design, remaining, batt_info->present_rate); - } -#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) +#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) int state; int sysctl_rslt; size_t sysctl_size = sizeof(sysctl_rslt); @@ -228,14 +314,9 @@ static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen /* * Using envsys(4) via sysmon(4). */ - bool watt_as_unit = false; - int full_design = -1, - remaining = -1, - voltage = -1; - int fd, rval, last_full_cap; + int fd, rval; bool is_found = false; - char *sensor_desc; - bool is_full = false; + char sensor_desc[16]; prop_dictionary_t dict; prop_array_t array; @@ -243,7 +324,8 @@ static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen prop_object_iterator_t iter2; prop_object_t obj, obj2, obj3, obj4, obj5; - asprintf(&sensor_desc, "acpibat%d", number); + if (number >= 0) + (void)snprintf(sensor_desc, sizeof(sensor_desc), "acpibat%d", number); fd = open("/dev/sysmon", O_RDONLY); if (fd < 0) { @@ -272,9 +354,17 @@ static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen /* iterate over the dictionary returned by the kernel */ while ((obj = prop_object_iterator_next(iter)) != NULL) { /* skip this dict if it's not what we're looking for */ - if (strcmp(sensor_desc, - prop_dictionary_keysym_cstring_nocopy(obj)) != 0) - continue; + if (number < 0) { + /* we want all batteries */ + if (!BEGINS_WITH(prop_dictionary_keysym_cstring_nocopy(obj), + "acpibat")) + continue; + } else { + /* we want a specific battery */ + if (strcmp(sensor_desc, + prop_dictionary_keysym_cstring_nocopy(obj)) != 0) + continue; + } is_found = true; @@ -294,6 +384,16 @@ static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen return false; } + struct battery_info batt_buf = { + .full_design = 0, + .full_last = 0, + .remaining = 0, + .present_rate = 0, + .status = CS_UNKNOWN, + }; + int voltage = -1; + bool watt_as_unit = false; + /* iterate over array of dicts specific to target battery */ while ((obj2 = prop_object_iterator_next(iter2)) != NULL) { obj3 = prop_dictionary_get(obj2, "description"); @@ -305,19 +405,16 @@ static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen obj3 = prop_dictionary_get(obj2, "cur-value"); if (prop_number_integer_value(obj3)) - batt_info->status = CS_CHARGING; + batt_buf.status = CS_CHARGING; else - batt_info->status = CS_DISCHARGING; + batt_buf.status = CS_DISCHARGING; } else if (strcmp("charge", prop_string_cstring_nocopy(obj3)) == 0) { obj3 = prop_dictionary_get(obj2, "cur-value"); obj4 = prop_dictionary_get(obj2, "max-value"); obj5 = prop_dictionary_get(obj2, "type"); - remaining = prop_number_integer_value(obj3); - full_design = prop_number_integer_value(obj4); - - if (remaining == full_design) - is_full = true; + batt_buf.remaining = prop_number_integer_value(obj3); + batt_buf.full_design = prop_number_integer_value(obj4); if (strcmp("Ampere hour", prop_string_cstring_nocopy(obj5)) == 0) watt_as_unit = false; @@ -325,19 +422,31 @@ static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen watt_as_unit = true; } else if (strcmp("discharge rate", prop_string_cstring_nocopy(obj3)) == 0) { obj3 = prop_dictionary_get(obj2, "cur-value"); - batt_info->present_rate = prop_number_integer_value(obj3); + batt_buf.present_rate = prop_number_integer_value(obj3); } else if (strcmp("charge rate", prop_string_cstring_nocopy(obj3)) == 0) { obj3 = prop_dictionary_get(obj2, "cur-value"); batt_info->present_rate = prop_number_integer_value(obj3); } else if (strcmp("last full cap", prop_string_cstring_nocopy(obj3)) == 0) { obj3 = prop_dictionary_get(obj2, "cur-value"); - last_full_cap = prop_number_integer_value(obj3); + batt_buf.full_last = prop_number_integer_value(obj3); } else if (strcmp("voltage", prop_string_cstring_nocopy(obj3)) == 0) { obj3 = prop_dictionary_get(obj2, "cur-value"); voltage = prop_number_integer_value(obj3); } } prop_object_iterator_release(iter2); + + if (!watt_as_unit && voltage != -1) { + batt_buf.present_rate = (((float)voltage / 1000.0) * ((float)batt_buf.present_rate / 1000.0)); + batt_buf.remaining = (((float)voltage / 1000.0) * ((float)batt_buf.remaining / 1000.0)); + batt_buf.full_design = (((float)voltage / 1000.0) * ((float)batt_buf.full_design / 1000.0)); + batt_buf.full_last = (((float)voltage / 1000.0) * ((float)batt_buf.full_last / 1000.0)); + } + + if (batt_buf.remaining == batt_buf.full_design) + batt_buf.status = CS_FULL; + + add_battery_info(batt_info, &batt_buf); } prop_object_iterator_release(iter); @@ -349,26 +458,69 @@ static bool slurp_battery_info(struct battery_info *batt_info, yajl_gen json_gen return false; } - if (last_full_capacity) - full_design = last_full_cap; + batt_info->present_rate = abs(batt_info->present_rate); +#endif + + return true; +} - if (!watt_as_unit) { - batt_info->present_rate = (((float)voltage / 1000.0) * ((float)batt_info->present_rate / 1000.0)); - remaining = (((float)voltage / 1000.0) * ((float)remaining / 1000.0)); - full_design = (((float)voltage / 1000.0) * ((float)full_design / 1000.0)); +/* + * Populate batt_info with aggregate information about all batteries. + * Returns false on error, and an error message will have been written. + */ +static bool slurp_all_batteries(struct battery_info *batt_info, yajl_gen json_gen, char *buffer, const char *path, const char *format_down) { +#if defined(LINUX) + char *outwalk = buffer; + bool is_found = false; + + char *placeholder; + char *globpath = sstrdup(path); + if ((placeholder = strstr(path, "%d")) != NULL) { + char *globplaceholder = globpath + (placeholder - path); + *globplaceholder = '*'; + strcpy(globplaceholder + 1, placeholder + 2); } - batt_info->percentage_remaining = - (((float)remaining / (float)full_design) * 100); + if (!strcmp(globpath, path)) { + OUTPUT_FULL_TEXT("no '%d' in battery path"); + return false; + } - if (is_full) - batt_info->status = CS_FULL; + glob_t globbuf; + if (glob(globpath, 0, NULL, &globbuf) == 0) { + for (size_t i = 0; i < globbuf.gl_pathc; i++) { + /* Probe to see if there is such a battery. */ + struct battery_info batt_buf = { + .full_design = 0, + .full_last = 0, + .remaining = 0, + .present_rate = 0, + .status = CS_UNKNOWN, + }; + if (!slurp_battery_info(&batt_buf, json_gen, buffer, i, globbuf.gl_pathv[i], format_down)) { + globfree(&globbuf); + free(globpath); + return false; + } - /* - * The envsys(4) ACPI routines do not appear to provide a 'time - * remaining' figure, so we must deduce it. - */ - batt_info->seconds_remaining = seconds_remaining_from_rate(batt_info->status, full_design, remaining, batt_info->present_rate); + is_found = true; + add_battery_info(batt_info, &batt_buf); + } + globfree(&globbuf); + } + free(globpath); + + if (!is_found) { + OUTPUT_FULL_TEXT(format_down); + return false; + } + + batt_info->present_rate = abs(batt_info->present_rate); +#else + /* FreeBSD and OpenBSD only report aggregates. NetBSD always + * iterates through all batteries, so it's more efficient to + * aggregate in slurp_battery_info. */ + return slurp_battery_info(batt_info, json_gen, buffer, -1, path, format_down); #endif return true; @@ -378,10 +530,13 @@ void print_battery_info(yajl_gen json_gen, char *buffer, int number, const char const char *walk; char *outwalk = buffer; struct battery_info batt_info = { + .full_design = -1, + .full_last = -1, + .remaining = -1, .present_rate = -1, .seconds_remaining = -1, .percentage_remaining = -1, - .status = CS_DISCHARGING, + .status = CS_UNKNOWN, }; bool colorful_output = false; @@ -389,13 +544,58 @@ void print_battery_info(yajl_gen json_gen, char *buffer, int number, const char /* These OSes report battery stats in whole percent. */ integer_battery_capacity = true; #endif -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) +#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__OpenBSD__) /* These OSes report battery time in minutes. */ hide_seconds = true; #endif - if (!slurp_battery_info(&batt_info, json_gen, buffer, number, path, format_down, last_full_capacity)) + if (number < 0) { + if (!slurp_all_batteries(&batt_info, json_gen, buffer, path, format_down)) + return; + } else { + if (!slurp_battery_info(&batt_info, json_gen, buffer, number, path, format_down)) + return; + } + + // *Choose* a measure of the 'full' battery. It is whichever is better of + // the battery's (hardware-given) design capacity (batt_info.full_design) + // and the battery's last known good charge (batt_info.full_last). + // We prefer the design capacity, but use the last capacity if we don't have it, + // or if we are asked to (last_full_capacity == true); but similarly we use + // the design capacity if we don't have the last capacity. + // If we don't have either then both full_design and full_last <= 0, + // which implies full <= 0, which bails out on the following line. + int full = batt_info.full_design; + if (full <= 0 || (last_full_capacity && batt_info.full_last > 0)) { + full = batt_info.full_last; + } + if (full <= 0 && batt_info.remaining < 0 && batt_info.percentage_remaining < 0) { + /* We have no physical measurements and no estimates. Nothing + * much we can report, then. */ + OUTPUT_FULL_TEXT(format_down); return; + } + + if (batt_info.percentage_remaining < 0) { + batt_info.percentage_remaining = (((float)batt_info.remaining / (float)full) * 100); + /* Some batteries report POWER_SUPPLY_CHARGE_NOW= when fully + * charged, even though that’s plainly wrong. For people who chose to see + * the percentage calculated based on the last full capacity, we clamp the + * value to 100%, as that makes more sense. + * See http://bugs.debian.org/785398 */ + if (last_full_capacity && batt_info.percentage_remaining > 100) { + batt_info.percentage_remaining = 100; + } + } + + if (batt_info.seconds_remaining < 0 && batt_info.present_rate > 0 && batt_info.status != CS_FULL) { + if (batt_info.status == CS_CHARGING) + batt_info.seconds_remaining = 3600.0 * (full - batt_info.remaining) / batt_info.present_rate; + else if (batt_info.status == CS_DISCHARGING) + batt_info.seconds_remaining = 3600.0 * batt_info.remaining / batt_info.present_rate; + else + batt_info.seconds_remaining = 0; + } if (batt_info.status == CS_DISCHARGING && low_threshold > 0) { if (batt_info.percentage_remaining >= 0 && strcasecmp(threshold_type, "percentage") == 0 && batt_info.percentage_remaining < low_threshold) { @@ -422,10 +622,8 @@ void print_battery_info(yajl_gen json_gen, char *buffer, int number, const char if (*walk != '%') { *(outwalk++) = *walk; - continue; - } - if (BEGINS_WITH(walk + 1, "status")) { + } else if (BEGINS_WITH(walk + 1, "status")) { const char *statusstr; switch (batt_info.status) { case CS_CHARGING: @@ -443,6 +641,7 @@ void print_battery_info(yajl_gen json_gen, char *buffer, int number, const char outwalk += sprintf(outwalk, "%s", statusstr); walk += strlen("status"); + } else if (BEGINS_WITH(walk + 1, "percentage")) { if (integer_battery_capacity) { outwalk += sprintf(outwalk, "%.00f%s", batt_info.percentage_remaining, pct_mark); @@ -450,6 +649,7 @@ void print_battery_info(yajl_gen json_gen, char *buffer, int number, const char outwalk += sprintf(outwalk, "%.02f%s", batt_info.percentage_remaining, pct_mark); } walk += strlen("percentage"); + } else if (BEGINS_WITH(walk + 1, "remaining")) { if (batt_info.seconds_remaining >= 0) { int seconds, hours, minutes; @@ -468,9 +668,11 @@ void print_battery_info(yajl_gen json_gen, char *buffer, int number, const char } walk += strlen("remaining"); EAT_SPACE_FROM_OUTPUT_IF_NO_OUTPUT(); + } else if (BEGINS_WITH(walk + 1, "emptytime")) { if (batt_info.seconds_remaining >= 0) { time_t empty_time = time(NULL) + batt_info.seconds_remaining; + set_timezone(NULL); /* Use local time. */ struct tm *empty_tm = localtime(&empty_time); if (hide_seconds) @@ -482,12 +684,16 @@ void print_battery_info(yajl_gen json_gen, char *buffer, int number, const char } walk += strlen("emptytime"); EAT_SPACE_FROM_OUTPUT_IF_NO_OUTPUT(); + } else if (BEGINS_WITH(walk + 1, "consumption")) { if (batt_info.present_rate >= 0) outwalk += sprintf(outwalk, "%1.2fW", batt_info.present_rate / 1e6); walk += strlen("consumption"); EAT_SPACE_FROM_OUTPUT_IF_NO_OUTPUT(); + + } else { + *(outwalk++) = '%'; } }