From b8589181a78959be0322d94339d43dba45fdeda0 Mon Sep 17 00:00:00 2001 From: Drath Date: Sat, 3 Jan 2026 16:24:00 +0100 Subject: [PATCH] move sensors to class --- include/app.hpp | 10 ++--- src/app.cpp | 103 ++++++++++++++++++++++++------------------------ 2 files changed, 57 insertions(+), 56 deletions(-) diff --git a/include/app.hpp b/include/app.hpp index 4d27ae8..40f33ad 100644 --- a/include/app.hpp +++ b/include/app.hpp @@ -15,7 +15,6 @@ class Application { struct Config { uint16_t lcd_interval_ms; uint8_t lcd_contrast; - std::string lcd_port; std::string cpu_pciaddr; std::string gpu_pciaddr; @@ -48,11 +47,12 @@ class Application { }; Config m_config; // m_ is prefix for member variable - Control m_control; + Control m_control{}; + Sensors m_sensors{}; - static void hassThread(const std::stop_token& st, Sensors& s); - void sensorsThread(const std::stop_token& st, Sensors& s); - void displayThread(const std::stop_token& st, Sensors& s); + void hassThread(const std::stop_token& st); + void sensorsThread(const std::stop_token& st); + void displayThread(const std::stop_token& st); }; #endif \ No newline at end of file diff --git a/src/app.cpp b/src/app.cpp index ad8ae45..dd4b04c 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -16,7 +16,7 @@ #include #include -void Application::hassThread(const std::stop_token& st, Sensors& s) { +void Application::hassThread(const std::stop_token& st) { applog(LOG::START, "Thread started"); HomeAssistant pc_power("home.drath.win", "sensor.gniazdko_komputer_moc"); @@ -24,33 +24,33 @@ void Application::hassThread(const std::stop_token& st, Sensors& s) { while (!st.stop_requested()) { pc_power.service(); { - std::lock_guard lock(s.mtx); - s.hass_state = pc_power.state; + std::lock_guard lock(m_sensors.mtx); + m_sensors.hass_state = pc_power.state; } std::this_thread::sleep_for(std::chrono::milliseconds(10)); } } -void Application::sensorsThread(const std::stop_token& st, Sensors& s) { +void Application::sensorsThread(const std::stop_token& st) { applog(LOG::START, "Thread started, poll interval {} ms", m_config.lcd_interval_ms); - cpu::detectHwmon(&s.cpu, m_config.cpu_pciaddr); - gpu::detectHwmon(&s.gpu, m_config.gpu_pciaddr); - sys::detectHwmon(&s.sys, m_config.sys_sensor); - s.home.mountpoint = m_config.home_dir; + cpu::detectHwmon(&m_sensors.cpu, m_config.cpu_pciaddr); + gpu::detectHwmon(&m_sensors.gpu, m_config.gpu_pciaddr); + sys::detectHwmon(&m_sensors.sys, m_config.sys_sensor); + m_sensors.home.mountpoint = m_config.home_dir; while (!st.stop_requested()) { auto start = std::chrono::steady_clock::now(); { - std::lock_guard lock(s.mtx); + std::lock_guard lock(m_sensors.mtx); - sys::getTimeDate(&s.td); - getloadavg(s.avg, 3); - sys::getRam(&s.ram); - sys::getDisk(&s.home); - sys::getNetwork(&s.net, m_config.sys_ifname); - sys::updateSensors(&s.sys); - cpu::update(&s.cpu); - gpu::update(&s.gpu); + sys::getTimeDate(&m_sensors.td); + getloadavg(m_sensors.avg, 3); + sys::getRam(&m_sensors.ram); + sys::getDisk(&m_sensors.home); + sys::getNetwork(&m_sensors.net, m_config.sys_ifname); + sys::updateSensors(&m_sensors.sys); + cpu::update(&m_sensors.cpu); + gpu::update(&m_sensors.gpu); } // log(LOG::DBG, "took {} microseconds", std::chrono::duration_cast(std::chrono::steady_clock::now() - start).count()); @@ -60,7 +60,7 @@ void Application::sensorsThread(const std::stop_token& st, Sensors& s) { applog(LOG::INF, "Thread stopped"); } -void Application::displayThread(const std::stop_token& st, Sensors& s) { +void Application::displayThread(const std::stop_token& st) { std::stop_callback cb(st, [&] { m_control.display.release(); }); applog(LOG::START, "Thread started"); // init internal variables of LCDDisplay class @@ -85,45 +85,45 @@ void Application::displayThread(const std::stop_token& st, Sensors& s) { m_control.display.try_acquire_for(std::chrono::milliseconds(static_cast(m_config.lcd_interval_ms * 1.25))); // holds the loop until sensor data is ready, max 1.25x of the loop time if (st.stop_requested()) break; // needed, otherwise it wont quit correctly { - std::lock_guard lock(s.mtx); + std::lock_guard lock(m_sensors.mtx); // prepare some tricky sensors - std::string gpu_temps = std::to_string(s.gpu.temp_edge); - if (s.gpu.temp_hotspot) { - const auto delta = s.gpu.temp_hotspot - s.gpu.temp_edge; - gpu_temps.append("/" + std::to_string(s.gpu.temp_hotspot)); + std::string gpu_temps = std::to_string(m_sensors.gpu.temp_edge); + if (m_sensors.gpu.temp_hotspot) { + const auto delta = m_sensors.gpu.temp_hotspot - m_sensors.gpu.temp_edge; + gpu_temps.append("/" + std::to_string(m_sensors.gpu.temp_hotspot)); gpu_temps.insert(0, LCDDisplay::cc(1) + std::to_string(delta) + LCDDisplay::cc(0) + " "); } uint16_t cpu_fan = 0; - for (const auto& fan : s.sys.fan_speed) + for (const auto& fan : m_sensors.sys.fan_speed) cpu_fan += fan; cpu_fan /= 2; // write to display buffer - lcd.writeBuf(0, 0, utils::pad(s.td.date, 11, utils::just::left) + " " + s.td.time + lcd.bar(7, s.gpu.usage_core / 100.0)); - lcd.writeBuf(0, 26, utils::pNum(s.avg[0], s.avg[0] > 10 ? 1 : 2)); - lcd.writeBuf(0, 31, utils::pNum(s.avg[1], s.avg[1] > 10 ? 1 : 2)); - lcd.writeBuf(0, 36, utils::pNum(s.avg[2], s.avg[2] > 10 ? 1 : 2)); + lcd.writeBuf(0, 0, utils::pad(m_sensors.td.date, 11, utils::just::left) + " " + m_sensors.td.time + lcd.bar(7, m_sensors.gpu.usage_core / 100.0)); + lcd.writeBuf(0, 26, utils::pNum(m_sensors.avg[0], m_sensors.avg[0] > 10 ? 1 : 2)); + lcd.writeBuf(0, 31, utils::pNum(m_sensors.avg[1], m_sensors.avg[1] > 10 ? 1 : 2)); + lcd.writeBuf(0, 36, utils::pNum(m_sensors.avg[2], m_sensors.avg[2] > 10 ? 1 : 2)); - lcd.writeBuf(1, 0, utils::pad(std::to_string(s.cpu.tctl) + "/" + std::to_string(s.cpu.tccd1) + LCDDisplay::cc(0), 8, utils::just::left)); - lcd.writeBuf(1, 7, utils::pad(utils::pBytes(s.ram.used, true), 6, utils::just::left)); - lcd.writeBuf(1, 13, utils::pad(utils::pNum(s.hass_state) + "W", 4)); - lcd.writeBuf(1, 19, std::to_string(s.sys.t_sensor) + LCDDisplay::cc(0)); // t_sensor temp - lcd.writeBuf(1, 32 - gpu_temps.size(), utils::pad(utils::pBytes(s.gpu.vram_used), 6)); + lcd.writeBuf(1, 0, utils::pad(std::to_string(m_sensors.cpu.tctl) + "/" + std::to_string(m_sensors.cpu.tccd1) + LCDDisplay::cc(0), 8, utils::just::left)); + lcd.writeBuf(1, 7, utils::pad(utils::pBytes(m_sensors.ram.used, true), 6, utils::just::left)); + lcd.writeBuf(1, 13, utils::pad(utils::pNum(m_sensors.hass_state) + "W", 4)); + lcd.writeBuf(1, 19, std::to_string(m_sensors.sys.t_sensor) + LCDDisplay::cc(0)); // t_sensor temp + lcd.writeBuf(1, 32 - gpu_temps.size(), utils::pad(utils::pBytes(m_sensors.gpu.vram_used), 6)); lcd.writeBuf(1, 39 - gpu_temps.size(), gpu_temps + LCDDisplay::cc(0)); - lcd.writeBuf(2, 0, utils::pad(std::to_string(static_cast(s.cpu.ptotal)) + "W", 8, utils::just::left)); - lcd.writeBuf(2, s.cpu.ptotal < 100 ? 4 : 5, std::to_string(cpu_fan) + "R"); // avg fan speed - lcd.writeBuf(2, 12, LCDDisplay::cc(3) + utils::pBytes(s.net.upload)); - lcd.writeBuf(2, 19, LCDDisplay::cc(4) + utils::pBytes(s.net.download)); - lcd.writeBuf(2, 26, utils::pad(std::to_string(s.gpu.fan_speed) + "R", 5)); - lcd.writeBuf(2, 31, utils::pad(std::to_string(s.gpu.power_avg) + "/" + std::to_string(s.gpu.power_cap) + "W", 9)); + lcd.writeBuf(2, 0, utils::pad(std::to_string(static_cast(m_sensors.cpu.ptotal)) + "W", 8, utils::just::left)); + lcd.writeBuf(2, m_sensors.cpu.ptotal < 100 ? 4 : 5, std::to_string(cpu_fan) + "R"); // avg fan speed + lcd.writeBuf(2, 12, LCDDisplay::cc(3) + utils::pBytes(m_sensors.net.upload)); + lcd.writeBuf(2, 19, LCDDisplay::cc(4) + utils::pBytes(m_sensors.net.download)); + lcd.writeBuf(2, 26, utils::pad(std::to_string(m_sensors.gpu.fan_speed) + "R", 5)); + lcd.writeBuf(2, 31, utils::pad(std::to_string(m_sensors.gpu.power_avg) + "/" + std::to_string(m_sensors.gpu.power_cap) + "W", 9)); - lcd.writeBuf(3, 0, std::to_string(s.cpu.avg_freq) + "MHz"); - lcd.writeBuf(3, 14, utils::pad(LCDDisplay::cc(2) + utils::pBytes(s.home.usage.free), 6)); - lcd.writeBuf(3, 21, utils::pad(std::to_string(s.gpu.clock_core) + "/" + std::to_string(s.gpu.clock_mem) + "MHz ", 13)); - lcd.writeBuf(3, 34, utils::pad(utils::pNum(s.gpu.vcore, 3) + "V", 5)); + lcd.writeBuf(3, 0, std::to_string(m_sensors.cpu.avg_freq) + "MHz"); + lcd.writeBuf(3, 14, utils::pad(LCDDisplay::cc(2) + utils::pBytes(m_sensors.home.usage.free), 6)); + lcd.writeBuf(3, 21, utils::pad(std::to_string(m_sensors.gpu.clock_core) + "/" + std::to_string(m_sensors.gpu.clock_mem) + "MHz ", 13)); + lcd.writeBuf(3, 34, utils::pad(utils::pNum(m_sensors.gpu.vcore, 3) + "V", 5)); } lcd.flushBuf(); @@ -135,7 +135,8 @@ void Application::displayThread(const std::stop_token& st, Sensors& s) { lcd.flushBuf(); } -Application::Application(Config config) : m_config(std::move(config)) { +Application::Application(Config config) { + m_config = std::move(config); // set up signals sigemptyset(&m_control.sigset); sigaddset(&m_control.sigset, SIGINT); @@ -148,25 +149,25 @@ Application::~Application() { void Application::Run() { applog(LOG::START, "starting"); + int sig; pthread_sigmask(SIG_BLOCK, &m_control.sigset, nullptr); { - Sensors sensors; std::vector threads; - std::function funcs[] = { - [this](const std::stop_token& st, Sensors& s) { displayThread(st, s); }, - [this](const std::stop_token& st, Sensors& s) { sensorsThread(st, s); }, - [](const std::stop_token& st, Sensors& s) { hassThread(st, s); }, + std::function funcs[] = { + [this](const std::stop_token& st) { displayThread(st); }, + [this](const std::stop_token& st) { sensorsThread(st); }, + [this](const std::stop_token& st) { hassThread(st); }, }; // start threads in order for (auto& f : funcs) { - threads.emplace_back(f, std::ref(sensors)); // params: function, stop_token (implied), pointer to sensor struct + threads.emplace_back(f); std::this_thread::sleep_for(std::chrono::milliseconds(10)); // start threads with delay so displayThread can quit the app if theres no lcd } - int sig; + // waits for signal, the threads are stopped when we go out of scope sigwait(&m_control.sigset, &sig); applog(LOG::WRN, "got stop signal, shutting down..."); }