Public Access
S1 #11: the System App: tasks, memory, network and system, live
Five views, Tab between them: Overview (each core's load, memory, traffic, battery, two minutes of load), Tasks (share of a core over the last second, lowest free stack, flagged under 512 bytes; `s` sorts), Memory (free heap against the floors of Q86), Network (bytes per service, and what's moving now), System (what `info` prints, plus battery, card, radio, GNSS). It samples once a second and keeps history only while open. The arithmetic is host-tested, including the trap found on the device: a task's run-time counter only moves when it's switched out, so the task that samples (the main loop, alone on its core) gets what's left of its core. `tasks` now samples across a second of normal running instead of inside its own wait. The main loop uses 100 % of core 1 at rest (#40). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EhqxQ49eCju4CzKYNjZzwT
This commit is contained in:
Claude Opus 5.5
@@ -0,0 +1,361 @@
|
||||
#include "system_app.h"
|
||||
|
||||
#include <Arduino.h>
|
||||
#include <SD.h>
|
||||
#include <esp_heap_caps.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
|
||||
#include "cleanup_plan.h"
|
||||
#include "platform/system_info.h"
|
||||
#include "sd_fault.h"
|
||||
#include "services/gemini_service.h"
|
||||
#include "ui/canvas.h"
|
||||
#include "ui/fonts.h"
|
||||
#include "ui/theme.h"
|
||||
#include "ui/widgets.h"
|
||||
|
||||
namespace roro {
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr size_t kUsers = static_cast<size_t>(net::User::Count);
|
||||
|
||||
// Collects what the console's `info` prints, so the System view can't drift from it (Q125).
|
||||
class Lines : public Print {
|
||||
public:
|
||||
size_t write(uint8_t ch) override {
|
||||
if (ch == '\n') {
|
||||
lines.push_back(current_);
|
||||
current_.clear();
|
||||
} else if (ch != '\r') {
|
||||
current_ += static_cast<char>(ch);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> lines;
|
||||
|
||||
private:
|
||||
std::string current_;
|
||||
};
|
||||
|
||||
std::string duration(uint32_t seconds) {
|
||||
char s[24];
|
||||
if (seconds < 3600) std::snprintf(s, sizeof s, "%lu min %02lu s", (unsigned long)(seconds / 60), (unsigned long)(seconds % 60));
|
||||
else std::snprintf(s, sizeof s, "%lu h %02lu min", (unsigned long)(seconds / 3600), (unsigned long)(seconds / 60 % 60));
|
||||
return s;
|
||||
}
|
||||
|
||||
// A filled bar for a percentage; the warning colour from 90 %.
|
||||
void bar(Canvas& c, int x, int y, int w, int percent) {
|
||||
c.drawRect(x, y, w, 9, theme::kMuted);
|
||||
int filled = std::clamp(percent, 0, 100) * (w - 2) / 100;
|
||||
if (filled > 0) c.fillRect(x + 1, y + 1, filled, 7, percent >= 90 ? theme::kWarning : theme::kAccent);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void SystemApp::onEnter() {
|
||||
view_ = View::Overview;
|
||||
beforeTotal_ = system_info::sampleTasks(before_);
|
||||
sampledMs_ = millis();
|
||||
for (size_t i = 0; i < kUsers; i++) traffic_[i] = net::traffic(static_cast<net::User>(i));
|
||||
requestRedraw();
|
||||
}
|
||||
|
||||
void SystemApp::onExit() { // nothing is kept while it's closed (Q120)
|
||||
std::vector<TaskSample>().swap(before_);
|
||||
std::vector<TaskRow>().swap(rows_);
|
||||
std::vector<std::string>().swap(systemLines_);
|
||||
for (auto& h : loadHistory_) h.clear();
|
||||
heapHistory_.clear();
|
||||
load_[0] = load_[1] = -1;
|
||||
}
|
||||
|
||||
bool SystemApp::onKey(const KeyEvent& e) {
|
||||
if (e.key == Key::Tab) {
|
||||
int n = static_cast<int>(View::Count), v = static_cast<int>(view_);
|
||||
view_ = static_cast<View>(e.shift ? (v + n - 1) % n : (v + 1) % n);
|
||||
taskTop_ = systemTop_ = 0;
|
||||
requestRedraw();
|
||||
return true;
|
||||
}
|
||||
int step = e.key == Key::Up ? -1 : e.key == Key::Down ? 1 : 0;
|
||||
if (step && view_ == View::Tasks) {
|
||||
taskTop_ = std::clamp(taskTop_ + step, 0, std::max(0, static_cast<int>(rows_.size()) - kTaskRows));
|
||||
requestRedraw();
|
||||
return true;
|
||||
}
|
||||
if (step && view_ == View::System) {
|
||||
systemTop_ = std::clamp(systemTop_ + step, 0, std::max(0, wrappedLines_ - 8));
|
||||
requestRedraw();
|
||||
return true;
|
||||
}
|
||||
if (view_ == View::Tasks && e.key == Key::Char && (e.ch == 's' || e.ch == 'S')) { // Q122
|
||||
sort_ = static_cast<TaskSort>((static_cast<int>(sort_) + 1) % 3);
|
||||
sortTasks(rows_, sort_);
|
||||
taskTop_ = 0;
|
||||
requestRedraw();
|
||||
return true;
|
||||
}
|
||||
return false; // Back leaves the App
|
||||
}
|
||||
|
||||
void SystemApp::update(uint32_t nowMs) {
|
||||
if (nowMs - sampledMs_ >= 1000) sample(nowMs);
|
||||
}
|
||||
|
||||
// Once a second (Q119): the tasks' shares over that second, the cores' load, the heap, the traffic.
|
||||
void SystemApp::sample(uint32_t nowMs) {
|
||||
uint32_t elapsedMs = nowMs - sampledMs_;
|
||||
sampledMs_ = nowMs;
|
||||
|
||||
std::vector<TaskSample> now;
|
||||
uint32_t total = system_info::sampleTasks(now);
|
||||
rows_ = taskRows(before_, beforeTotal_, now, total);
|
||||
sortTasks(rows_, sort_);
|
||||
before_.swap(now);
|
||||
beforeTotal_ = total;
|
||||
for (int core = 0; core < 2; core++) {
|
||||
load_[core] = coreLoad(rows_, core);
|
||||
loadHistory_[core].push(static_cast<uint8_t>(std::max(0, load_[core])));
|
||||
}
|
||||
heapHistory_.push(static_cast<uint16_t>(ESP.getFreeHeap() / 1024));
|
||||
|
||||
for (size_t i = 0; i < kUsers; i++) {
|
||||
net::Traffic t = net::traffic(static_cast<net::User>(i));
|
||||
rateIn_[i] = net::bytesPerSecond(traffic_[i].in, t.in, elapsedMs);
|
||||
rateOut_[i] = net::bytesPerSecond(traffic_[i].out, t.out, elapsedMs);
|
||||
traffic_[i] = t;
|
||||
}
|
||||
|
||||
if (view_ == View::System) { // the slow things: only while they're on screen
|
||||
Lines out;
|
||||
system_info::printSystem(out);
|
||||
const BatteryEstimator& b = battery_.estimator();
|
||||
if (b.hasReading()) out.printf("battery: %d %%, %d.%02d V\n", b.percent(), b.millivolts() / 1000, b.millivolts() % 1000 / 10);
|
||||
StorageState card = storage_.state();
|
||||
if (card.present)
|
||||
out.printf("sd: %s of %s used, %u write faults\n", formatBytes(card.usedBytes).c_str(), formatBytes(card.totalBytes).c_str(),
|
||||
(unsigned)sdLastFault().count);
|
||||
else out.println("sd: no card");
|
||||
out.printf("radio: %s\n", !radio_.present() ? "none" : radio_.sweeping() ? "sweeping" : radio_.listening() ? "listening" : "asleep");
|
||||
const auto& g = gnss_.state();
|
||||
out.printf("gnss: %s, %d satellites used\n", !gnss_.on() ? "off" : gnss_.receiving(nowMs) ? "receiving" : "silent", g.satellitesUsed);
|
||||
system_info::printSlots(out, store_);
|
||||
systemLines_.swap(out.lines);
|
||||
}
|
||||
requestRedraw();
|
||||
}
|
||||
|
||||
void SystemApp::footer(Canvas& c, const char* keys) {
|
||||
const auto& area = theme::kContent;
|
||||
c.setFont(&fonts::small);
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.setTextDatum(top_left);
|
||||
c.drawString(keys, 4, area.y + area.h - 9);
|
||||
}
|
||||
|
||||
void SystemApp::draw(Canvas& c) {
|
||||
c.setTextDatum(top_left);
|
||||
switch (view_) {
|
||||
case View::Overview: drawOverview(c); break;
|
||||
case View::Tasks: drawTasks(c); break;
|
||||
case View::Memory: drawMemory(c); break;
|
||||
case View::Network: drawNetwork(c); break;
|
||||
case View::System: drawSystem(c); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
void SystemApp::drawOverview(Canvas& c) {
|
||||
const auto& area = theme::kContent;
|
||||
char line[72];
|
||||
c.setFont(&fonts::body);
|
||||
int y = area.y + 2;
|
||||
for (int core = 0; core < 2; core++) {
|
||||
c.setTextColor(theme::kMuted);
|
||||
std::snprintf(line, sizeof line, "Core %d", core);
|
||||
c.drawString(line, 4, y);
|
||||
bar(c, 52, y + 2, 130, load_[core]);
|
||||
c.setTextColor(theme::kText);
|
||||
if (load_[core] >= 0) std::snprintf(line, sizeof line, "%d%%", load_[core]);
|
||||
else std::snprintf(line, sizeof line, "...");
|
||||
c.drawString(line, 190, y);
|
||||
y += theme::kLineHeight;
|
||||
}
|
||||
auto row = [&](const char* label, const std::string& value) {
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString(label, 4, y);
|
||||
c.setTextColor(theme::kText);
|
||||
c.drawString(value.c_str(), 62, y);
|
||||
y += theme::kLineHeight;
|
||||
};
|
||||
std::snprintf(line, sizeof line, "%u KB free, lowest %u", (unsigned)(ESP.getFreeHeap() / 1024), (unsigned)(ESP.getMinFreeHeap() / 1024));
|
||||
row("Memory", line);
|
||||
uint32_t in = 0, out = 0;
|
||||
for (size_t i = 0; i < kUsers; i++) in += rateIn_[i], out += rateOut_[i];
|
||||
if (wifi_.state() == WifiController::State::Connected)
|
||||
std::snprintf(line, sizeof line, "%s/s in, %s/s out", net::formatTraffic(in).c_str(), net::formatTraffic(out).c_str());
|
||||
else std::snprintf(line, sizeof line, "not connected");
|
||||
row("Network", line);
|
||||
const BatteryEstimator& b = battery_.estimator();
|
||||
if (b.hasReading()) std::snprintf(line, sizeof line, "%d%%, %d.%02d V", b.percent(), b.millivolts() / 1000, b.millivolts() % 1000 / 10);
|
||||
else std::snprintf(line, sizeof line, "...");
|
||||
row("Battery", line);
|
||||
std::snprintf(line, sizeof line, "%s, %.0f C", duration(millis() / 1000).c_str(), temperatureRead());
|
||||
row("Uptime", line);
|
||||
|
||||
// Both cores over the last two minutes: core 0 in the accent colour, core 1 in green.
|
||||
int gx = 4, gy = y + 3, gw = static_cast<int>(kHistory) * 2 - 8, gh = area.y + area.h - 12 - gy;
|
||||
if (gh > 8) {
|
||||
c.drawRect(gx, gy, gw + 2, gh + 2, theme::kMuted);
|
||||
for (int core = 0; core < 2; core++) {
|
||||
const auto& h = loadHistory_[core];
|
||||
for (size_t i = 1; i < h.size(); i++) {
|
||||
int x0 = gx + 1 + static_cast<int>((i - 1) * gw / kHistory), x1 = gx + 1 + static_cast<int>(i * gw / kHistory);
|
||||
c.drawLine(x0, gy + gh - h.at(i - 1) * gh / 100, x1, gy + gh - h.at(i) * gh / 100, core ? theme::kMessage : theme::kAccent);
|
||||
}
|
||||
}
|
||||
}
|
||||
footer(c, "Tab: tasks, memory, network, system");
|
||||
}
|
||||
|
||||
void SystemApp::drawTasks(Canvas& c) {
|
||||
const auto& area = theme::kContent;
|
||||
c.setFont(&fonts::small);
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString("task", 4, area.y + 2);
|
||||
c.setTextDatum(top_right);
|
||||
c.drawString("core", 128, area.y + 2);
|
||||
c.drawString("cpu", 176, area.y + 2);
|
||||
c.drawString("stack left", area.w - 4, area.y + 2);
|
||||
c.setFont(&fonts::body);
|
||||
char cell[16];
|
||||
for (int i = 0; i < kTaskRows && taskTop_ + i < static_cast<int>(rows_.size()); i++) {
|
||||
const TaskRow& r = rows_[taskTop_ + i];
|
||||
int y = area.y + 12 + i * theme::kLineHeight;
|
||||
c.setTextDatum(top_left);
|
||||
c.setTextColor(r.idle ? theme::kMuted : theme::kText);
|
||||
c.drawString(r.name.c_str(), 4, y);
|
||||
c.setTextDatum(top_right);
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString(r.core < 0 ? "any" : std::to_string(r.core).c_str(), 128, y);
|
||||
c.setTextColor(r.idle ? theme::kMuted : theme::kText);
|
||||
std::snprintf(cell, sizeof cell, "%u.%u%%", r.permille / 10, r.permille % 10);
|
||||
c.drawString(cell, 176, y);
|
||||
c.setTextColor(r.lowStack ? theme::kWarning : theme::kMuted); // Q122: under 512 bytes
|
||||
c.drawString(std::to_string(r.stackFree).c_str(), area.w - 4, y);
|
||||
}
|
||||
c.setTextDatum(top_left);
|
||||
std::string keys = std::string("s: by ") + (sort_ == TaskSort::Share ? "stack" : sort_ == TaskSort::Stack ? "name" : "cpu") +
|
||||
" " + std::to_string(rows_.size()) + " tasks Tab: memory";
|
||||
footer(c, keys.c_str());
|
||||
}
|
||||
|
||||
void SystemApp::drawMemory(Canvas& c) {
|
||||
const auto& area = theme::kContent;
|
||||
char line[72];
|
||||
c.setFont(&fonts::body);
|
||||
c.setTextColor(theme::kText);
|
||||
std::snprintf(line, sizeof line, "%.1f KB free, lowest %.1f", ESP.getFreeHeap() / 1024.0, ESP.getMinFreeHeap() / 1024.0);
|
||||
c.drawString(line, 4, area.y + 2);
|
||||
c.setTextColor(theme::kMuted);
|
||||
std::snprintf(line, sizeof line, "largest free block %.1f KB", heap_caps_get_largest_free_block(MALLOC_CAP_8BIT) / 1024.0);
|
||||
c.drawString(line, 4, area.y + 2 + theme::kLineHeight);
|
||||
|
||||
// Free heap over two minutes, with the floors of Q86 as lines.
|
||||
int gx = 26, gy = area.y + 32, gw = area.w - gx - 6, gh = area.y + area.h - 12 - gy;
|
||||
uint16_t top = 128; // KB at the top of the scale: more if the heap has been higher
|
||||
for (size_t i = 0; i < heapHistory_.size(); i++) top = std::max<uint16_t>(top, heapHistory_.at(i) + 8);
|
||||
auto yOf = [&](int kb) { return gy + gh - std::clamp(kb, 0, static_cast<int>(top)) * gh / top; };
|
||||
c.drawRect(gx, gy, gw, gh + 1, theme::kMuted);
|
||||
c.setFont(&fonts::small);
|
||||
struct {
|
||||
size_t bytes;
|
||||
uint16_t color;
|
||||
} floors[] = {{GeminiService::kStartFloor, theme::kMuted}, {GeminiService::kSteadyFloor, theme::kWarning}, {GeminiService::kTransientFloor, theme::kMessage}};
|
||||
for (auto& f : floors) {
|
||||
int kb = static_cast<int>(f.bytes / 1024), y = yOf(kb);
|
||||
for (int x = gx + 1; x < gx + gw - 1; x += 4) c.drawPixel(x, y, f.color);
|
||||
c.setTextColor(f.color);
|
||||
c.setTextDatum(top_right);
|
||||
c.drawString(std::to_string(kb).c_str(), gx - 3, y - 3);
|
||||
}
|
||||
c.setTextDatum(top_left);
|
||||
for (size_t i = 1; i < heapHistory_.size(); i++) {
|
||||
int x0 = gx + 1 + static_cast<int>((i - 1) * (gw - 2) / kHistory), x1 = gx + 1 + static_cast<int>(i * (gw - 2) / kHistory);
|
||||
c.drawLine(x0, yOf(heapHistory_.at(i - 1)), x1, yOf(heapHistory_.at(i)), theme::kAccent);
|
||||
}
|
||||
footer(c, "KB free, 2 min, with the floors Tab: network");
|
||||
}
|
||||
|
||||
void SystemApp::drawNetwork(Canvas& c) {
|
||||
const auto& area = theme::kContent;
|
||||
char line[72];
|
||||
c.setFont(&fonts::body);
|
||||
WifiService::Connection n = wifi_.connection();
|
||||
c.setTextColor(n.connected ? theme::kText : theme::kWarning);
|
||||
if (n.connected) std::snprintf(line, sizeof line, "%s, %d dBm", wifi_.ssid().c_str(), wifi_.rssi());
|
||||
else std::snprintf(line, sizeof line, "Wi-Fi isn't connected");
|
||||
c.drawString(line, 4, area.y + 2);
|
||||
if (n.connected) {
|
||||
c.setTextColor(theme::kMuted);
|
||||
std::snprintf(line, sizeof line, "%s/%d %s, gw %s", n.address.c_str(), n.prefix, n.fixed ? "fixed" : "DHCP",
|
||||
n.gateway.empty() ? "none" : n.gateway.c_str());
|
||||
c.drawString(line, 4, area.y + 2 + theme::kLineHeight);
|
||||
}
|
||||
// Per service (Q121): totals since boot, and the last second.
|
||||
int y = area.y + 32;
|
||||
c.setFont(&fonts::small);
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString("service", 4, y);
|
||||
c.setTextDatum(top_right);
|
||||
c.drawString("in", 124, y);
|
||||
c.drawString("out", 168, y);
|
||||
c.drawString("now, /s", area.w - 4, y);
|
||||
c.setFont(&fonts::body);
|
||||
y += 10;
|
||||
for (size_t i = 0; i < kUsers; i++) {
|
||||
bool active = rateIn_[i] || rateOut_[i];
|
||||
c.setTextDatum(top_left);
|
||||
c.setTextColor(active ? theme::kMessage : theme::kText);
|
||||
c.drawString(net::userName(static_cast<net::User>(i)), 4, y);
|
||||
c.setTextDatum(top_right);
|
||||
c.setTextColor(theme::kText);
|
||||
c.drawString(net::formatTraffic(traffic_[i].in).c_str(), 124, y);
|
||||
c.drawString(net::formatTraffic(traffic_[i].out).c_str(), 168, y);
|
||||
c.setTextColor(active ? theme::kMessage : theme::kMuted);
|
||||
c.drawString(active ? net::formatTraffic(rateIn_[i] + rateOut_[i]).c_str() : "-", area.w - 4, y);
|
||||
y += theme::kLineHeight;
|
||||
}
|
||||
c.setTextDatum(top_left);
|
||||
footer(c, "bytes since boot Tab: system");
|
||||
}
|
||||
|
||||
void SystemApp::drawSystem(Canvas& c) {
|
||||
const auto& area = theme::kContent;
|
||||
if (systemLines_.empty()) {
|
||||
c.setFont(&fonts::body);
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString("Reading...", 4, area.y + 4);
|
||||
return;
|
||||
}
|
||||
// The console's lines are longer than the screen: wrap them, continuation lines indented.
|
||||
std::vector<std::string> wrapped;
|
||||
auto measure = widgets::bodyMeasure(c);
|
||||
for (const std::string& line : systemLines_) {
|
||||
bool first = true;
|
||||
for (const std::string& part : wrapText(line, area.w - 14, measure)) {
|
||||
wrapped.push_back(first ? part : " " + part);
|
||||
first = false;
|
||||
}
|
||||
}
|
||||
wrappedLines_ = static_cast<int>(wrapped.size());
|
||||
systemTop_ = std::clamp(systemTop_, 0, std::max(0, wrappedLines_ - 8));
|
||||
widgets::textLines(c, wrapped, systemTop_, {area.x + 2, area.y + 2, area.w - 2, area.h - 12});
|
||||
footer(c, "Tab: overview");
|
||||
}
|
||||
|
||||
} // namespace roro
|
||||
@@ -0,0 +1,67 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "app.h"
|
||||
#include "key_value_store.h"
|
||||
#include "services/battery_service.h"
|
||||
#include "services/gnss_service.h"
|
||||
#include "services/radio_service.h"
|
||||
#include "services/storage_service.h"
|
||||
#include "services/wifi_service.h"
|
||||
#include "task_stats.h"
|
||||
#include "traffic.h"
|
||||
|
||||
namespace roro {
|
||||
|
||||
// The System App (docs/milestones/S1.md, Q117 to Q127): what the device is doing, live and
|
||||
// read-only. Tab moves between Overview, Tasks, Memory, Network and System. It samples once a
|
||||
// second and keeps two minutes of history, only while it's open (Q120).
|
||||
class SystemApp : public App {
|
||||
public:
|
||||
SystemApp(WifiService& wifi, BatteryService& battery, StorageService& storage, RadioService& radio, GnssService& gnss,
|
||||
KeyValueStore& store)
|
||||
: wifi_(wifi), battery_(battery), storage_(storage), radio_(radio), gnss_(gnss), store_(store) {}
|
||||
void onEnter() override;
|
||||
void onExit() override;
|
||||
bool onKey(const KeyEvent& e) override;
|
||||
void update(uint32_t nowMs) override;
|
||||
void draw(Canvas& c) override;
|
||||
|
||||
private:
|
||||
enum class View : uint8_t { Overview, Tasks, Memory, Network, System, Count };
|
||||
static constexpr size_t kHistory = 120; // seconds
|
||||
static constexpr int kTaskRows = 7;
|
||||
|
||||
void sample(uint32_t nowMs);
|
||||
void drawOverview(Canvas& c);
|
||||
void drawTasks(Canvas& c);
|
||||
void drawMemory(Canvas& c);
|
||||
void drawNetwork(Canvas& c);
|
||||
void drawSystem(Canvas& c);
|
||||
void footer(Canvas& c, const char* keys);
|
||||
|
||||
WifiService& wifi_;
|
||||
BatteryService& battery_;
|
||||
StorageService& storage_;
|
||||
RadioService& radio_;
|
||||
GnssService& gnss_;
|
||||
KeyValueStore& store_;
|
||||
View view_ = View::Overview;
|
||||
uint32_t sampledMs_ = 0;
|
||||
std::vector<TaskSample> before_;
|
||||
uint32_t beforeTotal_ = 0;
|
||||
std::vector<TaskRow> rows_; // the last second, sorted
|
||||
TaskSort sort_ = TaskSort::Share;
|
||||
int taskTop_ = 0;
|
||||
int load_[2] = {-1, -1};
|
||||
History<uint8_t, kHistory> loadHistory_[2];
|
||||
History<uint16_t, kHistory> heapHistory_; // free heap, KB
|
||||
net::Traffic traffic_[static_cast<size_t>(net::User::Count)];
|
||||
uint32_t rateIn_[static_cast<size_t>(net::User::Count)] = {}, rateOut_[static_cast<size_t>(net::User::Count)] = {};
|
||||
std::vector<std::string> systemLines_;
|
||||
int systemTop_ = 0, wrappedLines_ = 0;
|
||||
};
|
||||
|
||||
} // namespace roro
|
||||
+23
-2
@@ -14,6 +14,7 @@
|
||||
#include "apps/launcher_app.h"
|
||||
#include "apps/lora_scanner_app.h"
|
||||
#include "apps/settings_app.h"
|
||||
#include "apps/system_app.h"
|
||||
#include "apps/wifi_tools_app.h"
|
||||
#include "apps/setup_app.h"
|
||||
#include "event_bus.h"
|
||||
@@ -196,6 +197,8 @@ void setup() {
|
||||
apps->registerApp({"gnss", "GNSS", false, new GnssApp(*gnssService, settings)});
|
||||
apps->registerApp({"gemini", "Gemini", false, new GeminiApp(*geminiService)});
|
||||
apps->registerApp({"lora", "LoRa Scanner", false, new LoraScannerApp(*radioService, *loraCapture, settings, *clockService)});
|
||||
apps->registerApp({"system", "System", false,
|
||||
new SystemApp(*wifi, *battery, *storageService, *radioService, *gnssService, nvs)});
|
||||
apps->registerApp({"settings", "Settings", false,
|
||||
new SettingsApp({settings, bus, *apps, *battery, *storageService, *clockService, *wifi, *savedNetworks, *update})});
|
||||
apps->registerApp({"demo", "Widget demo", true, new DemoApp(bus)});
|
||||
@@ -382,9 +385,21 @@ static void ipTrialStep() {
|
||||
}
|
||||
#endif
|
||||
|
||||
// `tasks`: the first sample, and when to take the second and print.
|
||||
static std::vector<TaskSample> tasksBefore;
|
||||
static uint32_t tasksTotal = 0, tasksDueMs = 0;
|
||||
static bool tasksPending = false;
|
||||
|
||||
static void tasksStep() {
|
||||
if (!tasksPending || static_cast<int32_t>(millis() - tasksDueMs) < 0) return;
|
||||
tasksPending = false;
|
||||
system_info::printTasks(console, tasksBefore, tasksTotal);
|
||||
std::vector<TaskSample>().swap(tasksBefore);
|
||||
}
|
||||
|
||||
static const char* const kHelp =
|
||||
"info firmware, uptime, memory, Wi-Fi, app slots\n"
|
||||
"tasks FreeRTOS tasks: state, priority, free stack, CPU\n" "net bytes each network service has read and written since boot\n"
|
||||
"tasks FreeRTOS tasks over the next second: state, priority, free stack, CPU share\n" "net bytes each network service has read and written since boot\n"
|
||||
"reboot restart\n"
|
||||
"boot other restart into the other app slot (manual Rollback)\n"
|
||||
"log level <0-5> ESP-IDF log level (0 none ... 5 verbose)\n"
|
||||
@@ -433,7 +448,11 @@ static void runCommand(String line) {
|
||||
console.printf("update: %s\n", update->onProbation() ? "on probation" : "confirmed");
|
||||
system_info::printSlots(console, nvs);
|
||||
}
|
||||
if (line == "tasks") system_info::printTasks(console);
|
||||
if (line == "tasks") { // sampled now, printed a second later by tasksStep(): the loop must run in between
|
||||
tasksTotal = system_info::sampleTasks(tasksBefore);
|
||||
tasksDueMs = millis() + 1000;
|
||||
tasksPending = true;
|
||||
}
|
||||
if (line == "net") { // bytes each service has read and written since boot (S1, Q121)
|
||||
for (int i = 0; i < static_cast<int>(net::User::Count); i++) {
|
||||
net::Traffic t = net::traffic(static_cast<net::User>(i));
|
||||
@@ -739,6 +758,7 @@ static void loopSafeMode() {
|
||||
uint32_t now = millis();
|
||||
serialCommands();
|
||||
remoteCommands();
|
||||
tasksStep();
|
||||
services.tick(now);
|
||||
bus.dispatch();
|
||||
noteStableOnce(now);
|
||||
@@ -770,6 +790,7 @@ void loop() {
|
||||
|
||||
serialCommands();
|
||||
remoteCommands();
|
||||
tasksStep();
|
||||
#ifdef RORO_DEBUG
|
||||
ipTrialStep();
|
||||
#endif
|
||||
|
||||
@@ -7,6 +7,8 @@
|
||||
#include <freertos/FreeRTOS.h>
|
||||
#include <freertos/task.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
@@ -89,20 +91,40 @@ void printSlots(Print& out, KeyValueStore& store) {
|
||||
}
|
||||
}
|
||||
|
||||
void printTasks(Print& out) {
|
||||
uint32_t sampleTasks(std::vector<TaskSample>& out) {
|
||||
UBaseType_t n = uxTaskGetNumberOfTasks();
|
||||
std::vector<TaskStatus_t> tasks(n + 4);
|
||||
uint32_t total = 0;
|
||||
n = uxTaskGetSystemState(tasks.data(), tasks.size(), &total);
|
||||
out.printf("%-16s %-4s %3s %6s %5s %s\n", "task", "st", "pri", "stack", "cpu%", "core");
|
||||
static const char kStates[] = "RrBSD"; // running, ready, blocked, suspended, deleted
|
||||
out.clear();
|
||||
out.reserve(n);
|
||||
for (UBaseType_t i = 0; i < n; i++) {
|
||||
const TaskStatus_t& t = tasks[i];
|
||||
unsigned cpu = total ? (unsigned)((uint64_t)t.ulRunTimeCounter * 100 / total) : 0;
|
||||
int core = t.xCoreID == tskNO_AFFINITY ? -1 : (int)t.xCoreID;
|
||||
out.printf("%-16s %-4c %3u %6u %5u %d\n", t.pcTaskName, t.eCurrentState < 5 ? kStates[t.eCurrentState] : '?',
|
||||
(unsigned)t.uxCurrentPriority, (unsigned)t.usStackHighWaterMark, cpu, core);
|
||||
TaskSample s;
|
||||
s.id = t.xTaskNumber;
|
||||
std::snprintf(s.name, sizeof s.name, "%s", t.pcTaskName);
|
||||
s.runtime = t.ulRunTimeCounter;
|
||||
s.stackFree = static_cast<uint16_t>(std::min<uint32_t>(t.usStackHighWaterMark, 0xFFFF));
|
||||
s.core = t.xCoreID == tskNO_AFFINITY ? -1 : static_cast<int8_t>(t.xCoreID);
|
||||
s.state = static_cast<uint8_t>(t.eCurrentState);
|
||||
s.priority = static_cast<uint8_t>(t.uxCurrentPriority);
|
||||
out.push_back(s);
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
// Shares over the interval since `before`, not since boot: the counters wrap every 71 minutes.
|
||||
void printTasks(Print& out, const std::vector<TaskSample>& before, uint32_t beforeTotal) {
|
||||
std::vector<TaskSample> now;
|
||||
uint32_t t1 = sampleTasks(now);
|
||||
std::vector<TaskRow> rows = taskRows(before, beforeTotal, now, t1);
|
||||
sortTasks(rows, TaskSort::Share);
|
||||
out.printf("%-16s %-4s %3s %6s %6s %s\n", "task", "st", "pri", "stack", "cpu%", "core");
|
||||
static const char kStates[] = "RrBSD"; // running, ready, blocked, suspended, deleted
|
||||
for (const TaskRow& r : rows)
|
||||
out.printf("%-16s %-4c %3u %6u %4u.%u %d%s\n", r.name.c_str(), r.state < 5 ? kStates[r.state] : '?', r.priority,
|
||||
r.stackFree, r.permille / 10, r.permille % 10, r.core, r.lowStack ? " low stack" : "");
|
||||
out.printf("load: core 0 %d %%, core 1 %d %%\n", coreLoad(rows, 0), coreLoad(rows, 1));
|
||||
}
|
||||
|
||||
const char* bootOtherSlot() {
|
||||
|
||||
@@ -3,7 +3,10 @@
|
||||
#include <Print.h>
|
||||
#include <esp_partition.h>
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "key_value_store.h"
|
||||
#include "task_stats.h"
|
||||
|
||||
namespace roro::system_info {
|
||||
|
||||
@@ -20,7 +23,12 @@ void printSlots(Print& out, KeyValueStore& store);
|
||||
// Remembers which version the running slot holds (call at boot), or the slot an update just wrote.
|
||||
void recordSlotVersion(KeyValueStore& store, const esp_partition_t* slot, const char* version);
|
||||
// FreeRTOS tasks: state, priority, lowest free stack, CPU share since boot.
|
||||
void printTasks(Print& out);
|
||||
// The tasks' shares since `before` was sampled (with its run-time clock). The caller lets the main
|
||||
// loop run in between: sampling twice inside one command would show the loop asleep.
|
||||
void printTasks(Print& out, const std::vector<TaskSample>& before, uint32_t beforeTotal);
|
||||
// Every task as FreeRTOS reports it now; returns the run-time clock (microseconds, 32 bits), to
|
||||
// pair with the samples. Two of these make the shares the System App and `tasks` show.
|
||||
uint32_t sampleTasks(std::vector<TaskSample>& out);
|
||||
|
||||
// Boots the firmware in the other app slot if it holds a valid image (a manual Rollback).
|
||||
// Returns an error message; on success it restarts and doesn't return.
|
||||
|
||||
Reference in New Issue
Block a user