tassello 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -5,6 +5,30 @@ change the plugin API (`tassello/sdk`, `tassello/server`, `tassello/vite`), as n
 
 ## Unreleased
 
+- Plot widget: numbers of any topic over time, as rqt_plot and PlotJuggler plot them
+  (`/odom.twist.twist.linear.x`, a battery's voltage, joints' efforts), up to 8 series on a
+  chart, from every message. Live over the latest *time shown*; paused, zoomed (drag across it,
+  the wheel, a pinch) and scrolled through time (Shift+wheel, a swipe, the arrow keys); the value
+  axis fitted to what is shown or fixed; the values at the pointer; series hidden from the
+  legend. What is shown exported as CSV, a row a message. The series are picked in the widget,
+  from the topics of the graph and the numeric fields of their latest message (a `JointState`'s
+  named by joint), and saved with the panel, or listed in its properties.
+- The topic monitor (`topic.monitor`) samples: the numbers of every message at some fields, sent
+  ten times a second (`TopicSamples`). Plugins: `subscribeTopicMonitor`'s `samples`; its `stats`
+  and `echo` handlers are optional.
+- Plugins: widgets get `updateConfig`, which changes their properties and saves the panel, as the
+  side panel does.
+- System Monitor widget: the robot's computer, every second. The CPU's load, of each core (those
+  offline too), their frequencies and the load average; the memory, its cache and the swap; the
+  temperatures of the thermal zones and hwmon chips, by chip with their hottest, against their
+  own limits; the fans; a Raspberry Pi's throttling (under-voltage, frequency capped, throttled,
+  soft temperature limit, now and since boot); the GPUs: a Jetson's (devfreq), NVIDIA's
+  (`nvidia-smi`), AMD's (amdgpu); the power rails: a Jetson's INA3221 (L4T 32's too), hwmon's
+  power sensors, Intel's RAPL when readable; the disks' traffic and busy time, and the file
+  systems' space; the networks' traffic, of the device's own interfaces or those chosen. Charts
+  of the last 5 minutes, kept by the server, with the values at the pointer (or the arrow keys).
+  The board, its OS, uptime, and a Jetson's L4T release and power mode.
+- Plugins: `connection.subscribeSystem`, and the types of `src/shared/system.ts`.
 - Rosbags widget: the robot's rosbags, as `ros2 bag` makes and reads them. A folder's bags, the
   newest first, with their time span, size, storage and compression, and each topic's type,
   count and rate, from their `metadata.yaml` (Humble's and Jazzy's), else from their files (a

package/README.md

@@ -12,9 +12,11 @@ and plugins add more.
 - **Built in**: teleop pads, a Nav2 map with goals, the robot's URDF in 3D, an arm jogger, cameras,
   images, command buttons, a systemd application manager, a behavior tree inspector and
   editor, the ROS log of every node, the robot's diagnostics, its topics, services and actions
-  as the `ros2` command line shows them, its nodes' parameters, its rosbags (recorded, listed,
-  downloaded and played back), a file manager, a terminal, and its networks: Wi-Fi
-  joined, connections switched, the robot as an access point.
+  as the `ros2` command line shows them, plots of their numbers over time, its nodes'
+  parameters, its rosbags (recorded, listed,
+  downloaded and played back), a file manager, a terminal, its networks (Wi-Fi
+  joined, connections switched, the robot as an access point), and its computer: CPU, memory,
+  temperatures, a Raspberry Pi's throttling, a Jetson's GPU and power, disks and networks.
 - **Plugins**: widgets of your own, with server-side code if they need it, as npm or ROS packages.
 - **One process**: a ROS 2 node in Node.js. Nothing to install on the robot but Node.js.
 
@@ -132,10 +134,12 @@ after the others on the devices already arranged.
 | **Logs** | The ROS log (`/rosout`), as rqt_console and swri_console show it: every node's messages coloured by level, the nodes running and those that logged with their counts, filtered by node, by level and by text (terms or a regular expression, to show or to hide). Pause, follow the newest, clear, download, and a message's details: where it was logged |
 | **Diagnostics** | The robot's diagnostics (`/diagnostics`, or the aggregator's `/diagnostics_agg`), as rqt_robot_monitor shows them: each status's level, the groups with the worst under them, those with problems unfolded. As a tree, as a list (the worst first) or as the latest changes of level, filtered by level and by text; a widget can be for some statuses only. A status's details: its message, hardware ID, values and latest changes. Pause, download, and forget the statuses no longer published |
 | **ROS Monitor** | The ROS graph, as the `ros2` command line shows it, on three sheets: its topics, services and actions, filtered by name or type, the hidden ones on demand. A topic's messages, their rate, bandwidth and delay, its publishers and subscriptions with their QoS and those that cannot talk, a message to publish once or at a rate (`ros2 topic echo`, `hz`, `bw`, `delay`, `info -v`, `pub`); a service to call, once or at a rate (`ros2 service call`, `info`, `echo`); every goal of an action, whoever sent it, with its feedback, and a goal to send or cancel (`ros2 action send_goal`, `info`); their types' definitions (`ros2 interface show`) |
+| **Plot** | Numbers of any topic over time, as rqt_plot and PlotJuggler plot them: `/odom.twist.twist.linear.x`, a battery's voltage, joints' efforts (named by their joints), up to 8 series on a chart, from every message. Paused, zoomed and scrolled through time, each series shown or hidden; what is shown exported as CSV. Its series are picked in the widget, from the topics of the graph and the fields of their messages, or listed in its properties |
 | **Parameters** | Nodes' parameters, as rqt_reconfigure and `ros2 param` show them: the nodes of the graph, and the parameters of the one chosen grouped by their prefixes, each edited in place (a switch, a slider within its range, a field), live as they change wherever they are set. Their descriptions, ranges and constraints (`ros2 param describe`); new ones set and undeclared ones deleted (`set`, `delete`); all of them dumped as YAML, downloaded or saved on the robot (`dump`), and loaded from a YAML file of the robot or of the page's device (`load`) |
 | **Rosbags** | The robot's rosbags, as `ros2 bag` makes and reads them: those of a folder, the newest first, with when, how long and how big, their storage and compression, each topic's type, count and rate (`ros2 bag info`); downloaded, deleted, or played on the robot's topics (`ros2 bag play`: paused, sought, sped up, looped, some topics only). New ones recorded (`ros2 bag record`): topics chosen from the graph, all of them, or matching an expression, with rosbag2's options: the storage (MCAP, SQLite) and its preset, a new file by size or duration, compression of each file or message. Every page sees the recordings and the playback, the behavior tree inspectors' too |
 | **File Manager** | The robot's files: folders unfolded in place, places (home, the ROS workspaces, bookmarks) and the disks' free space, an entry's details and permissions, what takes a folder's space. Make, rename, cut, copy, paste, drag onto folders, delete, download (folders as `.tar.gz`) and upload (drop files and folders onto it). Text files edited in tabs as gedit does: highlighting, search and replace, undo; images and PGM maps shown |
 | **Terminal** | A shell on the robot, or a command (`htop`, `tmux attach`), in a full terminal: colours, full screen programs, the mouse. It outlives the page: reloaded, reconnected or shown again, it is as it was. On touch screens, the keys phones lack, as Termux has them: Esc, Tab, Ctrl, Alt, Home, End, the arrows, Page Up and Down, and while typing the terminal fills the screen above the on-screen keyboard |
+| **System Monitor** | The robot's computer, as top, sensors and a Jetson's jtop show it: the CPU's load, of each core, and their frequencies; the memory and swap; the temperatures by chip, and the fans; a Raspberry Pi's throttling (under-voltage, capped frequency, now and since boot); the GPUs (a Jetson's, NVIDIA's, AMD's) and the power rails (a Jetson's); the disks' traffic and space; the networks' traffic. With charts of the last 5 minutes |
 | **Networking** | The robot's networks, through NetworkManager, as a phone's settings show them: the Wi-Fi networks in range, joined with their password; the connections saved, switched between, edited (their addresses by DHCP or static), forgotten; the robot as an access point, its network shared by a QR code; the interfaces, their state and addresses. Asks before a change that would cut the page off from the robot |
 
 Their properties (topics, frames, speeds, colours, ...) are edited in the side panel of edit mode.
@@ -306,6 +310,26 @@ Notes on some of them:
 
   Messages, requests and goals are made from rclnodejs's code of their types, which Tassello
   makes when it starts for the workspaces sourced (see Install).
+- **Plot** draws up to 8 series on one value axis: a topic, a dot and its field
+  (`/odom.twist.twist.linear.x`, `/joint_states.effort[2]`, list items by their index), then a
+  label if any, one a line in its *series* property. *Series…* picks them in the widget, in view
+  mode, and saves them with the panel: a topic of the graph, then fields among those of its
+  latest message that are numbers, with their values (a `JointState`'s by joint name), or a field
+  typed. Numbers, booleans (0 or 1) and times (in seconds, a header's stamp) are plotted; NaN and
+  infinities break the line, as does a topic that stopped. The server reads every message of the
+  topics plotted, not 10 a second, and sends the numbers of the fields asked for ten times a
+  second; each sample is on the server's clock, when its message came. The page keeps the
+  latest 10 minutes of each series (200,000 samples at most, 200 s of a 1 kHz topic), from when
+  the widget opened.
+
+  Live, it shows the latest *time shown* (30 s), the value axis fitted to what is shown or
+  *fixed*. Drag across it to zoom in on that span, which pauses it; the wheel zooms around the
+  pointer (live, a shorter or longer span to now), Shift+wheel or a sideways swipe scrolls
+  through time, two fingers pinch; *Live* or a double click goes on. Space pauses, the arrow keys
+  scroll, `+` and `-` zoom, Escape goes back live. The pointer shows each series' value at its
+  time, the legend the values at the right edge; clicking a series in the legend hides it. The
+  download button exports what is shown as CSV: the time (s since the epoch), then a column a
+  series, a row a message (those of a topic's series on the same rows).
 - **Parameters** lists the nodes of the graph (but the hidden ones, as `ros2 node list` does), or
   shows one node only, its *node* (a panel to tune `/controller_server`). A node's parameters are
   read through its parameter services (`rcl_interfaces`), grouped by the prefixes of their names
@@ -466,6 +490,21 @@ Notes on some of them:
   Without it, the widget says the networks cannot be changed. *Share…* reads the passwords with
   `nmcli --show-secrets`, which needs the same right; those a desktop's keyring keeps cannot be
   read.
+- **System Monitor** reads `/proc` and `/sys` every second, for every page at once, while one
+  shows it, and keeps the last 5 minutes for the charts (a page opened later has them at once).
+  The temperatures are the kernel's thermal zones and its hwmon chips' sensors (the chips that
+  are a thermal zone again, once), grouped by chip with the hottest of each; a sensor is hot from
+  its own limits (else 80 °C), and critical at its own critical (else 95 °C). A **Raspberry Pi**'s
+  throttling is its firmware's (`get_throttled` in `/sys`, else `vcgencmd get_throttled`): under-
+  voltage, frequency capped, throttled, soft temperature limit, now and since boot. A **Jetson**'s
+  GPU is devfreq's (its load and clock), its power the INA3221's rails (`VDD_IN` the whole
+  board's), its L4T release and power mode (`nvpmodel -q`) are shown with the board. NVIDIA's
+  GPUs are read with `nvidia-smi` every 2 s, AMD's from amdgpu's files; an Intel CPU's package
+  power from RAPL, if its counters are readable (root's only, since Linux 5.10). Cores taken
+  offline (a Jetson's power modes) show as such. The disks are the whole ones (not partitions,
+  loop devices, device mapper or RAID), their space the File Manager's; the networks are the
+  device's own interfaces (not docker's bridges, VPN clients' tunnels: their traffic is the
+  devices' too), or those of its *interfaces* (`wlan0, tun*`). Each section can be hidden.
 
 ## Plugins
 
@@ -517,6 +556,7 @@ own pages only too: those whose origin is the host they reached (the `Host` head
                                                                         ├─ python3: the terminals' pseudo-terminals
                                                                         ├─ nmcli: the networks (NetworkManager)
                                                                         ├─ ros2 bag: rosbags recorded and played
+                                                                        ├─ /proc, /sys, nvidia-smi: the system monitor
                                                                         └─ the plugins' server sides
 ```
 
@@ -554,6 +594,13 @@ Safety and bandwidth are the server's concern:
   one recording per folder, for every page (the behavior tree inspectors' among them), one
   playback. A folder of bags is read once for every page showing it, every 2 s, a bag's metadata
   again only when its files change; the recordings' sizes every second.
+- A topic plotted is followed once for every page (the ROS Monitor's subscription, with its
+  publishers' QoS): its messages are deserialized only while a page plots it, and each page gets
+  the numbers of its own fields, ten batches a second: for a 200 Hz topic, about 3 KB a second
+  for when its messages came, and 4 KB for each field.
+- The system monitor's sensors are read once for every page, every second while one watches and
+  for 30 s after the last leaves; they are looked for again every 30 s (USB ones come and go).
+  Each page gets a sample a second, about 4 KB.
 - The File Manager's folders are read again every 3 s, and answered "unchanged" while they are;
   the largest are listed in part (5,000 entries), and only the rows in sight are drawn. Uploads
   and downloads are streamed, folders archived by `tar` as they are sent; saves replace files at

package/dist/server/message_format.d.ts

@@ -21,4 +21,5 @@ export interface RosTime {
 }
 export declare function toRosMessage(value: unknown, type: string, schemas: Record<string, MessageSchema>, now: () => RosTime, path?: string): Record<string, unknown>;
 export declare function fieldAt(message: unknown, path: string): unknown;
+export declare function sampleValue(value: unknown): number | null;
 export declare function echoJson(value: unknown, limit: number): unknown;

package/dist/server/message_format.js

@@ -307,6 +307,27 @@ export function fieldAt(message, path) {
     }
     return value;
 }
+// A field's value as a plot takes it: numbers, 64 bit integers, booleans (0
+// or 1), times and durations (in seconds); null for anything else, and for
+// NaN and infinities
+export function sampleValue(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === 'bigint') {
+        return Number(value);
+    }
+    if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+    }
+    if (value !== null && typeof value === 'object' && 'sec' in value && 'nanosec' in value) {
+        const { sec, nanosec } = value;
+        if (typeof sec === 'number' && typeof nanosec === 'number') {
+            return sec + nanosec / 1e9;
+        }
+    }
+    return null;
+}
 function number(value) {
     if (Number.isFinite(value)) {
         return value;

package/dist/server/server.js

@@ -33,6 +33,7 @@ import { Rosbags } from './rosbags.js';
 import { Rosout } from './rosout.js';
 import { Session } from './session.js';
 import { FrameStreams } from './streams.js';
+import { SystemMonitor } from './system.js';
 import { SystemdServices } from './systemd.js';
 import { Teleop } from './teleop.js';
 import { Terminals } from './terminals.js';
@@ -112,6 +113,7 @@ export async function startServer(options) {
     const diagnostics = new Diagnostics(node, logger);
     const terminals = new Terminals(logger);
     const networking = new Networking(logger);
+    const system = new SystemMonitor(logger);
     // Next to the panels
     const uploadsDir = path.join(path.dirname(panelsDir), 'images');
     const rosbags = new Rosbags(ros, logger);
@@ -171,6 +173,7 @@ export async function startServer(options) {
             actions,
             parameters,
             rosbags,
+            system,
             plugins: host,
             hostname: os.hostname(),
         }, ownPage(req.headers), req.socket.localAddress ?? null);
@@ -207,6 +210,7 @@ export async function startServer(options) {
         systemd.stopAll();
         terminals.stopAll();
         networking.stopAll();
+        system.stop();
         // Stops the robot if a page was driving it, while the node still runs
         for (const session of sessions) {
             session.close();

package/dist/server/session.d.ts

@@ -20,6 +20,7 @@ import type { Rosbags } from './rosbags.ts';
 import type { RosGraph } from './ros_graph.ts';
 import type { Rosout } from './rosout.ts';
 import type { FrameStreams } from './streams.ts';
+import type { SystemMonitor } from './system.ts';
 import type { SystemdServices } from './systemd.ts';
 import type { Teleop } from './teleop.ts';
 import type { Terminals } from './terminals.ts';
@@ -52,6 +53,7 @@ export interface SessionServices {
     actions: Actions;
     parameters: Parameters;
     rosbags: Rosbags;
+    system: SystemMonitor;
     plugins: PluginHost;
     hostname: string;
 }

package/dist/server/session.js

@@ -404,9 +404,11 @@ export class Session {
                     echo: echo && typeof echo === 'object'
                         ? { field: optionalString(echo.field), truncate: number(echo.truncate, 1, MAX_TRUNCATE, 128) }
                         : null,
+                    samples: message.samples === undefined ? null : strings(message.samples, 'samples'),
                     onStatus: (state, text) => this.sendStreamStatus(id, state, text),
                     onStats: (stats) => this.send({ type: 'topic.stats', id, stats }),
                     onEcho: (update) => this.send({ type: 'topic.echo', id, ...update }),
+                    onSamples: (samples) => this.send({ type: 'topic.samples', id, ...samples }),
                 }));
                 return;
             }
@@ -468,6 +470,12 @@ export class Session {
             case 'bags.action':
                 this.answer(message.id, Promise.resolve().then(() => services.rosbags.act(checkBagsRequest(message.request), this.ownPage)));
                 return;
+            case 'system.subscribe': {
+                const id = subscriptionId(message.id);
+                this.unsubscribe(id);
+                this.subscriptions.set(id, services.system.watch((update) => this.send({ type: 'system', id, ...update })));
+                return;
+            }
             case 'action.subscribe': {
                 const id = subscriptionId(message.id);
                 this.unsubscribe(id);

package/dist/server/system.d.ts

@@ -0,0 +1,40 @@
+import type { SystemUpdate } from '../shared/protocol.ts';
+import { type Logger } from './util.ts';
+export type SystemUpdateBody = Omit<SystemUpdate, 'type' | 'id'>;
+type Listener = (update: SystemUpdateBody) => void;
+export declare class SystemMonitor {
+    private readonly logger;
+    private readonly listeners;
+    private readonly history;
+    private info;
+    private infoJson;
+    private infoAt;
+    private space;
+    private spaceJson;
+    private spaceAt;
+    private sensors;
+    private sensorsAt;
+    private previous;
+    private latest;
+    private nvidia;
+    private vcgencmd;
+    private underVoltageSeen;
+    private timer;
+    private linger;
+    private running;
+    private ticking;
+    constructor(logger: Logger);
+    watch(listener: Listener): () => void;
+    stop(): void;
+    private send;
+    private tick;
+    private refresh;
+    private sample;
+    private temperatures;
+    private fans;
+    private frequencies;
+    private power;
+    private gpus;
+    private throttled;
+}
+export {};