129 lines
4.4 KiB
C++
129 lines
4.4 KiB
C++
|
|
#include <array>
|
|
#include <chrono>
|
|
#include <csignal>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <iostream>
|
|
#include <print>
|
|
#include <sstream>
|
|
#include <stop_token>
|
|
#include <string>
|
|
#include <thread>
|
|
//
|
|
#include <LCDDisplay.hpp>
|
|
#include <cpu.hpp>
|
|
#include <gpu.hpp>
|
|
#include <hass.hpp>
|
|
#include <sys.hpp>
|
|
#include <utils.hpp>
|
|
|
|
#define LCD_PORT "/dev/serial/by-id/usb-Raspberry_Pi_Pico_E6616407E37AA12F-if00" // tis a symlink, can also be just /dev/ttyACM0
|
|
#define LCD_INTERVAL_MS 1000
|
|
#define LCD_CONTRAST 215
|
|
|
|
std::chrono::milliseconds interval(LCD_INTERVAL_MS);
|
|
std::stop_source sigint;
|
|
|
|
struct sensors_t {
|
|
std::array<std::string, 2> td;
|
|
std::string loadavg;
|
|
mem_usage_t ram;
|
|
mem_usage_t home;
|
|
gpu_t gpu;
|
|
cpu_t cpu;
|
|
float hass_state = 0;
|
|
};
|
|
|
|
void sighandler(int s) {
|
|
std::println("[Signal] got SIGINT, exiting...");
|
|
sigint.request_stop();
|
|
}
|
|
|
|
void hass_thread(sensors_t *s, std::stop_token st) {
|
|
std::println("[Thread] Starting hass_thread, pid {}", gettid());
|
|
hass_connect();
|
|
while (!st.stop_requested()) {
|
|
hass_poll();
|
|
s->hass_state = hass_get();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
}
|
|
hass_disconnect();
|
|
}
|
|
|
|
void sensors_thread(sensors_t *s, std::stop_token st) {
|
|
std::println("[Thread] Starting sensors_thread, pid {}", gettid());
|
|
/* find hwmon paths from pci addresses */
|
|
cpu_hwmon_t cpu_hwmon = detectCpuHwmon("0000:00:18.3");
|
|
std::string gpu_hwmon = detectGpuHwmon("0000:08:00.0");
|
|
|
|
while (!st.stop_requested()) {
|
|
auto start = std::chrono::steady_clock::now();
|
|
s->td = getTimeDate();
|
|
s->loadavg = getAvgs();
|
|
s->ram = getRam();
|
|
s->home = getDisk("/home/drath");
|
|
s->cpu = getCpu(cpu_hwmon);
|
|
s->gpu = getGpu(gpu_hwmon);
|
|
|
|
// std::print("[Sensors] took {} microseconds \r", std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start).count());
|
|
// std::cout << std::flush;
|
|
std::this_thread::sleep_until(start + interval);
|
|
}
|
|
}
|
|
|
|
void display_thread(sensors_t *s, std::stop_token st) {
|
|
std::println("[Thread] Starting display_thread, pid {}", gettid());
|
|
LCDDisplay lcd(LCD_PORT);
|
|
lcd.setCustomChar(0, {16, 6, 9, 8, 8, 9, 6, 0}); // celcius
|
|
|
|
std::println("[Chrono] Running in daemon mode, {} ms interval", LCD_INTERVAL_MS);
|
|
lcd.setContrast(LCD_CONTRAST);
|
|
lcd.setBacklight(true);
|
|
lcd.clear();
|
|
|
|
while (!st.stop_requested()) {
|
|
auto start = std::chrono::steady_clock::now();
|
|
std::array<std::string, 4> lines;
|
|
|
|
auto gpu_temps = (s->gpu.hotspot_temp) ? "/" + std::to_string(s->gpu.hotspot_temp) : "";
|
|
gpu_temps += (s->gpu.mem_temp) ? "/" + std::to_string(s->gpu.mem_temp) : "";
|
|
|
|
lcd.writeBuf(0, 0, pad(s->td[1], 11, true) + " " + s->td[0] + lcd.bar(1, s->gpu.core_usage / 100.0) + pad(s->loadavg, 17));
|
|
|
|
lcd.writeBuf(1, 0, pad(std::to_string(s->cpu.tctl) + "/" + std::to_string(s->cpu.tccd1) + lcd.cc[0], 8, true));
|
|
lcd.writeBuf(1, 8, pad(pBytes(s->ram.used, true) + "B", 7, true));
|
|
lcd.writeBuf(1, 16, pad(pNum(s->hass_state) + "W", 4));
|
|
lcd.writeBuf(1, 22, pad(pBytes(s->gpu.vram_used) + "B", 7));
|
|
lcd.writeBuf(1, 29, pad(std::to_string(s->gpu.edge_temp) + gpu_temps + lcd.cc[0], 11));
|
|
|
|
lcd.writeBuf(2, 0, pad(pNum(s->cpu.ptotal, 1) + "W", 8, true));
|
|
lcd.writeBuf(2, 14, "home:" + pad(pBytes(s->home.free), 5));
|
|
|
|
lcd.writeBuf(2, 25, pad(std::to_string(s->gpu.fan_speed), 4) + "R");
|
|
// std::println("{}", s->gpu.fan_speed);
|
|
lcd.writeBuf(2, 31, pad(std::to_string(s->gpu.power_avg) + "/" + std::to_string(s->gpu.power_cap) + "W", 9));
|
|
|
|
lcd.writeBuf(3, 0, pad(pNum(s->cpu.vcore, 3) + "V", 7, true));
|
|
lcd.writeBuf(3, 7, std::to_string(s->cpu.avg_freq) + "MHz");
|
|
lcd.writeBuf(3, 21, pad(std::to_string(s->gpu.core_clock) + "/" + std::to_string(s->gpu.mem_clock) + "MHz ", 13));
|
|
lcd.writeBuf(3, 34, pad(pNum(s->gpu.vcore, 3) + "Vabscd", 5));
|
|
|
|
lcd.flushBuffer();
|
|
|
|
std::this_thread::sleep_until(start + interval);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
signal(SIGINT, sighandler);
|
|
|
|
sensors_t sensors;
|
|
|
|
std::jthread producer(sensors_thread, &sensors, sigint.get_token());
|
|
std::jthread hass(hass_thread, &sensors, sigint.get_token());
|
|
|
|
display_thread(&sensors, sigint.get_token());
|
|
return 0;
|
|
}
|