Node-RED Diagramm-Verlauf: MQTT-Chartdaten über Neustarts hinweg behalten

Der Node-RED Diagramm-Verlauf verschwindet bei jedem Neustart von Node-RED, weil Dashboard-Diagramme ihre Punkte im Arbeitsspeicher halten. Dieses Tutorial zeigt zwei praktische Wege, diesen Verlauf für MQTT-Daten zu behalten: einen dateibasierten Context-Speicher für kleine Datenmengen und eine SQLite-Tabelle, wenn Sie Abfragen und eine längere Aufbewahrung wünschen. In beiden Fällen spielen Sie die gespeicherten Daten beim Start in ein Dashboard-2.0-Diagramm zurück, sodass das Bedienpersonal die letzten 24 Stunden sieht statt eines leeren Rasters.

Warum Node-RED-Diagramme ihren Verlauf verlieren

Ein ui-chart-Node in Dashboard 2.0 speichert die empfangenen Punkte in einem serverseitigen Datenspeicher, weshalb ein neuer Browser-Tab die bestehende Linie trotzdem anzeigt. Dieser Speicher liegt im Arbeitsspeicher des Node-RED-Prozesses. Starten Sie Node-RED neu, booten Sie den Raspberry Pi, auf dem es läuft, oder aktualisieren Sie ein Paket und starten neu, dann beginnt das Diagramm wieder bei null.

MQTT schließt diese Lücke nicht von selbst. Eine retained message behält nur den letzten Wert pro Topic, ein sich neu verbindender Abonnent erhält also einen Punkt, keinen Trend. Ein Broker ist ein Nachrichten-Router, keine Datenbank. Wo genau diese Grenze verläuft, erfahren Sie unter Was ein MQTT-Broker macht. Der Verlauf muss an einem Ort gespeichert werden, den Sie kontrollieren, und Node-RED ist dafür ein bequemer Ort.

Die passende Speichermethode für den Node-RED Diagramm-Verlauf wählen

Der Rest dieses Artikels setzt die ersten beiden um. Für die dritte Variante folgen Sie dem Node-RED-InfluxDB-Tutorial, das denselben MQTT-Eingang und eine für diese Aufgabe gebaute Datenbank verwendet.

Testdaten von einem kostenlosen Broker

Sie brauchen einen Strom von Messwerten. Publizieren Sie alle paar Sekunden eine Temperatur an broker.connectmq.com, den Öffentlichen MQTT-Broker, mit einem eindeutigen Topic-Präfix. Ersetzen Sie a7f3k2 durch eine eigene Zufallszeichenfolge; alles auf dem öffentlichen MQTT-Broker ist für jeden lesbar, nutzen Sie ihn also nur für Tests.

# Publiziert alle 5 Sekunden eine zufällige Temperatur (Strg+C zum Beenden)
while true; do
  T=$(awk -v r=$RANDOM 'BEGIN { printf "%.2f", 20 + (r % 800) / 100 }')
  mosquitto_pub -h broker.connectmq.com -p 1883 -i pub-hist-a7f3k2 \
    -t connectmq/demo/a7f3k2/room1/telemetry -m "{\"temperature\": $T}"
  sleep 5
done

Fügen Sie in Node-RED einen mqtt in-Node auf connectmq/demo/a7f3k2/room1/telemetry hinzu, Ausgabe "a parsed JSON object", mit einem Broker-Config-Node, der eine eindeutige Client-ID verwendet.

Methode 1: Dateibasierter Context-Speicher

Einen persistenten Context-Speicher aktivieren

Standardmäßig liegt der Node-RED-Context im Arbeitsspeicher. Bearbeiten Sie settings.js in Ihrem Node-RED-Benutzerverzeichnis (meist ~/.node-red/settings.js) und definieren Sie einen zweiten Speicher, der auf die Festplatte schreibt:

// ~/.node-red/settings.js (innerhalb von module.exports = { ... })
contextStorage: {
    default: { module: "memory" },
    file: {
        module: "localfilesystem",
        config: { flushInterval: 30 }   // Sekunden zwischen Schreibvorgängen auf die Festplatte
    }
},

Starten Sie Node-RED neu. Bleibt der Arbeitsspeicher der Standard und wird der Dateispeicher explizit benannt, landen nur die Daten auf der Festplatte, die Sie auswählen, was bei SD-Karten wichtig ist. Die Werte werden alle 30 Sekunden geschrieben, ein harter Stromausfall kann also bis zu diesem Zeitfenster verlieren; ein sauberes Herunterfahren schreibt alles. Der Leitfaden zum Node-RED-Context erklärt Gültigkeitsbereiche und Speicher ausführlicher.

Einen Punkt pro Minute aufzeichnen

Jeden Rohwert zu speichern erzeugt schnell ein großes Array, das bei jedem Flush neu geschrieben wird. Mitteln Sie die Werte stattdessen pro Minute. Verbinden Sie den mqtt in-Node mit diesem Function-Node und dessen Ausgang mit dem Diagramm:

// Function-Node "record history" - 1 Ausgang
const RETENTION_MS = 24 * 60 * 60 * 1000;   // 24 Stunden aufbewahren
const value = Number(msg.payload.temperature);
if (Number.isNaN(value)) {
    return null;
}

const now = Date.now();
const minute = Math.floor(now / 60000);
let acc = context.get("acc") || { minute: minute, sum: 0, n: 0 };

if (acc.minute !== minute) {
    if (acc.n > 0) {
        let history = flow.get("tempHistory", "file") || [];
        history.push({
            x: acc.minute * 60000,
            y: Math.round((acc.sum / acc.n) * 100) / 100
        });
        const cutoff = now - RETENTION_MS;
        history = history.filter(p => p.x >= cutoff);
        flow.set("tempHistory", history, "file");
    }
    acc = { minute: minute, sum: 0, n: 0 };
}

acc.sum += value;
acc.n += 1;
context.set("acc", acc);

// Live-Punkt für das Diagramm
return { topic: "Temperature", payload: { x: now, y: value } };

Bei einem Punkt pro Minute umfasst ein Tag Verlauf 1.440 kleine Objekte pro Datenreihe, was eine Context-Datei problemlos bewältigt.

Das Diagramm konfigurieren

Wählen Sie im ui-chart-Node ein Liniendiagramm, belassen Sie Series auf msg.topic, setzen Sie X auf den Schlüssel x und Y auf den Schlüssel y und begrenzen Sie das Diagramm auf 24 Stunden an Punkten, damit es zu Ihrer Aufbewahrungsdauer passt.

Den Verlauf beim Start zurückspielen

Fügen Sie einen Inject-Node mit Inject once after 1 second ohne Wiederholung hinzu und verbinden Sie ihn mit diesem Function-Node und dann mit demselben Diagramm:

// Function-Node "replay history" - 1 Ausgang
const history = flow.get("tempHistory", "file") || [];
node.status({ fill: "green", shape: "dot", text: history.length + " points" });

return [[
    { topic: "Temperature", payload: [] },        // zuerst das Diagramm leeren
    { topic: "Temperature", payload: history }    // dann das gespeicherte Array senden
]];

Ein leeres Array leert das Diagramm und verhindert doppelte Linien nach einem erneuten Deploy. Ein Array aus {x, y}-Objekten fügt alle Punkte auf einmal hinzu. Starten Sie Node-RED neu, und das Diagramm erscheint wieder mit den Mittelwerten des letzten Tages und setzt dann mit Live-Punkten fort.

Methode 2: SQLite für längere Aufbewahrung

Wenn Sie mehrere Datenreihen haben, eine Woche oder mehr speichern oder nach Zeit filtern möchten, ist eine Datenbank sauberer. Installieren Sie node-red-node-sqlite über den Palette-Manager. Auf manchen Plattformen wird dabei ein natives Modul kompiliert, geben Sie ihm also eine Minute.

Die Tabelle anlegen

Fügen Sie einen Inject-Node (einmal beim Start) hinzu, dessen msg.topic die folgende Anweisung enthält, und verbinden Sie ihn mit einem sqlite-Node mit der Datenbankdatei /home/pi/.node-red/history.db (Pfad anpassen) und dem SQL-Abfragemodus Via msg.topic.

CREATE TABLE IF NOT EXISTS readings (
  ts     INTEGER NOT NULL,
  series TEXT    NOT NULL,
  value  REAL    NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_readings ON readings (series, ts);

Führt Ihre Node-Version nur eine Anweisung pro Nachricht aus, senden Sie die beiden Anweisungen über zwei separate Injects.

Jeden Messwert einfügen

Verwenden Sie einen zweiten sqlite-Node im Modus Prepared Statement mit diesem SQL:

INSERT INTO readings (ts, series, value) VALUES ($ts, $series, $value)

Speisen Sie ihn aus einem Function-Node, der die Parameter aufbaut:

// Function-Node "to sqlite params"
const value = Number(msg.payload.temperature);
if (Number.isNaN(value)) return null;
msg.params = { $ts: Date.now(), $series: "Temperature", $value: value };
return msg;

Beim Start abfragen und täglich aufräumen

Fragen Sie beim Start die letzten 24 Stunden ab und senden Sie die Zeilen an das Diagramm. Ein sqlite-Node im Modus Via msg.topic liefert die Zeilen als Array in msg.payload:

// Function-Node "history query" - ausgelöst durch einen Inject einmal beim Start
msg.topic = "SELECT ts AS x, value AS y FROM readings " +
            "WHERE series = 'Temperature' AND ts > " + (Date.now() - 86400000) +
            " ORDER BY ts";
return msg;

Leiten Sie das Ergebnis durch einen Change-Node, der msg.topic auf Temperature setzt, und dann in das Diagramm. Ergänzen Sie einen täglichen Inject, der DELETE FROM readings WHERE ts < <cutoff> mit einem auf dieselbe Weise berechneten Grenzwert ausführt, damit die Datei nicht endlos wächst.

Checkliste, bevor Sie sich darauf verlassen

1. Legen Sie eine Aufbewahrungsdauer fest und setzen Sie sie in Code oder SQL durch, nicht durch Hoffnung.
2. Reduzieren Sie die Daten vor dem Speichern, wenn Sie ohnehin nur Mittelwerte anzeigen.
3. Stellen Sie sicher, dass das Punktlimit des Diagramms zur Aufbewahrungsdauer passt, sonst verschwinden alte Punkte zu früh.
4. Leeren Sie das Diagramm vor dem Zurückspielen, um doppelte Linien nach Deploys zu vermeiden.
5. Sichern Sie das Context-Verzeichnis oder die Datenbankdatei zusammen mit dem Rest Ihres Node-RED-Projekts.
6. Behalten Sie die Speicherbelegung auf SD-Karten im Blick; bevorzugen Sie für hochfrequente Daten SQLite oder eine externe Datenbank.

Woher die Daten in Produktion kommen sollten

Der Verlauf ist nur so gut wie der Datenstrom, der ihn speist. Fällt der Broker aus, entstehen Lücken im Diagramm, und auf einem geteilten öffentlichen MQTT-Broker kann jeder Ihre Demo-Topics lesen oder darauf publizieren. Für echte Installationen richten Sie den mqtt in-Node auf einen privaten Broker mit Zugangsdaten und TLS aus. Bei ConnectMQ stellt das Portal für jeden Broker einen Benutzernamen, ein Passwort und eine Client-ID aus, und die Änderung im Flow beschränkt sich auf den Config-Node: Server, Port 8883, TLS an und die Zugangsdaten.

Ein verwalteter MQTT-Broker sorgt außerdem dafür, dass Geräte weiter publizieren, während Sie Node-RED neu starten oder aktualisieren. Kombiniert mit einer persistenten MQTT-Session und QoS 1 auf dem Abonnement kann der Broker kurze Node-RED-Neustarts überbrücken, indem er Nachrichten für die Session puffert, abhängig von der Session-Ablaufzeit Ihres Plans. Für die Dashboards selbst behandelt das Dashboard-2.0-Tutorial Anzeigen, Bedienelemente und Layout, und das Node-RED-MQTT-Tutorial die Broker-Grundlagen.

Halten Sie Ihre Node-RED-Daten mit ConnectMQ im Fluss

Registrieren Sie sich unter app.connectmq.com und starten Sie mit dem kostenlosen Serverless-Plan, ohne Kreditkarte. Erstellen Sie einen Broker, fügen Sie die Zugangsdaten in Ihren Node-RED-Config-Node ein, und Ihre Diagramme werden von einem privaten, TLS-verschlüsselten Datenstrom gespeist. Der Live-Topic-Explorer von ConnectMQ hilft Ihnen zu bestätigen, dass Messwerte ankommen, bevor Sie mit der Fehlersuche im Speicher beginnen.

Häufig gestellte Fragen

Speichert Node-RED Dashboard 2.0 Diagrammdaten automatisch?

Es hält Diagrammdaten im Arbeitsspeicher, damit neue Browser-Tabs bestehende Punkte sehen, schreibt aber nichts auf die Festplatte. Nach einem Neustart von Node-RED ist das Diagramm leer, sofern Sie keine gespeicherten Daten zurückspielen.

Können retained MQTT-Nachrichten einen Diagramm-Verlauf speichern?

Nein. Eine retained message enthält nur den neuesten Wert eines Topics. Sie ist nützlich, um den aktuellen Zustand sofort anzuzeigen, doch für einen Trend brauchen Sie Context-Speicher oder eine Datenbank.

Wie viel Verlauf kann ich im Node-RED-Context behalten?

Dateibasierter Context funktioniert gut für wenige Datenreihen, die auf einen Punkt pro Minute reduziert sind, über einen oder wenige Tage. Für größere Mengen verwenden Sie SQLite oder eine Zeitreihendatenbank wie InfluxDB.

Wie verhindere ich doppelte Linien nach einem Deploy?

Senden Sie ein leeres Array an das Diagramm, bevor Sie die gespeicherten Punkte zurückspielen. Das leert das Diagramm, sodass der Verlauf nur einmal gezeichnet wird.