mirror of
https://github.com/meshtastic/firmware.git
synced 2025-06-11 07:32:14 +00:00

Some checks are pending
CI / setup (check) (push) Waiting to run
CI / setup (esp32) (push) Waiting to run
CI / setup (esp32c3) (push) Waiting to run
CI / setup (esp32c6) (push) Waiting to run
CI / setup (esp32s3) (push) Waiting to run
CI / setup (nrf52840) (push) Waiting to run
CI / setup (rp2040) (push) Waiting to run
CI / setup (stm32) (push) Waiting to run
CI / check (push) Blocked by required conditions
CI / build-esp32 (push) Blocked by required conditions
CI / build-esp32-s3 (push) Blocked by required conditions
CI / build-esp32-c3 (push) Blocked by required conditions
CI / build-esp32-c6 (push) Blocked by required conditions
CI / build-nrf52 (push) Blocked by required conditions
CI / build-rpi2040 (push) Blocked by required conditions
CI / build-stm32 (push) Blocked by required conditions
CI / build-debian-src (push) Waiting to run
CI / package-pio-deps-native-tft (push) Waiting to run
CI / test-native (push) Waiting to run
CI / docker-deb-amd64 (push) Waiting to run
CI / docker-deb-amd64-tft (push) Waiting to run
CI / docker-alp-amd64 (push) Waiting to run
CI / docker-alp-amd64-tft (push) Waiting to run
CI / docker-deb-arm64 (push) Waiting to run
CI / docker-deb-armv7 (push) Waiting to run
CI / gather-artifacts (esp32) (push) Blocked by required conditions
CI / gather-artifacts (esp32c3) (push) Blocked by required conditions
CI / gather-artifacts (esp32c6) (push) Blocked by required conditions
CI / gather-artifacts (esp32s3) (push) Blocked by required conditions
CI / gather-artifacts (nrf52840) (push) Blocked by required conditions
CI / gather-artifacts (rp2040) (push) Blocked by required conditions
CI / gather-artifacts (stm32) (push) Blocked by required conditions
CI / release-artifacts (push) Blocked by required conditions
CI / release-firmware (esp32) (push) Blocked by required conditions
CI / release-firmware (esp32c3) (push) Blocked by required conditions
CI / release-firmware (esp32c6) (push) Blocked by required conditions
CI / release-firmware (esp32s3) (push) Blocked by required conditions
CI / release-firmware (nrf52840) (push) Blocked by required conditions
CI / release-firmware (rp2040) (push) Blocked by required conditions
CI / release-firmware (stm32) (push) Blocked by required conditions
CI / publish-firmware (push) Blocked by required conditions
140 lines
5.4 KiB
C++
140 lines
5.4 KiB
C++
#include "HostMetrics.h"
|
|
#include "../mesh/generated/meshtastic/telemetry.pb.h"
|
|
#include "MeshService.h"
|
|
#if ARCH_PORTDUINO
|
|
#include "PortduinoGlue.h"
|
|
#include <filesystem>
|
|
#endif
|
|
|
|
int32_t HostMetricsModule::runOnce()
|
|
{
|
|
#if ARCH_PORTDUINO
|
|
if (settingsMap[hostMetrics_interval] == 0) {
|
|
return disable();
|
|
} else {
|
|
sendMetrics();
|
|
return 60 * 1000 * settingsMap[hostMetrics_interval];
|
|
}
|
|
#else
|
|
return disable();
|
|
#endif
|
|
}
|
|
|
|
bool HostMetricsModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
|
|
{
|
|
// Don't worry about storing telemetry in NodeDB if we're a repeater
|
|
if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER)
|
|
return false;
|
|
|
|
if (t->which_variant == meshtastic_Telemetry_host_metrics_tag) {
|
|
#ifdef DEBUG_PORT
|
|
const char *sender = getSenderShortName(mp);
|
|
|
|
LOG_INFO("(Received Host Metrics from %s): uptime=%u, diskfree=%lu, memory free=%lu, load=%04.2f, %04.2f, %04.2f, %s",
|
|
sender, t->variant.host_metrics.uptime_seconds, t->variant.host_metrics.diskfree1_bytes,
|
|
t->variant.host_metrics.freemem_bytes, static_cast<float>(t->variant.host_metrics.load1) / 100,
|
|
static_cast<float>(t->variant.host_metrics.load5) / 100,
|
|
static_cast<float>(t->variant.host_metrics.load15) / 100,
|
|
t->variant.host_metrics.has_user_string ? t->variant.host_metrics.user_string : "");
|
|
#endif
|
|
}
|
|
return false; // Let others look at this message also if they want
|
|
}
|
|
|
|
/*
|
|
meshtastic_MeshPacket *HostMetricsModule::allocReply()
|
|
{
|
|
if (currentRequest) {
|
|
auto req = *currentRequest;
|
|
const auto &p = req.decoded;
|
|
meshtastic_Telemetry scratch;
|
|
meshtastic_Telemetry *decoded = NULL;
|
|
memset(&scratch, 0, sizeof(scratch));
|
|
if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_HostMetrics_msg, &scratch)) {
|
|
decoded = &scratch;
|
|
} else {
|
|
LOG_ERROR("Error decoding HostMetrics module!");
|
|
return NULL;
|
|
}
|
|
// Check for a request for device metrics
|
|
if (decoded->which_variant == meshtastic_Telemetry_host_metrics_tag) {
|
|
LOG_INFO("Device telemetry reply to request");
|
|
return allocDataProtobuf(getHostMetrics());
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
*/
|
|
|
|
#if ARCH_PORTDUINO
|
|
meshtastic_Telemetry HostMetricsModule::getHostMetrics()
|
|
{
|
|
std::string file_line;
|
|
meshtastic_Telemetry t = meshtastic_Telemetry_init_zero;
|
|
t.which_variant = meshtastic_Telemetry_host_metrics_tag;
|
|
t.variant.host_metrics = meshtastic_HostMetrics_init_zero;
|
|
|
|
if (access("/proc/uptime", R_OK) == 0) {
|
|
std::ifstream proc_uptime("/proc/uptime");
|
|
if (proc_uptime.is_open()) {
|
|
std::getline(proc_uptime, file_line, ' ');
|
|
proc_uptime.close();
|
|
t.variant.host_metrics.uptime_seconds = stoul(file_line);
|
|
}
|
|
}
|
|
|
|
std::filesystem::space_info root = std::filesystem::space("/");
|
|
t.variant.host_metrics.diskfree1_bytes = root.available;
|
|
|
|
if (access("/proc/meminfo", R_OK) == 0) {
|
|
std::ifstream proc_meminfo("/proc/meminfo");
|
|
if (proc_meminfo.is_open()) {
|
|
do {
|
|
std::getline(proc_meminfo, file_line);
|
|
} while (file_line.find("MemAvailable") == std::string::npos);
|
|
proc_meminfo.close();
|
|
t.variant.host_metrics.freemem_bytes = stoull(file_line.substr(file_line.find_first_of("0123456789"))) * 1024;
|
|
}
|
|
}
|
|
if (access("/proc/loadavg", R_OK) == 0) {
|
|
std::ifstream proc_loadavg("/proc/loadavg");
|
|
if (proc_loadavg.is_open()) {
|
|
std::getline(proc_loadavg, file_line, ' ');
|
|
t.variant.host_metrics.load1 = stof(file_line) * 100;
|
|
std::getline(proc_loadavg, file_line, ' ');
|
|
t.variant.host_metrics.load5 = stof(file_line) * 100;
|
|
std::getline(proc_loadavg, file_line, ' ');
|
|
t.variant.host_metrics.load15 = stof(file_line) * 100;
|
|
proc_loadavg.close();
|
|
}
|
|
}
|
|
if (settingsStrings[hostMetrics_user_command] != "") {
|
|
std::string userCommandResult = exec(settingsStrings[hostMetrics_user_command].c_str());
|
|
if (userCommandResult.length() > 1) {
|
|
strncpy(t.variant.host_metrics.user_string, userCommandResult.c_str(), 200);
|
|
t.variant.host_metrics.has_user_string = true;
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
|
|
bool HostMetricsModule::sendMetrics()
|
|
{
|
|
meshtastic_Telemetry telemetry = getHostMetrics();
|
|
LOG_INFO("Send: uptime=%u, diskfree=%lu, memory free=%lu, load=%04.2f, %04.2f, %04.2f %s",
|
|
telemetry.variant.host_metrics.uptime_seconds, telemetry.variant.host_metrics.diskfree1_bytes,
|
|
telemetry.variant.host_metrics.freemem_bytes, static_cast<float>(telemetry.variant.host_metrics.load1) / 100,
|
|
static_cast<float>(telemetry.variant.host_metrics.load5) / 100,
|
|
static_cast<float>(telemetry.variant.host_metrics.load15) / 100,
|
|
telemetry.variant.host_metrics.has_user_string ? telemetry.variant.host_metrics.user_string : "");
|
|
|
|
meshtastic_MeshPacket *p = allocDataProtobuf(telemetry);
|
|
p->to = NODENUM_BROADCAST;
|
|
p->decoded.want_response = false;
|
|
p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
|
|
p->channel = settingsMap[hostMetrics_channel];
|
|
LOG_INFO("Send packet to mesh");
|
|
service->sendToMesh(p, RX_SRC_LOCAL, true);
|
|
return true;
|
|
}
|
|
#endif |