tobias/waybar
1
0
Fork 0
mirror of https://github.com/rad4day/Waybar.git synced 2025-11-04 09:42:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

Added alternative calculations for time remaining

Browse Source
This commit is contained in:
Tom Charnock
2022-09-03 16:06:13 +02:00
parent 0d94853613
commit af2a3f8bda
1 changed files with 178 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

313
src/modules/battery.cpp
View File

@@ -164,7 +164,7 @@ const std::tuple<uint8_t, float, std::string, float> waybar::modules::Battery::g
bool total_energy_full_exists = false; bool total_energy_full_exists = false;
uint32_t total_energy_full_design = 0; uint32_t total_energy_full_design = 0;
bool total_energy_full_design_exists = false; bool total_energy_full_design_exists = false;
uint32_t total_capacity{0}; uint32_t total_capacity = 0;
bool total_capacity_exists = false; bool total_capacity_exists = false;
std::string status = "Unknown"; std::string status = "Unknown";
@@ -176,191 +176,232 @@ const std::tuple<uint8_t, float, std::string, float> waybar::modules::Battery::g
// Some battery will report current and charge in μA/μAh. // Some battery will report current and charge in μA/μAh.
// Scale these by the voltage to get μW/μWh. // Scale these by the voltage to get μW/μWh.
uint32_t capacity; // uint32_t capacity (bool pass) {
bool capacity_exists; // uint32_t c = 0;
// if (fs::exists(bat / "capacity"))
// c = std::ifstream(bat / "capacity");
// else if (pass)
// c = charge_now(pass) / charge_full(pass);
// return c;
// }
// uint32_t current_now (bool pass) {
// uint32_t c = 0;
// if (fs::exists(bat / "current_now"))
// std::ifstream(bat / "current_now") >> c;
// else if (fs::exists(bat / "current_avg"))
// std::ifstream(bat / "current_avg") >> c;
// else
// c = power_now(pass) / voltage_now(pass);
// return c;
// }
// uint32_t voltage_now () {
// uint32_t v = 0;
// if (fs::exists(bat / "voltage_now"))
// std::ifstream(bat / "voltage_now") >> v;
// else if (fs::exists(bat / "voltage_avg"))
// std::ifstream(bat / "voltage_avg") >> v;
// else
// }
uint32_t capacity = 0;
bool capacity_exists = false;
if (fs::exists(bat / "capacity")) { if (fs::exists(bat / "capacity")) {
capacity_exists = true; capacity_exists = true;
std::ifstream(bat / "capacity") >> capacity; std::ifstream(bat / "capacity") >> capacity;
} else {
capacity_exists = false;
capacity = 0;
} }
uint32_t current_now; uint32_t current_now = 0;
bool current_now_exists; bool current_now_exists = false;
if (fs::exists(bat / "current_now")) { if (fs::exists(bat / "current_now")) {
current_now_exists = true; current_now_exists = true;
std::ifstream(bat / "current_now") >> current_now; std::ifstream(bat / "current_now") >> current_now;
} else if (fs::exists(bat / "current_avg")) { } else if (fs::exists(bat / "current_avg")) {
current_now_exists = true; current_now_exists = true;
std::ifstream(bat / "current_avg") >> current_now; std::ifstream(bat / "current_avg") >> current_now;
} else {
current_now_exists = false;
current_now = 0;
} }
uint32_t voltage_now; uint32_t voltage_now = 0;
bool voltage_now_exists; bool voltage_now_exists = false;
if (fs::exists(bat / "voltage_now")) { if (fs::exists(bat / "voltage_now")) {
voltage_now_exists = true; voltage_now_exists = true;
std::ifstream(bat / "voltage_now") >> voltage_now; std::ifstream(bat / "voltage_now") >> voltage_now;
} else if (fs::exists(bat / "voltage_avg")) { } else if (fs::exists(bat / "voltage_avg")) {
voltage_now_exists = true; voltage_now_exists = true;
std::ifstream(bat / "voltage_avg") >> voltage_now; std::ifstream(bat / "voltage_avg") >> voltage_now;
} else {
voltage_now_exists = false;
voltage_now = 0;
} }
uint32_t charge_full; uint32_t charge_full = 0;
bool charge_full_exists; bool charge_full_exists = false;
if (fs::exists(bat / "charge_full")) { if (fs::exists(bat / "charge_full")) {
charge_full_exists = true; charge_full_exists = true;
std::ifstream(bat / "charge_full") >> charge_full; std::ifstream(bat / "charge_full") >> charge_full;
} else {
charge_full_exists = false;
charge_full = 0;
} }
uint32_t charge_full_design; uint32_t charge_full_design = 0;
bool charge_full_design_exists; bool charge_full_design_exists = false;
if (fs::exists(bat / "charge_full_design")) { if (fs::exists(bat / "charge_full_design")) {
charge_full_design_exists = true; charge_full_design_exists = true;
std::ifstream(bat / "charge_full_design") >> charge_full_design; std::ifstream(bat / "charge_full_design") >> charge_full_design;
} else {
charge_full_design_exists = false;
charge_full_design = 0;
} }
uint32_t charge_now; uint32_t charge_now = 0;
bool charge_now_exists; bool charge_now_exists = false;
if (fs::exists(bat / "charge_now")) { if (fs::exists(bat / "charge_now")) {
charge_now_exists = true; charge_now_exists = true;
std::ifstream(bat / "charge_now") >> charge_now; std::ifstream(bat / "charge_now") >> charge_now;
} else if (capacity_exists && charge_full_exists) {
// charge_now is missing on some systems, estimate using capacity and charge_full.
charge_now_exists = true; // this could be debatably set to false (same for all properties below)
charge_now = (capacity * charge_full) / 100;
} else {
charge_now_exists = false;
charge_now = 0;
} }
if (!capacity_exists && charge_now_exists && charge_full_exists) { uint32_t power_now = 0;
if (charge_full != 0) { bool power_now_exists = false;
capacity_exists = true;
capacity = charge_now * 100 / charge_full;
}
}
uint32_t power_now;
bool power_now_exists;
if (fs::exists(bat / "power_now")) { if (fs::exists(bat / "power_now")) {
power_now_exists = true; power_now_exists = true;
std::ifstream(bat / "power_now") >> power_now; std::ifstream(bat / "power_now") >> power_now;
} else if (current_now_exists && voltage_now_exists) {
power_now_exists = true;
power_now = ((uint64_t)current_now * (uint64_t)voltage_now) / 1000000;
} else {
power_now_exists = false;
power_now = 0;
} }
if (!current_now_exists && power_now_exists && voltage_now_exists) { uint32_t energy_now = 0;
if (voltage_now != 0){ bool energy_now_exists = false;
current_now_exists = true;
current_now = (uint64_t)power_now * 1000000 / (uint64_t)voltage_now;
}
}
if (!voltage_now_exists && power_now_exists && current_now_exists) {
if (current_now != 0) {
voltage_now_exists = true;
voltage_now = (uint64_t)power_now * 1000000 / (uint64_t)current_now;
}
}
uint32_t energy_now;
bool energy_now_exists;
if (fs::exists(bat / "energy_now")) { if (fs::exists(bat / "energy_now")) {
energy_now_exists = true; energy_now_exists = true;
std::ifstream(bat / "energy_now") >> energy_now; std::ifstream(bat / "energy_now") >> energy_now;
} else if (charge_now_exists && voltage_now_exists) {
energy_now_exists = true;
energy_now = ((uint64_t)charge_now * (uint64_t)voltage_now) / 1000000;
} else {
energy_now_exists = false;
energy_now = 0;
} }
if (!charge_now_exists && energy_now_exists && voltage_now_exists) { uint32_t energy_full = 0;
if (voltage_now != 0){ bool energy_full_exists = false;
charge_now_exists = true;
charge_now = (uint64_t)energy_now * 1000000 / (uint64_t)voltage_now;
}
}
if (!voltage_now_exists && energy_now_exists && charge_now_exists) {
if (charge_now != 0) {
voltage_now_exists = true;
voltage_now = (uint64_t)energy_now * 1000000 / (uint64_t)charge_now;
}
}
uint32_t energy_full;
bool energy_full_exists;
if (fs::exists(bat / "energy_full")) { if (fs::exists(bat / "energy_full")) {
energy_full_exists = true; energy_full_exists = true;
std::ifstream(bat / "energy_full") >> energy_full; std::ifstream(bat / "energy_full") >> energy_full;
} else if (charge_full_exists && voltage_now_exists) {
energy_full_exists = true;
energy_full = ((uint64_t)charge_full * (uint64_t)voltage_now) / 1000000;
} else {
energy_full_exists = false;
energy_full = 0;
} }
if (!charge_full_exists && energy_full_exists && voltage_now_exists) { uint32_t energy_full_design = 0;
if (voltage_now != 0){ bool energy_full_design_exists = false;
charge_full_exists = true;
charge_full = (uint64_t)energy_full * 1000000 / (uint64_t)voltage_now;
}
}
if (!voltage_now_exists && energy_full_exists && charge_full_exists) {
if (charge_full != 0) {
voltage_now_exists = true;
voltage_now = (uint64_t)energy_full * 1000000 / (uint64_t)charge_full;
}
}
uint32_t energy_full_design;
bool energy_full_design_exists;
if (fs::exists(bat / "energy_full_design")) { if (fs::exists(bat / "energy_full_design")) {
energy_full_design_exists = true; energy_full_design_exists = true;
std::ifstream(bat / "energy_full_design") >> energy_full_design; std::ifstream(bat / "energy_full_design") >> energy_full_design;
} else if (charge_full_design_exists && voltage_now_exists) {
energy_full_design_exists = true;
energy_full_design = ((uint64_t)charge_full_design * (uint64_t)voltage_now) / 1000000;
} else {
energy_full_design_exists = false;
energy_full_design = 0;
} }
if (!charge_full_design_exists && energy_full_design_exists && voltage_now_exists) { if (!voltage_now_exists) {
if (voltage_now != 0){ if (power_now_exists && current_now_exists && current_now != 0) {
charge_full_design_exists = true;
charge_full_design = (uint64_t)energy_full_design * 1000000 / (uint64_t)voltage_now;
}
}
if (!voltage_now_exists && energy_full_design_exists && charge_full_design_exists) {
if (charge_full_design != 0) {
voltage_now_exists = true; voltage_now_exists = true;
voltage_now = (uint64_t)energy_full_design * 1000000 / (uint64_t)charge_full_design; voltage_now = 1000000 * power_now / current_now;
} else if (energy_full_design_exists && charge_full_design_exists && charge_full_design != 0) {
voltage_now_exists = true;
voltage_now = 1000000 * energy_full_design / charge_full_design;
} else if (energy_now_exists) {
if (charge_now_exists && charge_now != 0) {
voltage_now_exists = true;
voltage_now = 1000000 * energy_now / charge_now;
} else if (capacity_exists && charge_full_exists) {
charge_now_exists = true;
charge_now = charge_full * capacity / 100;
if (charge_full != 0 && capacity != 0) {
voltage_now_exists = true;
voltage_now = 1000000 * energy_now * 100 / charge_full / capacity;
}
}
} else if (energy_full_exists) {
if (charge_full_exists && charge_full != 0) {
voltage_now_exists = true;
voltage_now = 1000000 * energy_full / charge_full;
} else if (charge_now_exists && capacity_exists) {
if (capacity != 0) {
charge_full_exists = true;
charge_full = 100 * charge_now / capacity;
}
if (charge_now != 0) {
voltage_now_exists = true;
voltage_now = 10000 * energy_full * capacity / charge_now;
}
}
} }
} }
if (!capacity_exists) {
if (charge_now_exists && charge_full_exists && charge_full != 0) {
capacity_exists = true;
capacity = 100 * charge_now / charge_full;
} else if (energy_now_exists && energy_full_exists && energy_full != 0) {
capacity_exists = true;
capacity = 100 * energy_now / energy_full;
} else if (charge_now_exists && energy_full_exists && voltage_now_exists) {
if (!charge_full_exists && voltage_now != 0) {
charge_full_exists = true;
charge_full = 1000000 * energy_full / voltage_now;
}
if (energy_full != 0) {
capacity_exists = true;
capacity = charge_now * voltage_now / 10000 / energy_full;
}
} else if (charge_full_exists && energy_now_exists && voltage_now_exists) {
if (!charge_now_exists && voltage_now != 0) {
charge_now_exists = true;
charge_now = 1000000 * energy_now / voltage_now;
}
if (voltage_now != 0 && charge_full != 0) {
capacity_exists = true;
capacity = 100 * 1000000 * energy_now / voltage_now / charge_full;
}
}
}
if (!energy_now_exists && voltage_now_exists) {
if (charge_now_exists) {
energy_now_exists = true;
energy_now = charge_now * voltage_now / 1000000;
} else if (capacity_exists && charge_full_exists) {
charge_now_exists = true;
charge_now = capacity * charge_full / 100;
energy_now_exists = true;
energy_now = voltage_now * capacity * charge_full / 1000000 / 100;
} else if (capacity_exists && energy_full) {
if (voltage_now != 0) {
charge_full_exists = true;
charge_full = 1000000 * energy_full / voltage_now;
charge_now_exists = true;
charge_now = capacity * 10000 * energy_full / voltage_now;
}
energy_now_exists = true;
energy_now = capacity * energy_full / 100;
}
}
if (!energy_full_exists && voltage_now_exists) {
if (charge_full_exists) {
energy_full_exists = true;
energy_full = charge_full * voltage_now / 1000000;
} else if (charge_now_exists && capacity_exists && capacity != 0) {
charge_full_exists = true;
charge_full = 100 * charge_now / capacity;
energy_full_exists = true;
energy_full = charge_now * voltage_now / capacity / 10000;
} else if (capacity_exists && energy_now) {
if (voltage_now != 0) {
charge_now_exists = true;
charge_now = 1000000 * energy_now / voltage_now;
}
if (capacity != 0) {
energy_full_exists = true;
energy_full = 100 * energy_now / capacity;
if (voltage_now != 0) {
charge_full_exists = true;
charge_full = 100 * 1000000 * energy_now / voltage_now / capacity;
}
}
}
}
if (!power_now_exists && voltage_now_exists && charge_now_exists) {
power_now_exists = true;
power_now = voltage_now * current_now / 1000000;
}
if (!energy_full_design_exists && voltage_now_exists && charge_full_design_exists) {
energy_full_design_exists = true;
energy_full_design = voltage_now * charge_full_design / 1000000;
}
// Show the "smallest" status among all batteries // Show the "smallest" status among all batteries
if (status_gt(status, _status)) if (status_gt(status, _status))
status = _status; status = _status;