Skip to Content
Low-CodeThird Party NodesBeispiele für Third-Party Nodes

Beispiele für Third-Party Nodes

Diese Seite zeigt praktische Anwendungsbeispiele für häufig verwendete Third-Party Nodes in LowCode. Jedes Beispiel enthält eine Flow-Beschreibung und die wichtigsten Konfigurationsschritte.

PostgreSQL — CRUD-Operationen

Der Node node-red-contrib-postgresql ermöglicht den direkten Zugriff auf PostgreSQL-Datenbanken.

Verbindung konfigurieren

Erstellen Sie zunächst einen PostgreSQL-Config-Node:

EigenschaftWert
Hostlocalhost oder Docker-Service-Name
Port5432
Databasemydb
Userpostgres
PasswordAus Umgebungsvariable

Datensätze lesen (SELECT)

Verbinden Sie einen Inject-Node mit einem PostgreSQL-Node:

SELECT id, name, status, created_at
FROM orders
WHERE status = $1
ORDER BY created_at DESC
LIMIT 50;

Die Parameter werden über msg.params übergeben:

// Im Function-Node vor dem PostgreSQL-Node
msg.params = ["active"];
return msg;

Datensätze erstellen (INSERT)

// Function-Node: Daten vorbereiten
msg.query = `
  INSERT INTO orders (name, status, amount)
  VALUES ($1, $2, $3)
  RETURNING id;
`;
msg.params = [
  msg.payload.name,
  "new",
  msg.payload.amount
];
return msg;

Datensätze aktualisieren (UPDATE)

// Function-Node: Update-Query
msg.query = `
  UPDATE orders
  SET status = $1, updated_at = NOW()
  WHERE id = $2;
`;
msg.params = [msg.payload.status, msg.payload.id];
return msg;

Datensätze löschen (DELETE)

// Function-Node: Lösch-Query
msg.query = `DELETE FROM orders WHERE id = $1;`;
msg.params = [msg.payload.id];
return msg;

Flow-Aufbau

[HTTP In: GET /api/orders] → [Function: Query vorbereiten] → [PostgreSQL] → [HTTP Response]
[HTTP In: POST /api/orders] → [Function: Insert vorbereiten] → [PostgreSQL] → [HTTP Response]
[HTTP In: PUT /api/orders/:id] → [Function: Update vorbereiten] → [PostgreSQL] → [HTTP Response]
[HTTP In: DELETE /api/orders/:id] → [Function: Delete vorbereiten] → [PostgreSQL] → [HTTP Response]

Modbus — Industrielle Geräteanbindung

Der Node node-red-contrib-modbus ermöglicht die Kommunikation mit Industriesteuerungen über das Modbus-Protokoll.

Modbus TCP-Verbindung

Erstellen Sie einen Modbus-Server-Config-Node:

EigenschaftWert
TypTCP
Host192.168.1.100 (IP der SPS)
Port502
Unit-Id1

Register auslesen (Holding Registers)

Verwenden Sie den Modbus-Read-Node, um Holding-Register einer SPS auszulesen:

EigenschaftWertBeschreibung
FCRead Holding Registers (FC3)Funktion zum Lesen
Address0Startadresse
Quantity10Anzahl Register
Poll Rate1 SekundeAbfrageintervall

Daten aufbereiten

Die gelesenen Register werden als Array in msg.payload übergeben. Ein Function-Node kann diese in lesbare Werte umwandeln:

// Function-Node: Modbus-Daten aufbereiten
const registers = msg.payload;
 
msg.payload = {
  temperature: registers[0] / 10,    // Register 0: Temperatur (0.1 °C Auflösung)
  pressure: registers[1] / 100,      // Register 1: Druck (0.01 bar Auflösung)
  speed: registers[2],               // Register 2: Drehzahl (RPM)
  status: registers[3],              // Register 3: Statuswort
  errorCode: registers[4],           // Register 4: Fehlercode
  operatingHours: (registers[5] << 16) | registers[6]  // Register 5+6: Betriebsstunden (32-bit)
};
 
return msg;

Register schreiben

Verwenden Sie den Modbus-Write-Node, um Steuerbefehle an die SPS zu senden:

// Function-Node: Sollwert an SPS senden
msg.payload = {
  value: Math.round(msg.payload.targetTemperature * 10),  // Temperatur-Sollwert
  fc: 6,              // FC6: Write Single Register
  unitid: 1,
  address: 100,       // Zieladresse auf der SPS
  quantity: 1
};
return msg;

Flow-Aufbau: Maschinenüberwachung

[Modbus Read: FC3, Addr 0, Qty 10, Poll 1s]
  → [Function: Daten aufbereiten]
  → [Switch: Status prüfen]
    → [Ausgang 1: Normal] → [Dashboard: Anzeige]
    → [Ausgang 2: Warnung] → [Dashboard: Warnung] → [E-Mail: Benachrichtigung]
    → [Ausgang 3: Fehler] → [Dashboard: Alarm] → [Engine: Störungsprozess starten]

MongoDB — Dokumentenspeicher

Der Node node-red-node-mongodb bietet eine einfache Integration mit MongoDB-Datenbanken.

Verbindung konfigurieren

Erstellen Sie einen MongoDB-Config-Node:

EigenschaftWert
Hostmongodb://localhost:27017
Databaseprocesscube
CollectionWird pro Node festgelegt

Dokumente speichern

Verwenden Sie den MongoDB-Out-Node mit der Operation insert:

// Function-Node: Dokument vorbereiten
msg.collection = "logs";
msg.payload = {
  timestamp: new Date(),
  processId: msg.payload.processId,
  action: msg.payload.action,
  user: msg.payload.user,
  data: msg.payload.data,
  metadata: {
    source: "lowcode",
    version: "1.0"
  }
};
return msg;

Dokumente abfragen

Verwenden Sie den MongoDB-In-Node mit der Operation find:

// Function-Node: Abfrage definieren
msg.collection = "logs";
msg.payload = {
  processId: msg.payload.processId,
  timestamp: {
    $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) // Letzte 24 Stunden
  }
};
 
// Optionale Sortierung und Limit
msg.sort = { timestamp: -1 };
msg.limit = 100;
 
return msg;

Dokumente aktualisieren

Verwenden Sie den MongoDB-Out-Node mit der Operation update:

// Function-Node: Update-Operation
msg.collection = "logs";
msg.operation = "update";
msg.payload = [
  { _id: msg.payload.id },                          // Filter
  { $set: { status: "processed", updatedAt: new Date() } }  // Update
];
return msg;

Aggregation-Pipeline

Für komplexere Auswertungen nutzen Sie die Aggregation-Pipeline:

// Function-Node: Aggregation
msg.collection = "logs";
msg.operation = "aggregate";
msg.payload = [
  { $match: { timestamp: { $gte: new Date("2025-01-01") } } },
  { $group: {
    _id: "$action",
    count: { $sum: 1 },
    lastOccurrence: { $max: "$timestamp" }
  }},
  { $sort: { count: -1 } }
];
return msg;

Flow-Aufbau: Audit-Log

[Engine Event: Prozess gestartet]
  → [Function: Log-Eintrag erstellen]
  → [MongoDB Out: Insert in "audit_logs"]

[HTTP In: GET /api/audit]
  → [Function: Query aufbauen]
  → [MongoDB In: Find in "audit_logs"]
  → [HTTP Response: JSON]

Tipps für die Praxis

  • Fehlerbehandlung: Verbinden Sie immer einen Catch-Node mit Ihren Datenbank-Nodes, um Verbindungsfehler abzufangen
  • Connection Pooling: Verwenden Sie einen einzelnen Config-Node pro Datenbankverbindung, um Connection Pooling zu nutzen
  • Umgebungsvariablen: Speichern Sie Zugangsdaten niemals direkt im Flow, sondern nutzen Sie Umgebungsvariablen oder das Node-RED Credential System
  • Timeouts: Konfigurieren Sie angemessene Timeouts für Datenbankabfragen, besonders bei Modbus-Verbindungen

Nächste Schritte

Third-Party NodesInstallation von Third-Party Nodes