From 0e76ad0ac73fe393e8f5049cdac5c6f9adf66dd9 Mon Sep 17 00:00:00 2001 From: sumitshinde-84 Date: Fri, 3 Jul 2026 19:51:33 +0530 Subject: [PATCH] Improve Certifed Nodes Docs --- src/node-red/flowfuse/edge/cip-suite.md | 420 ++++++++++++------------ src/node-red/flowfuse/edge/opcua.md | 23 +- src/node-red/flowfuse/edge/rtsp.md | 25 +- src/node-red/flowfuse/hub/redis.md | 12 + 4 files changed, 271 insertions(+), 209 deletions(-) diff --git a/src/node-red/flowfuse/edge/cip-suite.md b/src/node-red/flowfuse/edge/cip-suite.md index 7fa4cc7cb1..8638ceff20 100644 --- a/src/node-red/flowfuse/edge/cip-suite.md +++ b/src/node-red/flowfuse/edge/cip-suite.md @@ -1,69 +1,82 @@ --- eleventyNavigation: - key: CIP Suite — EtherNet/IP Node + key: CIP Suite — EtherNet/IP Nodes parent: Edge order: 2 meta: - title: CIP Suite — EtherNet/IP Node - description: A CIP Suite node for communicating with Rockwell Automation and Allen-Bradley PLCs using the EtherNet/IP (Ethernet Industrial Protocol) protocol. + title: CIP Suite — EtherNet/IP Nodes + description: A suite of nodes for reading, writing, and monitoring data on Rockwell Automation and Allen-Bradley PLCs, and other CIP-capable devices, using the EtherNet/IP protocol. --- # {{ meta.title }} -A CIP Suite node for communicating with Rockwell Automation and Allen-Bradley PLCs using the EtherNet/IP (Ethernet Industrial Protocol) protocol. +A suite of nodes for communicating with Rockwell Automation and Allen-Bradley PLCs, and other CIP-capable devices, using the EtherNet/IP (Ethernet Industrial Protocol) protocol. ## Overview -This node provides a robust interface for connecting FlowFuse flows to industrial control systems, specifically Rockwell Automation and Allen-Bradley programmable logic controllers (PLCs). It wraps the [st-ethernet-ip](https://www.npmjs.com/package/st-ethernet-ip) library to enable real-time tag monitoring and data collection from industrial automation equipment. +The CIP Suite connects FlowFuse flows to industrial control systems across the full spectrum of Rockwell Automation hardware, from modern ControlLogix and CompactLogix controllers to legacy SLC 500 and PLC-5 systems. It provides dedicated nodes for reading and writing tags, continuous tag monitoring, tag discovery, controller management, and advanced CIP objects covering motion, energy, time synchronization, security, and more. + +This is a **FlowFuse Certified Node**. Unlike community nodes, which vary in quality and can go unmaintained without warning, FlowFuse vets Certified Nodes for quality, security, and support, and maintains them on an ongoing basis. [Read more about Certified Nodes](/blog/2025/07/certified-nodes-v2/). It is built on the [st-ethernet-ip](https://www.npmjs.com/package/st-ethernet-ip) protocol driver. {% note %} -The CIP Suite EtherNet/IP node is not available by default. It is part of the FlowFuse Edge Certified Nodes catalogue, which is part of the **FlowFuse Edge** offering. Please contact our sales team at [Contact us](/contact-us/) to learn more or to request access. +The CIP Suite is not available by default. It is part of the FlowFuse Edge Certified Nodes catalogue, which is part of the **FlowFuse Edge** offering. Please contact our sales team at [Contact us](/contact-us/) to learn more or to request access. {% endnote %} ## What is EtherNet/IP? -EtherNet/IP (Ethernet Industrial Protocol) is an industrial network protocol that adapts the Common Industrial Protocol (CIP) to standard Ethernet. It's the primary communication protocol used by Rockwell Automation and Allen-Bradley industrial controllers, including: - -- **ControlLogix** PLCs -- **CompactLogix** PLCs -- **MicroLogix** PLCs -- **PowerFlex** Drives -- **PanelView** HMIs -- Other Rockwell Automation/Allen-Bradley devices - -## How It Works with Rockwell/Allen-Bradley Hardware - -This node establishes a client connection to Allen-Bradley PLCs over EtherNet/IP and provides the following capabilities: - -### 1. **Controller Discovery** -When connecting, the node automatically: -- Reads controller properties (model, serial number, firmware version) -- Discovers available tags in the controller -- Retrieves controller time and status - -### 2. **Tag Subscription** -The node subscribes to specific tags (variables) in the PLC and monitors them for changes: -- **BOOL** tags (Boolean/Digital I/O) -- **DINT** tags (Double Integer/32-bit integers) -- **REAL** tags (Floating-point values) -- **STRING** tags (Text data) -- **Custom data types** (UDTs) - -### 3. **Real-Time Monitoring** -- Polls the PLC at a configurable scan rate (50ms to 36000s) -- Emits messages only when tag values change -- Maintains a cache of current tag values -- Handles Allen-Bradley string encoding (82-character strings with 4-byte length prefix) - -### 4. **Connection Management** -- Automatic connection lifecycle management -- Proper cleanup on deployment or shutdown -- Error handling and status reporting -- Support for different slot configurations (backplane addressing) +EtherNet/IP (Ethernet Industrial Protocol) is an industrial network protocol that adapts the Common Industrial Protocol (CIP) to standard Ethernet. It's the primary communication protocol used by Rockwell Automation and Allen-Bradley industrial controllers and devices. + +## Supported Hardware + +| Platform | Protocol | Notes | +|----------|----------|-------| +| **ControlLogix** (L6x, L7x, L8x) | CIP Symbolic | Slot-based backplane routing | +| **CompactLogix** (L1x, L2x, L3x) | CIP Symbolic | Typically slot 0 | +| **Micro800** (Micro820/850/870) | CIP Symbolic | No backplane; enable Micro800 mode | +| **SLC 500** | PCCC over CIP | File-based addressing (N7:0, F8:0) | +| **MicroLogix** (1100/1400) | PCCC over CIP | File-based addressing | +| **PLC-5** | PCCC over CIP | File-based addressing | +| **Third-party CIP devices** | CIP Raw | Any EtherNet/IP device with CIP objects | + +## Use case + +Manufacturers running Allen-Bradley and Rockwell controllers typically have production data trapped on the plant floor. It's visible on an HMI, but invisible to anything above it. The CIP Suite closes that gap in both directions: it reads live tag data off the PLC into your flows, and lets flows write values and commands back when your use case requires it. + +### Example: tracking line performance in real time + +A CompactLogix controller on a packaging line exposes tags for `ProductionCount`, `ConveyorRunning`, and `RejectCount`. Without this suite, getting that data into a dashboard or historian usually means an OT engineer manually configuring a separate SCADA tag, or a nightly CSV export that's already stale by morning. + +With the CIP Suite, the flow looks like this: + +1. **Connect**: a `cip-endpoint` configuration node holds the shared connection to the PLC, with automatic reconnection. +2. **Subscribe**: a `cip-subscribe` node scans the tags cyclically and emits messages on change, with deadband filtering to suppress noise. +3. **Enrich**: a `function` node attaches a line ID, timestamp, or shift code, and converts raw units into something business-readable. +4. **Deliver**: the enriched payload is published to an MQTT broker or Unified Namespace, written to a historian, or dropped straight into [FlowFuse Tables](/node-red/flowfuse/flowfuse-tables/). + +The result: production counts, machine states, and reject rates are available to dashboards, analytics, and other systems within moments of changing on the floor. No polling scripts, no OPC server to license and maintain, no manual tag mapping in a separate SCADA package. + +### Where this shows up in practice + +- **OEE and downtime tracking**: feed `ConveyorRunning` and cycle-time tags into a calculation flow to surface availability and performance losses as they happen, instead of reconstructing them from end-of-shift reports. +- **Live operations dashboards**: wire tag changes straight into [FlowFuse Dashboard](https://dashboard.flowfuse.com/) widgets so operators and supervisors see machine state and counts update in real time. +- **Recipe and setpoint downloads**: use `cip-write` to push new setpoints, batch parameters, or recipe values to the PLC from an MES, a dashboard form, or a database lookup. +- **Threshold alerting**: route a `Temperature` or `Pressure` tag through a `switch` node and fire a Slack, Teams, or email notification the moment a value crosses a quality limit. +- **Unified Namespace / MQTT bridging**: treat the PLC as a data source feeding a plant-wide UNS, so IT and OT systems consume the same live tag data instead of duplicating integrations per PLC. +- **Legacy modernization**: connect SLC 500, MicroLogix, and PLC-5 systems through the PCCC nodes and bring decades-old equipment into the same data pipeline as modern controllers, without touching the ladder logic. + +### Why it scales beyond one PLC + +Only the source and sink nodes are protocol-specific. The transform stages of a flow, such as renaming tags, adding context, and routing data, don't care what protocol the data came from. The same flow pattern you build for one Allen-Bradley line can be reused for a Siemens PLC over [OPC UA](/node-red/flowfuse/edge/opcua/) or a Modbus device just by swapping the protocol nodes, which matters a lot on a mixed-vendor plant floor. + +## Requirements + +- Node.js >= 16.0.0 +- Node-RED >= 2.0.0 +- Access to the FlowFuse Edge Certified Nodes catalogue (part of the **FlowFuse Edge** offering) ## Installation -Because this node is part of the **FlowFuse Edge Certified Nodes** add-on, make sure your account has access before installing. Contact our [sales team](/contact-us/) if you don't. +Because this suite is part of the FlowFuse Edge Certified Nodes catalogue, which is part of the **FlowFuse Edge** offering, make sure your account has access before installing. Contact our [sales team](/contact-us/) if you don't. {% note %} Existing devices and hosted instances will not see newly added nodes until they are restarted. Restart any instance you plan to install nodes on so it picks up the updated catalogue. @@ -76,209 +89,204 @@ Existing devices and hosted instances will not see newly added nodes until they 3. Search for the **FlowFuse Edge Certified Nodes** collection. 4. Locate `@flowfuse-certified-nodes/cip-suite` and click **Install**. +After installation, all nodes appear under the **CIP Suite** category in the palette. + +## Nodes in the Suite + +### Core CIP Nodes (Logix controllers) + +| Node | Type | Description | +|------|------|-------------| +| **cip-endpoint** | Config | Shared TCP session to a Logix PLC. Auto-reconnect, Micro800 support, multi-hop routing. | +| **cip-read** | In/Out | Read tag values. Supports bit access (`Tag.5`), array elements (`Tag[3]`), array ranges (`Tag[0..9]`), UDT/structures, batch reads, and polling. | +| **cip-write** | In/Out | Write tag values. Supports atomic bit-level writes, arrays, UDT partial merge, and batch writes. | +| **cip-browse** | In/Out | Discover tags on the PLC. Glob/regex filtering, UDT detection, program-scoped tags. | +| **cip-subscribe** | Out | Continuous cyclic multi-tag scanning. Deadband filtering, report-by-exception, runtime reconfiguration. | +| **cip-controller** | In/Out | Read controller identity, mode, fault status, keyswitch, and tag count. Runtime commands: run/program/test/reset. | +| **cip-raw** | In/Out | Send raw CIP service requests to any CIP object, with full response parsing and human-readable status codes. | +| **cip-discover** | In/Out | UDP broadcast device discovery on the local network. Standalone; no endpoint required. | + +### Legacy PCCC Nodes (SLC 500 / MicroLogix / PLC-5) + +| Node | Type | Description | +|------|------|-------------| +| **cip-pccc-endpoint** | Config | Session to legacy controllers using EtherNet/IP with PCCC encapsulation. | +| **cip-pccc-read** | In/Out | Read data-file addresses: `N7:0`, `F8:0`, `B3:0/5`, `T4:0.ACC`, `S:1/5`. Multi-element reads and polling. | +| **cip-pccc-write** | In/Out | Write data-file addresses, including safe bit-level writes. | + +### Advanced CIP Object Nodes + +| Node | Description | +|------|-------------| +| **cip-io-scanner** | Implicit I/O with cyclic data exchange for remote I/O, drives, and servos. | +| **cip-security** | Read TLS/DTLS status and security profiles from the CIP Security Object. | +| **cip-sync** | IEEE 1588 PTP time synchronization: grandmaster discovery, offset monitoring, enable/disable. | +| **cip-motion** | Motion Axis Object: jog, absolute/relative moves, home, stop, enable/disable, axis status polling. | +| **cip-energy** | Energy monitoring: power, energy, and electrical measurements (V/A/Hz/PF/THD). | +| **cip-file** | File Object: firmware upload/download, file directory listing, metadata access. | +| **cip-param** | Parameter Object: device parameterization with discovery scan and scaled read/write. | + +## Tag Addressing + +### CIP Symbolic (Logix) + +| Format | Example | Description | +|--------|---------|-------------| +| Simple | `MyTag` | Read/write a tag | +| Bit access | `MyDint.5` | Read/write bit 5 of a DINT | +| Array element | `MyArray[3]` | Single array element | +| Array range | `MyArray[0..9]` | Read elements 0 to 9 | +| Program-scoped | `Program:MainProgram.MyTag` | Tag inside a program | +| Batch | `msg.tags = ["Tag1","Tag2"]` | Multi-tag read in one request | + +### PCCC (SLC 500 / MicroLogix / PLC-5) + +| Format | Example | Description | +|--------|---------|-------------| +| Integer | `N7:0` | Integer file 7, element 0 | +| Float | `F8:5` | Float file 8, element 5 | +| Bit | `B3:0/5` | Bit file 3, element 0, bit 5 | +| Timer | `T4:0` | Full timer (CTL/PRE/ACC) | +| Timer sub-element | `T4:0.ACC` | Timer accumulator only | +| Counter | `C5:0.ACC` | Counter accumulator | +| Output/Input | `O:0/3`, `I:1/0` | I/O with bit access | +| Status | `S:1/5` | Status file with bit | +| String | `ST9:0` | String file | +| Long | `L10:0` | Long integer file | + +## Configuration + +### cip-endpoint + +| Setting | Default | Description | +|---------|---------|-------------| +| IP Address | (required) | PLC IP address | +| Port | 44818 | EtherNet/IP port | +| Slot | 0 | Backplane slot (ControlLogix) | +| Timeout (ms) | 5000 | Connection timeout | +| Retry (ms) | 5000 | Reconnection interval | +| Micro800 | off | Enable for Micro800 controllers | +| Routing Path | (optional) | Multi-hop routing, e.g. `1/0/2/192.168.1.1` | + +### cip-pccc-endpoint + +| Setting | Default | Description | +|---------|---------|-------------| +| IP Address | (required) | PLC IP address | +| Port | 44818 | EtherNet/IP port | +| Timeout (ms) | 5000 | Connection/request timeout | +| Retry (ms) | 5000 | Reconnection interval | + ## Usage -### Input Message Format +### Reading tags -Send a message with the following payload structure to initiate a PLC connection: +Send a message to a `cip-read` node with the tag name configured on the node or in `msg.tagName`. The output: ```json { - "address": "192.168.1.100", - "slot": 0, - "scanRate": 500, - "tagConfig": [ - { - "scope": "", - "tags": [ - { - "tagName": "ProductionCount", - "tagType": "DINT" - }, - { - "tagName": "ConveyorRunning", - "tagType": "BOOL" - }, - { - "tagName": "Temperature", - "tagType": "REAL" - }, - { - "tagName": "PartNumber", - "tagType": "STRING" - } - ] - } - ] + "payload": 1250, + "tagName": "ProductionCount", + "dataType": "DINT", + "timestamp": 1710000000000 } ``` -#### Configuration Parameters - -- **address**: IP address of the PLC (required) -- **slot**: Backplane slot number where the processor is located (typically 0 for CompactLogix, varies for ControlLogix) -- **scanRate**: Polling interval in milliseconds (50-36000000ms) -- **tagConfig**: Array of tag scopes containing tags to monitor - - **scope**: Tag scope in the controller (empty string for controller-scoped tags) - - **tags**: Array of tag objects - - **tagName**: Name of the tag in the PLC program - - **tagType**: Data type (BOOL, DINT, REAL, STRING, etc.) - -### Outputs +### Writing tags -#### Output 1: PLC Data - -Emits updated tag values when changes are detected: +Send a message to a `cip-write` node with the value in `msg.payload`: ```json { - "payload": { - "ProductionCount": 1250, - "ConveyorRunning": true, - "Temperature": 72.5, - "PartNumber": "ABC-123-XYZ" - }, - "changedTagName": "ProductionCount", - "changedTagValue": 1250 + "payload": 42, + "tagName": "TargetSpeed" } ``` -#### Output 2: Debug/Metadata +Bit-level writes use the atomic CIP Read-Modify-Write service where the controller supports it, so individual bits change without race conditions. + +### Subscribing to tag changes -Provides diagnostic information and PLC metadata: +The `cip-subscribe` node scans a group of tags cyclically and emits when values change. Multi-tag output: ```json { - "payload": { - "category": "plcProps", - "value": { - "name": "CompactLogix Controller", - "serial": "12345678", - "slot": 0, - "version": "31.011" - } - } + "payload": { "Tag1": 42, "Tag2": 3.14 }, + "tags": [ + { "name": "Tag1", "value": 42, "type": "DINT", "changed": true }, + { "name": "Tag2", "value": 3.14, "type": "REAL", "changed": false } + ], + "scanRate": 1000, + "timestamp": 1710000000000 } ``` -**Categories:** -- `plcConfig`: Echoes the input configuration -- `plcProps`: Controller properties (model, serial, etc.) -- `plcTime`: Controller clock time -- `plcTags`: Complete list of available tags -- `debug`: Diagnostic messages -- `error`: Error information - -### Connection States +Deadband filtering suppresses small fluctuations on analog values so only meaningful changes flow downstream. -Monitor the node status to track connection health: +### Reading legacy controllers -| State | Color | Meaning | -|-------|-------|---------| -| connecting | blue | Initiating connection to PLC | -| reading props | blue | Reading controller properties | -| discovering tags | blue | Scanning for available tags | -| connected | green | Active and monitoring tags | -| closing | gray | Shutting down connection | -| closed | red | Disconnected and idle | -| warn - end | yellow | PLC terminated connection | -| warn - closed | yellow | Connection closed | -| error - config | red | Invalid input message | -| error - connect | red | Cannot reach PLC | -| error - prop read | red | Cannot read properties | -| error - tag discovery | red | Cannot read tag list | -| error - scan | red | Error during tag scanning | -| error - disconnect | red | Error during shutdown | -| error - controller | red | Incompatible controller type | - -## Example Flow +The `cip-pccc-read` node returns data-file values from SLC 500, MicroLogix, and PLC-5 controllers: ```json -[ - { - "id": "inject1", - "type": "inject", - "name": "Connect to PLC", - "topic": "", - "payload": "{\"address\":\"192.168.1.100\",\"slot\":0,\"scanRate\":500,\"tagConfig\":[{\"scope\":\"\",\"tags\":[{\"tagName\":\"Tag1\",\"tagType\":\"DINT\"}]}]}", - "payloadType": "json", - "wires": [["plcNode"]] - }, - { - "id": "plcNode", - "type": "eth-ip", - "name": "Production Line PLC", - "wires": [["output"], ["debug"]] - } -] +{ + "payload": 1234, + "address": "N7:0", + "fileType": "Integer", + "timestamp": 1710000000000 +} ``` +## Node Status Indicators + +| Color | Shape | Meaning | +|-------|-------|---------| +| Green | dot | Connected / OK | +| Yellow | ring | Connecting / warning | +| Red | ring | Error / disconnected | +| Blue | dot | Operation in progress | + ## Best Practices ### Connection Management -- Any new input message will close the existing connection and establish a new one -- Use a **status node** to monitor connection health and implement retry logic -- Handle reconnection logic externally to the node +- Share a single `cip-endpoint` configuration node across all read, write, browse, and subscribe nodes talking to the same PLC. +- The endpoint reconnects automatically at the configured retry interval; use a **status node** if you need to react to connection changes in your flow. +- All nodes skip new requests while a previous one is in flight, which protects the PLC from overload. ### Network Configuration -- Ensure your FlowFuse instance can reach the PLC IP address -- Configure firewall rules to allow TCP port 44818 (EtherNet/IP) -- Use static IP addresses for PLCs in production environments +- Ensure your FlowFuse instance can reach the PLC IP address. +- Configure firewall rules to allow TCP port 44818 (EtherNet/IP). +- Use static IP addresses for PLCs in production environments. +- Use the routing path setting to reach PLCs behind ControlLogix backplanes or across multiple hops. + +### Tag Selection and Scan Rates +- Only subscribe to tags you need to minimize network traffic. +- Use appropriate scan rates based on how quickly data changes; faster scan rates increase CPU and network load. +- Use deadband filtering on analog tags to avoid flooding downstream systems with insignificant changes. -### Tag Selection -- Only subscribe to tags you need to minimize network traffic -- Use appropriate scan rates based on how quickly data changes -- Faster scan rates increase CPU and network load +### Writing Safely +- Validate values in a `function` node before they reach a `cip-write` node, especially when values originate from dashboards or external systems. +- Prefer bit-level writes for command bits so unrelated bits in the same word are never disturbed. +- Keep safety functions and interlocks in the PLC program. Never rely on a flow to enforce a safety condition. ### Error Handling -- Connect a **catch node** to handle errors gracefully -- Monitor the debug output for diagnostic information -- Implement reconnection strategies for production reliability - -## Compatibility - -### Tested Hardware -- Allen-Bradley ControlLogix (L7x, L8x series) -- Allen-Bradley CompactLogix (L1x, L2x, L3x series) -- Allen-Bradley MicroLogix (1100, 1400, 1500 series) - -### Supported Data Types -- BOOL (Boolean) -- SINT (Short Integer) -- INT (Integer) -- DINT (Double Integer) -- REAL (Floating Point) -- STRING (82-character Allen-Bradley strings) -- Custom UDTs (User Defined Types) +- Connect a **catch node** to handle errors gracefully. +- Use the admin metrics endpoint (`GET /cip-endpoint/:id/metrics`) to monitor response times, error counts, and uptime. ## Troubleshooting ### Cannot Connect to PLC -- Verify IP address and network connectivity (ping test) -- Check slot number matches your controller configuration -- Ensure PLC firmware supports EtherNet/IP messaging -- Verify firewall settings allow TCP 44818 +- Verify IP address and network connectivity (ping test). +- Check the slot number matches your controller configuration. +- For Micro800 controllers, enable Micro800 mode on the endpoint. +- Verify firewall settings allow TCP 44818. ### Tags Not Updating -- Confirm tag names match exactly (case-sensitive) -- Verify tag scope is correct -- Check scan rate isn't too slow for your application -- Ensure tags exist in the controller +- Confirm tag names match exactly (case-sensitive). +- For program-scoped tags, use the full `Program:ProgramName.TagName` format. +- For legacy controllers, verify the data-file address format (e.g. `N7:0`, not a tag name). +- Check the scan rate isn't too slow for your application. ### Connection Drops Frequently -- Reduce scan rate to decrease network load -- Check network stability and switch configuration -- Verify PLC isn't overloaded with connections -- Consider using unconnected messaging for multiple clients - -## Technical Details - -This node uses **unconnected messaging** mode by default with a 5064ms timeout, which: -- Reduces timeout issues with multiple clients -- Works better in high-latency networks -- Allows multiple nodes to connect to the same PLC - -String handling automatically decodes Allen-Bradley's proprietary format: -- First 4 bytes contain Little-Endian INT32 length -- Remaining bytes contain ASCII character data -- Maximum length of 82 characters +- Reduce scan rates to decrease network load. +- Check network stability and switch configuration. +- Verify the PLC isn't overloaded with connections from other clients. \ No newline at end of file diff --git a/src/node-red/flowfuse/edge/opcua.md b/src/node-red/flowfuse/edge/opcua.md index 74d87475d6..49c439e8f6 100644 --- a/src/node-red/flowfuse/edge/opcua.md +++ b/src/node-red/flowfuse/edge/opcua.md @@ -11,7 +11,7 @@ meta: Connect a FlowFuse instance to industrial OPC UA servers. Read and write values, monitor changes in real time, call methods, browse the address space, read history, work with files, or host your own OPC UA server, all from within your flows. -This is a **FlowFuse Certified Node**. FlowFuse vets it for quality, security, and support, and maintains it on an ongoing basis. [Read more about Certified Nodes](/blog/2025/07/certified-nodes-v2/). +This is a **FlowFuse Certified Node**. Unlike community nodes, which vary in quality and can go unmaintained without warning, FlowFuse vets Certified Nodes for quality, security, and support, and maintains them on an ongoing basis. [Read more about Certified Nodes](/blog/2025/07/certified-nodes-v2/). ## Table of contents @@ -52,6 +52,25 @@ Everything runs inside your FlowFuse instance. Connections, certificates, and cr - Read, write, and append files on servers that implement the OPC UA FileType interface. - Host an OPC UA server from within a self-hosted FlowFuse instance using Function nodes. +### Use case + +Most industrial equipment already speaks OPC UA, but the data usually stays inside the machine's own server: readable by the vendor's tools, invisible to dashboards, brokers, and databases. This certified node closes that gap. A FlowFuse instance connects to the equipment as an OPC UA client, so the values, alarms, and history locked inside each machine become ordinary flow data you can route, transform, and act on. On self-hosted FlowFuse it also works in the other direction, exposing flow data as an OPC UA server for SCADA systems and historians to consume. + +#### Example: connecting a filling machine to the plant + +A filling machine exposes `FillLevel`, `LineSpeed`, and an alarm hierarchy through its embedded OPC UA server. Today that data lives on the machine's own panel. With one shared connection, a Monitor node streams the process values into the plant's Unified Namespace over MQTT, with a deadband filter suppressing sensor jitter before it ever reaches the network. A Monitor Event node subscribed with `Severity >= 600` routes machine alarms to the maintenance team's chat channel. And when the recipe changes, a Write node, gated behind an operator confirmation on a dashboard, pushes the new fill setpoint back to the machine. One connection replaces a per-machine SCADA tag mapping exercise, and the same flow pattern repeats for every OPC UA machine on the floor. + +#### Where this shows up in practice + +Real deployments usually combine several of the nodes on a single shared connection (see [The node set](#3.-the-node-set) for what each one does): + +- **Unified Namespace and broker integration**: subscribe to the variables that matter with [Monitor](#10.-monitor) and publish changes to MQTT, so every system in the plant consumes the same live equipment data instead of integrating with each machine separately. +- **Supervisory control**: fetch current values on demand with [Read](#6.-read), push setpoints and recipe parameters back with [Write](#7.-write), and invoke machine operations such as starting a batch or acknowledging an alarm with [Call](#9.-call). Writes change real-world state, so gate them behind validation or an operator confirmation step. +- **Alarm-driven maintenance**: subscribe to a server's alarms and events with [Monitor Event](#11.-monitor-event), filter by type and severity on the server side, and route what remains to notifications, dashboards, or logs, so the maintenance team hears about a fault from the machine, not from the operator. +- **Shift reports, trends, and audits**: pull raw or server-aggregated values over a time range with [History Read](#14.-history-read) to build end-of-shift reports, quality trends, and incident timelines from data the equipment already recorded. +- **Fast commissioning**: map a machine's entire address space with [Explore](#13.-explore) and feed the result straight into a Monitor node, turning hours of manual tag mapping into a single deploy. +- **Exposing flow data to SCADA and historians**: on self-hosted FlowFuse, [host an OPC UA server](#16.-hosting-an-opc-ua-server) so external OPC UA clients, including another FlowFuse instance, can read the data your flows produce. This is not available on FlowFuse Cloud. + ## 2. Get the Certified Node in FlowFuse FlowFuse delivers Certified Nodes to your instances as a managed catalogue. The OPC UA package is part of the FlowFuse Edge Certified Nodes catalogue, which is part of the **FlowFuse Edge** offering. [contact us](/contact-us/) to enable it for your team @@ -959,4 +978,4 @@ The OPC UA port (default 4840) is configurable per server; update the rule if yo | Cannot host a server on FlowFuse Cloud | Server hosting requires a self-hosted FlowFuse instance with the OPC UA TCP port exposed. Cloud exposes HTTP/HTTPS only. | | Re-trusting the server certificate after every deploy | The PKI directory (`/opcua-for-flow-fuse/PKI`) is not on persistent storage. On container-based FlowFuse it must sit under the `/data/storage` persistent volume. Also confirm the certificate is in `trusted`, not `rejected`. | -For help enabling the OPC UA Certified Node, licensing, or anything else, [contact FlowFuse](/contact-us/). +For help enabling the OPC UA Certified Node, licensing, or anything else, [contact FlowFuse](/contact-us/). \ No newline at end of file diff --git a/src/node-red/flowfuse/edge/rtsp.md b/src/node-red/flowfuse/edge/rtsp.md index ba96fadb7f..5ec395afa4 100644 --- a/src/node-red/flowfuse/edge/rtsp.md +++ b/src/node-red/flowfuse/edge/rtsp.md @@ -12,6 +12,8 @@ meta: The **RTSP Video Feed** node connects to an [RTSP](https://en.wikipedia.org/wiki/Real-Time_Streaming_Protocol) video stream from an IP camera or NVR and extracts still frames as PNG images. +This is a **FlowFuse Certified Node**. Unlike community nodes, which vary in quality and can go unmaintained without warning, FlowFuse vets Certified Nodes for quality, security, and support, and maintains them on an ongoing basis. [Read more about Certified Nodes](/blog/2025/07/certified-nodes-v2/). + The node orchestrates `ffmpeg` to acquire and decode the video stream. By handling the video decoding externally, `ffmpeg` reduces the processing load on the main FlowFuse event loop. However, higher frame rates and image resolutions generate more image data, which can increase CPU and memory usage as frames are transferred and processed within your flows. The node is a source node with no input connector. It begins capturing frames as soon as the flow is deployed and displays a green **Running** status on the canvas when it has successfully connected to the stream. If `ffmpeg` exits unexpectedly, the node restarts it automatically after a short delay and displays the exit code in the node status. Extracted frames can either be emitted as messages into the flow or written directly to disk as a numbered sequence of PNG files. See [Operating modes](#operating-modes) for details. @@ -20,6 +22,27 @@ Extracted frames can either be emitted as messages into the flow or written dire The RTSP Video Feed node is not available by default. It is part of the FlowFuse Edge Certified Nodes catalogue, which is part of the **FlowFuse Edge** offering. Please contact our sales team at [Contact us](/contact-us/) to learn more or to request access. {% endnote %} +## Use case + +Most plants and facilities already have IP cameras on the network, but the footage is locked inside an NVR: useful for reviewing an incident after the fact, invisible to everything else. The RTSP Video Feed node turns those existing cameras into a live data source. It captures still frames from the stream at a rate you choose and hands them to your flow as PNG images, where they can be analyzed, displayed, filtered, or stored like any other data. No new hardware, no separate video-analytics appliance. + +### Example: catching mislabeled products on a packaging line + +A camera above a packaging line already streams to the site NVR. Point the RTSP Video Feed node at that same stream, set it to 1 FPS, and wire it to a [FlowFuse AI node](/node-red/flowfuse/ai/) running an image classification model. Each frame is checked for a missing or misprinted label, and when one is detected, the flow raises a dashboard alert and publishes the offending frame over MQTT for the quality team to review. What used to require an operator glancing at a screen, or a dedicated vision system with its own controller and license, becomes a three-node flow on hardware you already own. + +### Where this shows up in practice + +- **Machine vision**: feed frames to a [FlowFuse AI node](/node-red/flowfuse/ai/) for object detection or image classification, then act on the result, for example counting parts on a line, checking a fill level, or verifying a safety gate is closed. +- **Remote monitoring**: display the frames live on a [FlowFuse Dashboard](https://dashboard.flowfuse.com/) so an operator can watch a machine or area from anywhere the dashboard is reachable, alongside the process data on the same page. +- **Event snapshots**: route frames through a `function` or `switch` node and keep only the ones that matter, for example the frame captured the moment a PLC tag or sensor reports a fault, and forward it with an [`mqtt out`](/node-red/flowfuse/mqtt/mqtt-out/) node or attach it to an alert. +- **Timelapse and archiving**: switch to disk-writing mode and the node writes a numbered sequence of PNG files for later review or timelapse assembly, without adding any messages to the flow. + +### Combining video with other plant data + +Because the frames arrive as ordinary messages, they combine naturally with everything else in a flow. A single flow can join a camera frame with the PLC tag values captured at the same moment, so a quality event is recorded with both the picture and the process conditions that produced it. That correlation is exactly what standalone camera systems can't do. + +Set the FPS no higher than the use case requires: in message mode each captured frame becomes a message, and higher frame rates increase CPU and memory usage. + ## Requirements The node requires `ffmpeg`. In most cases this is handled automatically: the node pulls in `ffmpeg-static` on install, which provides a prebuilt `ffmpeg` binary for your platform. @@ -75,7 +98,7 @@ The node emits each captured frame as a message at the configured FPS rate. | `msg.payload` | Buffer | The captured frame as a PNG image buffer. | | `msg.topic` | String | The topic configured on the node. | -The output can be wired to any node that accepts an image buffer, including [FlowFuse Dashboard widgets](https://dashboard.flowfuse.com/),[MQTT out nodes](/node-red/flowfuse/mqtt/mqtt-out/), and [FlowFuse AI nodes](/node-red/flowfuse/ai/). +The output can be wired to any node that accepts an image buffer, including [FlowFuse Dashboard widgets](https://dashboard.flowfuse.com/), [MQTT out nodes](/node-red/flowfuse/mqtt/mqtt-out/), and [FlowFuse AI nodes](/node-red/flowfuse/ai/). {% note %} Every captured frame becomes a message in the flow. A high FPS value increases the number and size of messages being processed. Set FPS no higher than your use case requires. diff --git a/src/node-red/flowfuse/hub/redis.md b/src/node-red/flowfuse/hub/redis.md index 272ec47e93..c043f85f84 100644 --- a/src/node-red/flowfuse/hub/redis.md +++ b/src/node-red/flowfuse/hub/redis.md @@ -28,6 +28,18 @@ Built on [ioredis](https://github.com/luin/ioredis), so anything ioredis support The Redis node is not available by default. It is part of the FlowFuse Hub Certified Nodes catalogue, which is part of the **FlowFuse Hub** offering. Please contact our sales team at [Contact us](/contact-us/) to learn more or to request access. {% endnote %} +## Use case + +Redis is commonly used with FlowFuse as a fast shared data layer between flows and instances, since Node-RED's own context is per-instance and does not span multiple instances. This package exposes Redis through several nodes, each suited to a different pattern: + +- **Shared state and caching**: `redis-command` runs `SET`/`GET` and other commands, so several flows or instances can read and update the same values: a cached sensor reading, a rate counter, or an inventory count. Setting an expiry (`EX`) turns any key into a time-limited cache entry. +- **Work queues**: `redis-out` with `rpush` adds items to a list, and `redis-in` with `blpop` lets a worker flow pick them up in order as they arrive, decoupling a producer flow from a consumer. +- **Messaging (pub/sub)**: `redis-out` `publish` broadcasts a message to every `redis-in` `subscribe` node listening on that channel at once, across instances. +- **Atomic operations**: `redis-lua-script` runs a Lua script on the server in a single round trip, so a multi-step operation cannot interleave with another client, for example checking and decrementing stock so two concurrent orders cannot oversell the last unit. +- **Direct client access**: for anything the nodes above do not cover (pipelines, `SCAN`, RedisJSON, or other module commands), `redis-instance` injects a live ioredis client into context for use in function nodes. + +Connections are pooled per config node, so pointing many nodes at the same server reuses one connection rather than opening a separate one for each. Blocking operations such as `subscribe` and `blpop` take their own dedicated connection automatically. + ## Install 1. Open the **Palette Manager** from the top-right menu in the FlowFuse editor.