FlowFuse

FlowFuse 2.20: AI-Assisted Node-RED & New Database Service

2025-07-31T00:00:00Z

This release represents a major leap forward in FlowFuse's data management and AI capabilities, introducing our new FlowFuse Tables database feature, along with enhanced AI assistance features and a streamlined user interface. These improvements make FlowFuse a complete solution for building industrial applications, even while reducing development time.

Introducing: FlowFuse Tables

A screenshot of the new "Tables" view, now available in FlowFuse

FlowFuse Tables is our brand new database offering that provides a simple way to store your data, all within the FlowFuse ecosystem. This comprehensive database offering comes with FlowFuse's enterprise-grade security and unlocks the ability to seamlessly build critical systems like MES and ERP.

FlowFuse Tables eliminates the complexity of setting up and managing separate database infrastructure, allowing you to focus on building applications that drive operational efficiency.

FlowFuse Tables is available now for all Enterprise users running on FlowFuse Cloud.

New Node: Query

A flow in Node-RED that uses the new FlowFuse "Query" node

Alongside the new Tables offering, we have shipped a new node that you can find in your Node-RED Editor - "Query". This will automatically connect to any associated database you have with your team, saving you time in manually configuring nodes and credentials, giving you more time to just focus on the fun of building your flows, and making it really easy to start storing and querying your data.

AI-Assisted Node-RED with Smart Suggestions

GIF of Smart Suggestions in Action

Development in Node-RED is now even faster with Smart Suggestions, an agent that runs in-browser and offers intelligent flow completion for next-node recommendations. With Smart Suggestions, as you place a node, the agent will automatically calculate the most likely next node to place, and will offer suggestions for the node's configuration. It present up to 5 options, so even if the first suggestion isn't correct, it's very likely that the correct choice is only a quick keyboard shortcut away.

This work extends the functionality of the in-built FlowFuse Assistant and it's MCP server that runs behind the Node-RED Editor to provide power additional development enhancements.

New Blueprint: Agentic AI with Retrieval Augmented Generation

The new RAG (Retrieval Augmented Generation) Blueprint enables you to train your own LLM agents, combining your own data with natural language capabilities.

This Blueprint provides two flows: one that adds text into Node-RED's flow context store and uses it to train an OpenAI agent, so you can query the content of the flow directly; and one flow that scrapes websites to train an OpenAI agent so that content can be queried and used as well.

The RAG Blueprint makes it easy to create intelligent agents that leverage your organizational knowledge without requiring deep AI expertise. Try it out for yourself here.

Refined Applications Page

Screenshot of Redesigned Applications Page

With the new FlowFuse Home page in place, we have greatly streamlined the Applications page. The new structure includes:

Streamlined Navigation: Applications now appear under Instances in the navigation hierarchy
Reduced Cognitive Load: Eliminated the overwhelming number of buttons and links in the previous design
Focus on Important Information: The newly refined design focusses on giving you a clear overview of the status of your Hosted and Remote Instances, split by Application.
Performance Optimizations: The above has also lead to faster page loading and improved responsiveness

This redesign creates a more intuitive workflow that aligns with how teams actually use FlowFuse, reducing clicks and improving productivity.

More Powerful "Small" Instances

Based on user feedback and our own review of instance performance, we have increased the CPU and memory of all "small" Node-RED instances running on FlowFuse. This will have the immediate benefit of preventing slowdowns and loading issues for all Starter and Team customers.

What's Next?

Our development roadmap continues to focus on AI integration and enterprise data management. Upcoming releases will expand FlowFuse Tables with additional database types and analytics capabilities, while our AI Assistant will gain more sophisticated workflow automation features.

We're also working on enhanced Blueprint offerings and deeper integration between our AI capabilities and industrial data sources, with several exciting announcements planned for the coming months!

What else is new?

For a complete list of everything included in our 2.20 release, check out the release notes.

Your feedback continues to be invaluable in shaping FlowFuse's development. We'd love to hear your thoughts on these new features and any suggestions for future improvements. Please share your experiences or report any issues on GitHub.

Which of these new features are you most excited to try? Email me directly at greg@flowfuse.com - I'd love to hear from you!

Try FlowFuse

FlowFuse Cloud

The quickest way to get started is with FlowFuse Cloud.

Get started for free and have your Node-RED instances running in the cloud within minutes.

Self-Hosted

Get FlowFuse running locally in under 30 minutes using Docker or Kubernetes.

FlowFuse AI Assistant: Let Your Engineers Build Automation, Not Write Code

2025-07-29T00:00:00Z

Every manufacturing engineer knows this scenario: Node-RED's visual programming handles most of your automation needs brilliantly. Connect to PLCs, route data, trigger actions—all with drag-and-drop simplicity, but then you hit the wall. Your machine outputs data in a proprietary format. You need a custom dashboard widget that doesn't exist. You're manually creating test data for hours, or you're trying to understand a complex flow built by someone who left last year.

These bespoke tasks can often demand coding skills—JavaScript for parsing data, Vue.js for custom widgets, CSS for styling. Skills your automation engineers might not have. Skills that pull them away from what the engineers do best: optimizing production.

FlowFuse's AI Assistant changes this dynamic completely. Describe what you need in plain English, then, get working code instantly. No more hours lost to syntax errors or Stack Overflow searches. Your engineers can focus on their own expertise, and FlowFuse Assistant fills in the gaps. Let's look at how manufacturing teams can use it to solve real problems.

Parsing Machine Data Without the JavaScript Struggle

While Node-RED's low-code nodes cover most scenarios, every production line has unique quirks. Complex data parsing, multi-step calculations, proprietary protocols—these can all be accomplished in Node-RED by writing your own JavaScript. Engineers, who should be focussed on optimizing processes, end up out of their comfort zone, searching regex patterns and debugging syntax errors.

Consider this output from a CNC machine that's been reliable for 15 years:

-- CYCLE END REPORT --
ID: M-45B / PART: XF-201
TIMESTAMP: 2025-07-09T14:22:01Z
SERIAL: 2025-0001547
OPERATOR: JONES, M
STATS ---
PART_COUNT: 481
CYCLE_TIME (S): 114.72
MAX_TEMP (C): 85.3
TOOL_WEAR_IDX: 0.73
COOLANT_LEVEL: OK
ALERTS: NONE
-- END --

The traditional approach means spending 30-50 minutes writing regex patterns, handling edge cases, and testing thoroughly. Your engineer needs to remember JavaScript string methods, debug regex syntax, and account for variations in the output format.

With FlowFuse Assistant, the process changes completely. Your engineer opens a function node, clicks the FlowFuse Assistant button, and types:

"Parse this CNC report format. Extract PART_COUNT as integer, CYCLE_TIME as float, TOOL_WEAR_IDX as float, OPERATOR name, and ALERTS. Return as JSON."

The engineer reviews the code, tests it with their data, and moves on to solving actual manufacturing problems instead of wrestling with JavaScript syntax.

FlowFuse AI Assistant generating a Node-RED function node to extract data from a CNC text report.

Creating Test Data in Seconds, Not Hours

Before connecting to live equipment, you need test data that looks real. Making it by hand is tedious and wastes lots of time.

With FlowFuse Assistant, just ask:

"Generate 20 machine records with machine_id, production_count, efficiency_percentage, downtime_minutes, and last_maintenance_date. Show realistic variations."

It's as simple as that.

FlowFuse AI Assistant creating realistic test data for manufacturing dashboards—complete with machine IDs, production metrics, and maintenance dates.

Building Custom Dashboards Without Web Development

FlowFuse Dashboard widgets cover most UI needs, but manufacturing can often demand more. Custom visualizations for specific KPIs can be build in Dashboard with the "Template" node, where developers can write their own Vue.js templates.

Developing custom components to match your HMI design standards takes CSS expertise. Whether you're building new widgets or styling existing ones, you're suddenly in web development territory—far from where most automation engineers want to be.

Take a Pareto Chart for defect analysis as an example—essential for quality teams but not available as a standard Dashboard widget. Building it requires Vue.js knowledge, Chart.js integration, and responsive design skills.

With FlowFuse's AI Assistant, just describe what you need:

"Create a Pareto chart widget showing defect counts as bars with a cumulative percentage line. Include the 80% threshold."

FlowFuse AI Assistant building both custom widgets and styling existing components for manufacturing dashboards.

Or consider input boxes for operator data entry that look too modern. Your team prefers the familiar green LCD screens they've used for decades, you can ask FlowFuse Assistant:

"Add CSS that makes the input with classes 'calculator' and 'text-input' look like an old green LCD calculator screen."

AI Assistant creating CSS that transforms standard input boxes into retro LCD displays with glowing green text.

Whether creating new widgets or styling existing ones, AI Assistant handles the Vue.js and CSS complexity. You describe the outcome—it generates the code.

Documenting Complex Flows Before Knowledge Walks Out

Production flows evolve over years into complex systems. Hundreds of nodes, critical logic buried in functions, intricate routing between tabs. When knowledge walks out the door, new team members can face weeks of detective work trying to understand flows and their colleague's work.

FlowFuse Assistant's Flow Explainer solves this. Select any flow or group of nodes, click "Explain," and get instant documentation. It analyzes connections, reads function code, and generates clear explanations of what everything does and why.

FlowFuse AI Assistant turning complex flows into clear documentation for easy knowledge transfer.

Start Building Today

FlowFuse Assistant is just one way FlowFuse helps manufacturing teams work faster.

Teams collaborate on flows in real-time. Version control with snapshots means you can always go back if something breaks. Remote device management handles edge devices across your factory floor. Deploy to one machine or a thousand with a single click. Built-in DevOps pipelines streamline your workflow from development to production.

For production reliability, high availability keeps systems running 24/7. The integrated MQTT broker handles all your device messaging. Enterprise security includes SSO, multi-factor authentication, role-based access control, and complete audit logs.

FlowFuse gives you everything you need to build, deploy, and manage Node-RED at scale.

Try FlowFuse free →

How Leading Manufacturers Save Thousands of Dollars/Year with Real-Time SPC

2025-07-24T00:00:00Z

Leading manufacturers are quietly saving thousands, sometimes millions, of dollars annually with a quality control method that's been proven since the 1920s. The difference today? Modern tools make it simple to implement.

Consider this real example: A manufacturer shared on Practical Machinist forum that they process 400,000 parts per year with a 4% scrap rate. That's 16,000 parts discarded annually. At even a conservative $10 per part, this represents $160,000 in direct losses from a single production line. They accepted this as normal because industry reports confirm 4-5% scrap rates are standard.

What separates industry leaders from the rest? They refuse to accept "normal" waste. Using Statistical Process Control (SPC), they detect problems as they occur, not after producing defective parts. When a process begins drifting, they receive immediate alerts and correct it before generating scrap.

This guide shows you exactly how to build a real-time SPC system using FlowFuse. You'll create a live dashboard that tracks measurements and alerts operators the moment something goes wrong. No statistics degree needed, just practical steps you can implement today.

Why Traditional Quality Control Falls Short

Most manufacturers still rely on end-of-line inspection. Make parts, check parts, scrap the bad ones. This reactive approach creates three expensive problems:

Problem 1: You're always too late When inspection finds a defect, you've already invested in material, machine time, labor, and energy. That investment is now scrap. Worse, how many parts did you make between when the problem started and when you caught it?

Problem 2: The borderline parts you miss Not all defects are obvious. Parts that barely pass inspection today might fail in the field tomorrow. These marginal parts slip through because traditional inspection only catches clear failures, not process degradation.

Problem 3: No insight into root causes Finding bad parts tells you nothing about why they're bad. Was it temperature drift? Tool wear? Material variation? Without process data, you're guessing at solutions.

The Proactive Alternative: Statistical Process Control

SPC flips the entire approach. Instead of checking parts after production, it monitors your process during production. The NIST Engineering Statistics Handbook explains it simply:

"The underlying concept of statistical process control is based on a comparison of what is happening today with what happened previously."

When your process starts to drift from its normal behavior, SPC alerts you immediately. You fix the issue before making defective parts, not after.

Walter Shewhart developed this method at Bell Labs in the 1920s, proving its effectiveness across industries. Today, FlowFuse makes it accessible to any manufacturer, regardless of size or technical expertise.

Building Your First SPC System with FlowFuse

Let's build a real example. This guide shows you how to create a SPC control chart for individual measurements - perfect for monitoring critical dimensions in real-time.

First, open your FlowFuse Node-RED instance. If you don't have one yet, you can sign up for a free account and have an instance running in minutes.

What We're Building

A real-time SPC control chart that monitors individual measurements and automatically calculates control limits. Perfect for scenarios where you measure one part at a time - like bearing dimensions on a CNC line. When measurements drift outside the calculated limits, you'll know instantly.

Step 1: Get Your Tools Ready

First, we need two nodes for SPC monitoring.

Open FlowFuse's palette manager (hamburger menu → Manage palette)
Go to the Install tab
Search for and install these nodes:
- node-red-contrib-simple-spc - This is your statistics engine
- @flowfuse/node-red-dashboard - For that slick real-time chart
Click Install for each node and wait for completion

Step 2: Simulate Your Machine Data

In production, you'd connect to your PLC. For now, let's simulate a bearing measurement around 10mm nominal.

Drag an inject node onto your canvas. This is your "sensor."
Double-click it and set:
- Repeat: interval → 2 seconds (mimics real sensor timing)
- Payload: switch to JSONata mode and enter: $random() * 0.2 + 10

This generates readings like 10.05, 9.98, 10.11 - realistic variation around 10mm.

Step 3: Add the Statistical Brain

Find the spc node in your palette (it'll be under "function" category after install).

Drag it over and wire your inject node to it.
Double-click to configure:
- Control Limit Multiplier: 3 (for 3-sigma limits)
- Timer: 10 (seconds before alerting out-of-control)

Once configured, the node outputs an object like this:

{
    value: 10.020214950604476,      // Current measurement
    avg: 10.089877376434453,         // Running average
    ucl: 10.344067494423967,         // Upper control limit
    lcl: 9.835687258444938,          // Lower control limit
    outOfControl: false              // Alert status
}

Step 4: Make the Data Chart-Ready

Charts need data in a specific format. Add a change node between SPC and your chart.

Drag a change node onto the canvas
Wire it between the SPC node and where your chart will go
Double-click to configure and set one rule: Set msg.payload to this JSONata expression:

[
    {"series": "Measurement", "x": $millis(), "y": payload.value},
    {"series": "UCL", "x": $millis(), "y": payload.ucl},
    {"series": "LCL", "x": $millis(), "y": payload.lcl},
    {"series": "Average", "x": $millis(), "y": payload.avg}
]

This creates four lines on your chart, your actual measurements plus the three control lines.

Step 5: Build Your Control Room Dashboard

Now we'll create the dashboard that displays your SPC control chart. This is what operators will watch to spot problems in real-time.

Drag a chart widget from the dashboard section and set:
- Type: Line Chart
- X-axis: HH:mm:ss (shows time)
- Series: Set to series (as key)
- X: Set to x (as key)
- Y: Set to y (as key)
- Legend: Show
- Label: "SPC Chart: Bearing Diameter (mm)"
Connect the change node to it.
Deploy the flow.

Complete SPC monitoring flow with real-time chart display

Step 6: Add the Alert System

A chart is nice, but you need immediate alerts. Here's the clever bit:

Add a switch node connected to your SPC output
Set it to check msg.payload.outOfControl
Create two outputs: true and false
Now add a text nodes from dashboard. Wire it to your switch outputs.

For the "true" path, set the text to something attention-grabbing using change node: ⚠️ PROCESS OUT OF CONTROL - CHECK MACHINE!

For the "false" path: ✓ Process Stable

Deploy the flow.

Node-RED alert system with switch node: Process stable

Step 7: Test Your SPC System

Open your dashboard (switch to the Dashboard 2.0 tab → click Open Dashboard button on the top-right of the right sidebar).

What you'll see initially:

First 20 measurements: Chart builds up baseline data
After 20 points: Control limits appear automatically
Blue line bouncing between red lines: Process is stable

Let the system run for a minute to establish your baseline. The control limits aren't arbitrary - they're calculated from your actual process data.

Now test it with a simulated process shift:

Double-click the Inject node
Change the formula to $random() * 0.2 + 10.5 (this shifts the mean up by 0.5mm)
Click Done to close the node
Deploy only the modified nodes:
- Click the down arrow next to the Deploy button
- Select Modified Nodes
- Click the Deploy button

Deploy menu with Modified Nodes option for updating only changed nodes

Once done You will see the chart detect the change within seconds.

SPC chart detecting process shift - measurements above UCL trigger immediate alert

SPC Chart Rules That Actually Matter

Control limits catch obvious problems. But subtle issues need pattern recognition. Here are the four rules that catch 95% of real problems:

Rule 1: Any point outside limits This one is fairly obvious: If a measurement point falls outside of the established upper or lower limits, something is wrong.
Rule 2: Seven points on one side Seven consecutive points above or below the center line means your process has shifted. Maybe a new material lot, maybe tool wear.
Rule 3: Seven points trending Seven points in a row going up or down. Classic sign of tool wear or temperature drift.
Rule 4: Repeating and Cyclical Patterns This rule is for recurring behaviors that the other rules miss. Cycles that repeat over time, like a regular pattern that appears at the start of every shift change or every Monday. Speak with your operators, they will likely know what these mean.

Here's how to implement these rules in FlowFuse:

Drag a Function node onto the workspace and add the following JavaScript code to it.
Replace switch node with this Function node.
Deploy the flow.

const buffer = context.get('measurements') || [];
const current = msg.payload;

// Rule 1: Out-of-control point (handled by SPC node)
if (msg.payload.outOfControl) {
    msg.payload = "⚠️ PROCESS OUT OF CONTROL – CHECK MACHINE!";
    return msg;
}

// Store the current measurement
buffer.push({
    value: current.value,
    avg: current.avg,
    timestamp: new Date()
});

// Keep only the last 20 measurements
if (buffer.length > 20) {
    buffer.shift();
}
context.set('measurements', buffer);

// Initialize alert message
let alertMessage = "✓ Process Stable";

// Check rules if we have enough data
if (buffer.length >= 7) {
    const recent = buffer.slice(-7);
    const values = recent.map(r => r.value);

    // Rule 2: Seven points on one side of the center line
    const allAbove = values.every(v => v > current.avg);
    const allBelow = values.every(v => v < current.avg);
    if (allAbove || allBelow) {
        alertMessage = "⚠️ Process shift detected – 7 points on one side of center";
    }

    // Rule 3: Seven points trending up or down
    let trending = true;
    const increasing = values[1] > values[0];
    for (let i = 2; i < values.length; i++) {
        if ((increasing && values[i] <= values[i - 1]) ||
            (!increasing && values[i] >= values[i - 1])) {
            trending = false;
            break;
        }
    }
    if (trending) {
        alertMessage = increasing
            ? "⚠️ Increasing trend – check for tool wear"
            : "⚠️ Decreasing trend – check material quality";
    }
}

msg.payload = alertMessage;
return msg;

The following image demonstrates the advanced alerting system in action, detecting specific patterns beyond simple control limit violations:

Real-time SPC monitoring detecting process drift and triggering appropriate alerts based on trend analysis

Connecting to Real Equipment

Time to connect your actual machines. The approach depends on what equipment you have.

For modern PLCs - anything from the last decade like Siemens S7-1200/1500, Allen-Bradley ControlLogix, or Omron NX - you'll use OPC UA. It's already built into these PLCs. Enable it in the configuration, install node-red-contrib-opcua from the FlowFuse palette, and point it at your PLC. The endpoint looks like opc.tcp://192.168.1.100:4840. Browse for your measurement tags and connect them to your SPC flow. Full OPC UA guide here.

Older equipment speaks Modbus TCP. Check your manual's appendix for the register map. Install node-red-contrib-modbus, configure it with your device's IP address and the register holding your measurement (like 40001 for holding registers). Almost every industrial device from the last 30 years supports this. Modbus tutorial here.

For everything else, get creative. Old gauges with RS-232 ports work fine with a USB adapter and the serial node - see our serial port guide. Machines that dump CSV files can be monitored with the watch node. Manual measurements need just a simple dashboard form, one input field, one submit button. Don't overcomplicate it.

Before connecting to SPC, always test with inject → protocol node → debug to make sure data flows. Once you see measurements in the debug panel, wire it to your SPC node and you're monitoring real processes.

The Money You're Leaving on the Table

Remember that manufacturer from the forum processing 400,000 parts annually with a 4% scrap rate? That's 16,000 parts straight to the trash. At just $10 per part, that's $160,000 in annual waste. Cut that rate to 2% with SPC and you save $80,000 yearly.

But here's what most people miss - the $10 part cost is just the beginning. Consider what every defective part also burned through:

Machine time: Say 3 minutes at $200/hour = another $10 gone
Labor: About 15 minutes handling the defect at $30/hour = $7.50 more
Materials: The raw stock you'll never get back

That "$10 part" actually cost you around $27.50 to scrap. Those 16,000 defects? Try $440,000 in real losses.

SPC attacks all of this simultaneously. When your process stays in control, you're not just saving parts - you're saving machine capacity, labor hours, and materials. Plus stable processes need less inspection, letting you redeploy quality staff to improvement projects instead of firefighting.

Quick ROI calculation: Take your annual defect count, multiply by your true cost per defect (part + machine + labor), then multiply by 0.5 for a conservative estimate. That's your yearly savings potential with SPC. Most manufacturers see payback in under 3 months.

SPC works. It's not magic, it's not complicated, and it doesn't have to be expensive. It's just math applied to manufacturing data in real-time.

The tools exist. Node-RED gets you started, but FlowFuse keeps you running in production. With built-in high availability, your SPC charts stay live even if a server fails. Multiple engineers can work on the same flows without conflicts. Deploy updates to 50 production lines with one click. When downtime costs thousands per hour, you need a platform built for manufacturing.

Start Preventing Defects Today

Every day without SPC is money left on the table. Those 16,000 scrapped parts per year? The warranty claims from undetected drift? All preventable.

Here's your path to production-ready SPC:

Start Free with FlowFuse - Get your instance running in minutes
Follow this tutorial - Build your first SPC chart today
Connect one machine - Start with your most critical measurement
Expand gradually - Add more parameters as you prove value

Don't wait for the perfect plan. Don't form another committee. Pick one measurement that matters and start monitoring it today. Need help getting started? Book a demo to discuss your specific requirements or contact our team for enterprise deployment guidance.

Because somewhere right now, one of your machines is drifting out of spec. The only question is whether you'll catch it in time.

Build Your First SPC Dashboard Now →

References

Six Sigma Online - Statistical Process Control - Background on manufacturers saving thousands with quality control methods
Practical Machinist Forum - Scrap Rates Discussion - Real manufacturer example: 400,000 parts/year with 4% scrap rate
ServiceChannel - Industry Scrap Rate Report - Industry data confirming 4-5% scrap rates are standard
NIST Engineering Statistics Handbook - Statistical Process Control - Official definition and explanation of SPC principles
Walter Shewhart - Wikipedia - SPC creator at Bell Labs in the 1920s

OPC UA Tutorial: Connect and Exchange Data with Industrial Equipment

2025-07-16T00:00:00Z

If you’ve ever tried to connect industrial equipment from different vendors, you know how frustrating it can be, a mess of incompatible protocols, proprietary software, and confusing drivers. Your Siemens PLC speaks one language, your Allen-Bradley controller another, and that Modbus sensor? Yet another protocol entirely.

OPC UA changes that.

OPC UA (Open Platform Communications Unified Architecture) is the industry-standard protocol that eliminates this chaos. Also known as OPC Unified Architecture or IEC 62541, it provides a universal language for secure communication between PLCs, SCADA systems, HMIs, and enterprise applications ,regardless of the manufacturer.

This hands-on guide walks you through building your first OPC UA integration using Node-RED and FlowFuse:

Connect to any OPC UA server—Kepware, MatrikonOPC, or built-in PLC servers
Browse available tags and discover Node IDs from your equipment
Read real-time values from PLCs, sensors, and industrial devices
Write control signals and setpoints back to your systems

Why OPC UA?

If you have worked with industrial equipment, you know the pain. Every PLC vendor uses a different protocol. Your Siemens S7-1500 requires TIA Portal and PROFINET drivers. The Allen-Bradley ControlLogix needs RSLinx and EtherNet/IP. A Modbus temperature sensor needs yet another tool. Before long, you are juggling a dozen different software packages—each with its own licensing, training, and maintenance overhead.

Breaking the Cycle

OPC UA eliminates this fragmentation. Instead of relying on vendor-specific protocols, it provides a universal language for all your equipment. Here is why it is becoming the industry standard:

Universal Connectivity

Connect to any modern PLC using a single protocol. Leading manufacturers like Siemens, Rockwell, Schneider, and ABB now embed OPC UA servers directly into their controllers. One client, all your equipment.

Information, Not Just Data

Reading a temperature value from OPC UA does not just give you "42.5"—it gives the full context: 42.5 °C, measured at 14:32:15.625 with "Good" quality, from "Tank_01/Temperature", and includes alarm limits (10 °C / 80 °C). This context reduces guesswork and helps prevent costly mistakes.

Security Built for Industry

While protocols like Modbus transmit everything in plain text, OPC UA uses enterprise-grade security. It supports X.509 certificates, 256-bit encryption, and robust user authentication to safeguard critical infrastructure from cyber threats.

Future-Proof Investment

OPC UA is the foundation of Industry 4.0 initiatives around the world. It is not just another protocol—it is the one major vendors are standardizing on. Choosing OPC UA today ensures long-term compatibility and ROI.

Getting Started

Now that you understand why OPC UA is widely adopted, let’s explore how to implement it using FlowFuse Node-RED.

This next section walks you through exactly what you need to get started with a working setup, whether for prototyping or production.

What You’ll Need

Before diving into the flow-building process, make sure you have the following:

An OPC UA server (like Kepware, MatrikonOPC, or built into your PLC)
A FlowFuse Node-RED instance running on your edge device.

For production OPC UA deployments, we recommend using FlowFuse. When connecting to industrial systems, you need more than just Node-RED—you need team collaboration so multiple engineers can work on flows safely, audit logs for compliance tracking, high availability to prevent downtime, and remote device management for edge deployments.

FlowFuse provides these enterprise features plus automatic backups, one-click rollbacks, environment variables for different sites, and DevOps pipelines for testing changes before they reach production.

Get started →

Installing OPC UA Support in FlowFuse

To work with OPC UA in FlowFuse Node-RED, you will first need to install the required nodes.

Install the OPC UA Node Package

Open the FlowFuse Node-RED editor.
Click the menu in the top-right and choose Manage palette.
Navigate to the Install tab and search for node-red-contrib-opcua.
Click Install.

Once installed, you will find new nodes for OPC UA communication in your palette, including Client, Item, and Browser and other OPC UA nodes.

Connecting to Your OPC UA Server

To begin accessing industrial data, create a client connection using the OPC UA Client node.

Drag an OPC UA Client node onto the canvas.
Double-click to configure it.
Click the + icon to create a new endpoint configuration.
Enter your OPC UA server address, for example: opc.tcp://192.168.0.10:4840
Set the security mode to None (you can add security later).

Security Note: This tutorial uses "None" for the security setting to keep things simple. In production environments, always use appropriate security—typically "Sign & Encrypt" with certificates.

Click Add, then Done.

OPC UA endpoint configuration

With the connection now defined, you’re ready to explore what tags are available.

Browsing Tags (Optional)

If you do not already know the Node IDs of the tags you want to access, use the OPC UA Browser node to explore the tag structure.

Drag an Inject, OPC UA Browser, and Debug node onto the canvas.
Connect the output of the Inject node to the input of the Browser node, then connect the Browser's output to the Debug node.
In the Browser node, set the topic to ns=0;i=85 (the root Objects folder).
Configure the Inject node to send a timestamp.
Deploy the flow and click the Inject node.

Tag information will be printed to the debug sidebar. You can now identify the exact Node IDs to use in your reads or writes.

OPC UA Browser node

Reading Tag Values

Once you know the Node IDs, you can start reading data from your industrial equipment through the OPC UA server.

Reading a Single Tag

Here’s how to read a single value in real time:

Drag an Inject node onto the canvas (this will trigger the read operation).
Add an OPC UA Item node and configure:
- Node ID: Enter the tag’s identifier (e.g., ns=3;i=1003)
- Data Type: Select the appropriate type (e.g., Boolean)
Connect the output of the Inject node to the input of the Item node.
Add an OPC UA Client node and set its Action to read.
Select the endpoint configuration you created earlier.
Connect the output of the Item node to the input of the Client node, then connect the Client node's top output to a Debug node.

The OPC UA Client node has three outputs: the top carries the data payload, the middle indicates connection status, and the bottom provides raw responses for debugging.

Deploy the flow and click the Inject button to trigger the read.

You should see the tag value appear in the debug panel. This confirms that communication is working correctly.

You can also pass the Node ID dynamically using msg.topic from the Inject node if you prefer not to use an Item node.

Reading Multiple Tags

Batch reading improves performance when you need multiple data points from your equipment

Drag an OPC UA Client node and set its Action to "READ MULTIPLE".

Screenshot showing OPC UA Client node with "READ MULTIPLE" action selected

Select the endpoint configuration.
Add an OPC UA Item node for each tag you want to read.
Add an Inject node for each Item node to trigger it.
Connect each Inject node to its corresponding Item node.
Wire all Item nodes into the OPC UA Client node.
Add a Debug node to the top output of the Client node.
Deploy the flow.
Click each Inject node once, the client node will store the tag definitions.
Send a message with msg.topic = "readmultiple" to trigger the actual read.
To clear stored items, send msg.topic = "clearitems".

You now have a flexible setup for reading multiple values from your PLC on demand.

Writing Values

In addition to reading data, OPC UA also allows you to write control signals or parameters to your equipment.

Writing a Single Tag

To write a single value:

Drag an Inject node onto the canvas (used to trigger the write operation).
Add an OPC UA Item node and configure:
- Node ID: Enter the target identifier.
- Data Type: Choose the appropriate type (e.g., Boolean, Double).
- Value: Enter the value to write.
OPC UA Item node configured for a write operation
Connect the Inject node to the Item node.
Add an OPC UA Client node and set its Action to WRITE.

OPC UA Client node with "WRITE" action selected
Select the endpoint configuration you created earlier.
Connect the Item node to the Client node, then connect the Client node's top output to a Debug node.
Deploy the flow and click the Inject button to trigger the write.

The OPC UA Client node will confirm the operation with a status like "values written".

Writing Multiple Tags

To write multiple values at once, follow this pattern:

Add an OPC UA Client node and set its Action to WRITE MULTIPLE.

OPC UA Client node configured for writing multiple values
Select the appropriate endpoint configuration.
Add multiple OPC UA Item nodes, each configured with a Node ID, Data Type, and Value to be written.
Add an Inject node for each Item node.
Connect each Inject node to its corresponding Item node, then connect all Item nodes to the Client node.
Add a Debug node to the top output of the Client node.
Deploy the flow and trigger all Inject nodes to load the values.
To execute the write operation, send a message with msg.topic = "writemultiple".
To clear the stored items, send a message with msg.topic = "clearitems".

This setup allows you to prepare multiple tag values and write them all at once, giving you precise control through a single command.

What’s Next

You’ve now mastered the fundamentals of OPC UA integration—connecting to servers, browsing tags, and reading or writing data. These core building blocks lay the foundation for powerful industrial automation.

In real deployments, you will want more than Inject nodes and debug panels. With FlowFuse Dashboard 2.0, you can build full operator interfaces—live gauges, control buttons, trend charts—fully connected to your OPC UA data.

This guide covered the basics, but OPC UA offers far more. In the next article, we will explore:

Subscriptions for real-time monitoring without polling
Events and alarms directly from equipment
Historical data queries for trend analysis
Method calls to execute functions on your devices

When it is time to move beyond prototypes, FlowFuse delivers what industrial systems truly need—remote device management, instant rollbacks with full version control, built-in team collaboration, and high availability you can trust.

If you’re ready to simplify your OPC UA integration and scale industrial workflows with Node-RED, start your free trial of FlowFuse today.

Connecting Manufacturing Equipment via Serial Port

2025-07-09T00:00:00Z

Many factories rely on machines, both new and old, that communicate via traditional serial interfaces such as RS-232, RS-422, or RS-485. These machines remain reliable but can be challenging to integrate with modern systems due to their connectivity style.

This blog shows how to use FlowFuse to connect manufacturing equipment to collect data and enable monitoring without modifying the original hardware.

Making Sense of Serial Communication

Before diving into the wiring and flow configuration, it helps to understand how serial communication works—and why it is still relevant in industrial settings.

Serial ports move data one bit at a time, like passing beads on a string. This may sound old-fashioned, but it remains one of the most reliable and predictable ways to connect machines.

Data Direction: Which Way Does It Flow?

Not all serial connections behave the same. The direction of data flow is defined by its duplex mode:

Simplex: One-way only. Like a speaker giving a lecture—the machine talks, you just listen. This is common for devices like weight scales or scanners that only output data.
Half-Duplex: Data can flow in both directions, but only one side can transmit at a time. This is like using a walkie-talkie. It is the most common operational mode for RS-485 (using two wires), where multiple devices share the same communication line.
Full-Duplex: Two-way, simultaneous communication. This is like a phone call—both sides can talk and listen at once. This is the typical mode for RS-232 (using separate transmit and receive lines) and RS-422, which is designed for full-duplex, multi-drop scenarios (one sender, multiple listeners).

Across industrial environments, serial interfaces like RS-232, RS-422, and RS-485 remain prevalent for device communication, depending on the wiring and number of connected devices.

Data Format: How Is It Structured?

Machines are picky—they expect data to arrive in a specific format. Here are the key pieces that make up a serial data frame:

Setting	What It Means
Baud Rate	Speed of transmission (e.g., 9600 or 115200)
Data Bits	The actual data, usually 7 or 8 bits
Parity	Optional error check—even, odd, or none
Stop Bits	Marks the end of each message

Interface Types: How Devices Physically Connect

Different machines use different physical standards. The most common are:

RS-232: Typically full-duplex and one-to-one. Good for short-distance device communication.
RS-422: Full-duplex, multi-drop (one sender, multiple receivers). Used for longer distances than RS-232.
RS-485: Typically half-duplex and multi-device. Ideal for networks and even longer cable runs.
USB (via adapter): Most modern PCs and gateways use USB-to-Serial adapters to talk to RS-232/422/485 devices.

Setting Up Serial Communication with FlowFuse

Now that you understand how serial communication works and what kind of interfaces your machine might use, the next step is to put that knowledge into practice.

Using FlowFuse, you can easily establish serial communication, process the data, and integrate it into dashboards or automated workflows, all without modifying the original hardware.

Let's walk through how to set this up.

Prerequisites

Before we start, ensure the following prerequisites are met:

Hardware Connection: The machine must be physically connected to your system using a serial interface.
Node-RED Instance: Make sure you have an instance of Node-RED up and running. The quickest way to do this is via FlowFuse. If you don't have an account, check out our free trial.
Serialport Node: Install the node-red-node-serialport package if it is not already available in your palette.

Configuring the Serial Port Node

After installing the node-red-node-serialport package, follow these steps to configure serial communication in your Node-RED flow:

Drag a Serial In node from the Node-RED palette onto the canvas.
Double-click the node to open the configuration dialog.
Click the pencil icon next to the Serial Port field to add a new port configuration.
Enter the serial port path (e.g., /dev/ttyUSB0 on Linux or COM3 on Windows). You can also click the search option to list available ports.

Screenshot of Node-RED serial port node configuration showing available serial ports after clicking the search option.

Set the baud rate, data bits, stop bits, and parity according to your machine’s specifications. These values must match the device exactly, or communication will fail or result in corrupted data.
Optionally, define an input delimiter, such as \n or \r, to segment incoming messages if your device sends data in lines or chunks. If the output is fixed-length, you can configure it to wait for a specific number of characters. You can also set a timeout to receive data at regular intervals. Later in the output section, you can choose to add characters back to the message, such as restoring the line break.

Screenshot of input and output settings in the Node-RED serial port node, showing options like delimiter, character count, and timeout.
Click Done to save the configuration.

Once the serial port is correctly configured and the device is connected, the serial in node will show a "connected" status below the node with a small green square.

Screenshot of the Serial In node in Node-RED showing a green square that indicates a successful connection to the serial port.

Writing to Serial Port

To send data to a machine, use the serial out node in Node-RED. This is often necessary to trigger actions such as starting a process, requesting a reading, or changing an internal state.

Follow these steps to send a command:

Drag an inject node onto the canvas.
Set the payload type appropriate to your machine’s requirements. This could be a string, number, raw buffer, or JSON object.
Add a serial out node and select the configured serial port.
Connect the inject node to the serial out node.

Once deployed, clicking the inject button will send the specified data to the machine via the serial interface.

In this guide, we are using a real machine connected via a serial interface. The machine is programmed to simulate a production process when it receives the "START" command (sent as a string). Once triggered, it begins incrementing the count of good and defect products and sends this data back over the same serial connection.

The next section demonstrates how to read and process this simulated production data using the serial in node.

Reading and Processing Serial Data

Follow these steps to read and handle the serial data:

Drag a serial in node onto the canvas and configure it to use the same serial port.
Add a debug node and connect it to the output of the serial in node. This helps you inspect the raw payload and confirm that data is being received correctly.
Once you confirm the format of the incoming data, use any of the change, JSON, or function node to parse and convert it into a structured format, here we have used function.

In our case, the machine sends production data every 2 seconds in the following format:

Screenshot of Node-RED debug panel showing production data sent from the machine every 2 seconds.

To convert this string into a structured JSON object, you can use a function node with the following code:

let parts = msg.payload.trim().split(' ');
let result = {};

parts.forEach(part => {
    let [key, value] = part.split(':');
    result[key.trim()] = parseInt(value);
});

msg.payload = result;
return msg;

This transforms the string into a JSON object like:

{
  "GOOD": 214,
  "DEFECT": 22
}

Tip: You do not need to know JavaScript to use the function node. If you are using FlowFuse, the built-in FlowFuse Assistant can help you write function code using natural language. Simply provide a sample of the data received from your machine and describe the output you expect — the Assistant will generate the function for you.

Handling Request-Response Serial Communication

Not all machines stream data continuously. Some expect a request command, and only then respond with data. In these cases, using a combination of inject, serial out, and serial in nodes can become tricky—especially if you need to match each request with exactly one response. That’s where the serial request node becomes useful.

The serial request node handles this entire pattern for you. Internally, it combines the logic of sending a message and waiting for a single reply, working in a first-in, first-out manner. This means it will only send the next request after receiving a response (or timeout) for the previous one, making it ideal for synchronous devices.

To use it:

Drag a serial request node from the palette.
Double-click to configure the port—use the same path and settings as your other serial nodes.
Connect it to an inject node configured with the command your machine expects, such as "READ" or "STATUS".
On the output side, connect a debug or function node to handle the response.

Each time you trigger the inject, the command will be sent over the serial port, and the response will be delivered to the output—ready to be parsed just like before. This approach is clean, predictable, and removes the guesswork from matching writes with reads.

The output message includes msg.payload containing the response (if any), msg.status with the result status, and msg.port for reference.

This node is especially useful for polling machines that respond with production counts, part IDs, temperature readings, or system status—but only when asked.

Dynamically Managing Serial Ports

In a perfect setup, the serial device is connected, the port is stable, and everything just works. But in practice, hardware is not always so predictable.

For example, You might disconnect and reconnect a USB-to-serial adapter—and now the device shows up as /dev/ttyUSB1 instead of /dev/ttyUSB0. Or maybe you need to temporarily release the serial port to flash new firmware onto an Arduino. In some environments, the port assignment could change on every reboot, making it difficult to hardcode anything.

Rather than redeploying or editing your flow every time, Node-RED gives you a more flexible option: the serial control node.

This node lets your flow adjust serial communication settings on the fly. You can:

Stop the serial connection when needed.
Start it again later.
Even switch to a different port entirely—without touching the Node-RED editor.

All of this happens by sending a simple message to the control node.

To stop communication:

{ "enabled": false }

To start it again:

{ "enabled": true }

And if the port changes or needs reconfiguration, you can send everything in one message:

{
  "serialport": "/dev/ttyUSB1",
  "serialbaud": 9600,
  "databits": 8,
  "parity": "none",
  "stopbits": 1,
  "enabled": true
}

This is especially useful when your flow needs to recover automatically—for example, after a USB reconnection—or if you want to let a user select the correct port from a dashboard interface.

Each time a message is received, the node also outputs the current port configuration. This allows you to log or verify changes as part of your flow—making it easy to track what the system is doing behind the scenes.

In short, the serial control node adds a layer of resilience and flexibility that is often essential in real-world deployments—where devices come and go, ports are never quite consistent, and downtime is not an option.

Key Takeaways

Manufacturing floors often bring together a mix of old and new machines. Among them, many still operate on traditional communication methods that are reliable but difficult to integrate with modern systems. These machines continue to perform their core functions well, but without connectivity, they remain isolated from digital workflows.

With FlowFuse and Node-RED, you can bridge that gap—bringing equipment online without changing or replacing existing hardware. From data collection to triggering actions and monitoring performance, your machines can become part of a connected and intelligent system.

Whether you’re in textiles, precision engineering, or automotive manufacturing, FlowFuse helps you unlock the full potential of your existing equipment. No rip-and-replace needed—just smarter connections. Get in touch with us and start building your serial integration flow today.

How we Built a Smart Manufacturing Order Execution Panel with FlowFuse

2025-07-03T00:00:00Z

A few days ago, I had a conversation with a solution architect about how the lack of integration between the shop floor and business systems often leads to missed opportunities and financial losses. He also mentioned that while many manufacturers want to bridge this gap, they often hesitate — mostly due to concerns about complexity of integration or fear of disrupting existing operations.

But there is no need to be afraid. In this blog, I will walk you through a simple demo that shows how easy it can be to connect production systems with your ERP. With just a small integration, you can improve visibility, avoid manual errors, and prevent unnecessary losses.

To demonstrate this, I built a smart Manufacturing Order (MO) execution panel using FlowFuse, connected to ERP.

Let’s take a closer look.

Demo: Smart Manufacturing Order Execution Panel in Action

In this demonstration, an operator starts by selecting a Manufacturing Order (MO) from a list pulled directly from Odoo ERP. The system immediately checks if enough raw materials are available for that specific order.

If the materials are ready, production begins, and the MO status in Odoo is automatically updated to In Progress. The system then tracks the production count in real time. However, if materials are missing, production won’t start, and the operator is notified instantly. Once the produced quantity matches the target, the system automatically stops the line and marks the MO as Done in Odoo, completing the cycle without manual intervention.

How It Works: Behind the Scenes

To build this system, I used FlowFuse to create a Node-RED flow that connects to Odoo ERP and controls a simulated production line.

System Components

Odoo ERP
Holds Manufacturing Orders, product details, and inventory data. This integration allows for a two-way conversation between the shop floor and the business's core planning system. For a detailed guide on how to read from and write to Odoo, you can read our article, Connect Your Shop Floor to Your ERP – Odoo Edition
FlowFuse
Executes logic such as fetching manufacturing orders, checking material availability, updating statuses, controlling production, and building the operator interface.
Simulated Production Line (Factory I/O)
Acts as the shop floor. Starts and stops production based on FlowFuse commands.
PLC
Receives commands from FlowFuse and controls the actual machinery or simulated production environment.
S7 Protocol (S7Comm)
This is the protocol used to communicate with Siemens S7 series PLCs. We use Node-RED nodes within FlowFuse to send control commands (e.g., start/stop production) and read critical data (e.g., produced quantity, machine status) directly from the PLC’s memory blocks. To learn exactly how to set this up, check out our step-by-step tutorial, Getting Started: Integrating Siemens S7 PLCs with Node-RED

Below is the full Node-RED flow that powers this smart manufacturing execution panel.

Workflow Breakdown

sequenceDiagram
    participant Operator
    participant FlowFuse
    participant Odoo
    participant PLC
    Operator->>FlowFuse: Select MO
    FlowFuse->>Odoo: Fetch MO details
    Odoo-->>FlowFuse: Return MO + Material info
    alt Materials Available
        FlowFuse->>Odoo: Update MO to "In Progress"
        FlowFuse->>PLC: Start production
        loop While producing
            PLC-->>FlowFuse: Report produced quantity
        end
        FlowFuse->>PLC: Stop production
        FlowFuse->>Odoo: Update MO to "Done"
    else Materials Not Available
        FlowFuse-->>Operator: Notify: Cannot start
    end

Fetch Manufacturing Orders
The system pulls a list of confirmed or in progress MOs from Odoo using HTTP requests with help of Odoo node.
Check Raw Material Availability
When an operator selects an MO, FlowFuse checks if enough raw materials are available in Odoo.
Start Production
If materials are available:
- The MO status is updated to In Progress
- The simulated line starts producing
Track Quantity in Real Time
As the line runs, FlowFuse keeps track of the produced quantity.
Stop and Complete the MO
When the produced quantity matches the MO target:
- FlowFuse sends a stop command to the PLC
- The MO status in Odoo is updated to Done

Why This Matters for Business

This demo might seem simple, but it solves some of the most common and expensive problems on the shop floor. Think about the daily headaches: an operator starts a big job, only to find out halfway through that a key material is missing, forcing the entire line to stop. Or, they produce 10% more than the order required, creating waste that just sits in inventory.

This smart panel is designed to prevent those exact scenarios. By connecting your production line directly to your business systems, it:

Prevents material shortages by automatically checking for raw materials before a job can even start.
Eliminates overproduction by stopping the line the moment the target quantity is hit.
Gets rid of manual data entry by instantly updating the order status in the ERP.

This means managers get a live, accurate view of what’s happening on the floor, not data from hours ago. The best part is that you don't need to overhaul your entire operation or buy a huge, complex system to get these benefits. A smart, focused integration like this can deliver real results, quickly.

Ready to Connect Your Shop Floor?

This demo shows how even a small, targeted integration between your production line and ERP can eliminate manual errors, reduce waste, and improve visibility — without overhauling your entire system.

If you are exploring how to bring these kinds of improvements to your manufacturing operations, let’s talk.

We’d be happy to discuss how FlowFuse can help you build custom, scalable solutions tailored to your factory’s needs.

👉 Get in touch with us

FlowFuse 2.19: More Powerful AI in Node-RED, Drop-In Blueprints, Memory Monitoring, and Faster Onboarding

2025-07-03T00:00:00Z

This release focuses on speeding time to value with more powerful AI functionality within Node-RED, along with reducing friction for new users while enhancing the experience for existing users through improved Blueprint functionality, comprehensive performance monitoring, and a modernized interface that reflects FlowFuse's evolution.

AI Enhancements to Node-RED

GIF of AI Flow Explainer

The FlowFuse Assistant can now do more than create a Function node based on your text instructions. With this release, you can highlight a flow in the Node-RED editor and ask the FlowFuse Assistant to explain the purpose of the flow. This new functionality is perfect for learning and collaboration.

You can also use the FlowFuse assistant to create Dashboard templates with HTML, VUE, Vuetify, and CSS, allowing you to build even faster.

Stay tuned for more developments as we continue to add enhancements to the Node-RED editor in FlowFuse to enable even faster development.

Comprehensive Performance Monitoring

Screenshot of Memory Monitoring Building on our existing CPU monitoring capabilities, we've added memory usage tracking to the Performance feature. This enhancement provides:

Complete visibility into both CPU and memory utilization
Better understanding of instance resource consumption
More informed decision-making for scaling and optimization

With these features, you can now get a holistic view of your instance performance and make informed decisions about resource allocation.

Add Blueprints to Existing Instances

Screenshot of Blueprint Import

Previously, Blueprints could only be used when creating new instances. Now you can import Blueprints into existing instances, making them much more versatile. Blueprints now appear as an option in the Import menu.

And if you're running Node-RED version 4.1, when you select a Blueprint to import that uses nodes not in your current palette, it will offer to install them automatically.

This change transforms Blueprints from a one-time instance creation tool into a constantly useful resource to speed your development with Node-RED.

Screenshot of Google Signin

To make it easier than ever to create a FlowFuse account, we've introduced social sign-in options that allow users to create FlowFuse Cloud accounts using their Google credentials.

This enhancement removes multiple steps from the onboarding process, making it significantly easier for new users to get started with FlowFuse.

Enhanced Device Agent Flow Selection

Connecting your existing Node-RED instances running on remote devices is now even easier with the new Device Agent terminal file browser. When installing the Device Agent, you can now easily navigate your file system and select existing Node-RED instances through an interactive interface directly in the terminal.

This improvement replaces the previous manual file path entry process with:

An intuitive file browser that works directly in your terminal
Easy navigation through your file system to locate flows
Contextual information about flows including file size and modification dates
A streamlined selection process that reduces setup friction

Modernized User Interface

Screenshot of Homepage

The FlowFuse user interface was due for a restructuring in light of what users are looking for, along with a visual touchup. This release introduces a dedicated landing page that focuses on what we've learned users want to do when they first access FlowFuse. The new homepage provides:

Direct access to relevant hosted and remote instances
Smart prioritization based on recent activity and deployments
Prominent display of issues requiring attention (performance alerts, errors)
Recent team activity overview through audit log integration
Improved layout and visual hierarchy
Updated color scheme and styling

These changes make it easier to find what you are looking for within FlowFuse, address issues that may arise, and creates a more pleasant workspace.

What's Next?

Our development team continues to focus on AI integration and workflow optimization. The upcoming releases will build on these foundational improvements while introducing more intelligent automation and development assistance features.

We're also working on expanding our Blueprint library and improving the overall development experience within the Node-RED editor, with several exciting features planned for the coming months.

What else is new?

For a complete list of everything included in our 2.19 release, check out the release notes.

Which of these new features are you most excited to try? Email me directly at greg@flowfuse.com - I'd love to hear from you!

Try FlowFuse

FlowFuse Cloud

The quickest way to get started is with FlowFuse Cloud.

Get started for free and have your Node-RED instances running in the cloud within minutes.

Self-Hosted

Get FlowFuse running locally in under 30 minutes using Docker or Kubernetes.

Curated Node-RED Integrations: FlowFuse Certified Nodes 2.0

2025-07-01T00:00:00Z

At FlowFuse, we believe that enterprises deserve access to the best of Node-REDs custom nodes and solutions crafted by recognized experts who bring deep domain knowledge and professional standards to their work. That's why we are thrilled to announce a significant evolution of our ecosystem: FlowFuse Certified Nodes v2.0.

From Community Contribution to Professional Partnership

The Node-RED community has always had a pasionate and thrived on the domain-expertise of its developers. The community has created an environment of innovation, and now we're taking the next step to support enterprise-grade solutions that companies are building on Node-RED today.

Our new Certified Nodes program we hope to elevate the community. We are establishing a professional partnership with the most skilled node developers and domain experts in the community.

Here’s how it works:

Expertise Recognition: FlowFuse partners with developers who have demonstrated deep expertise in their domains, and may have already published nodes in their area of expertise. Ensuring our enterprise customers access the most knowledgeable contributors in each field.
Quality-Driven Selection: Our certification process identifies nodes that excel in real-world environments, focusing on reliability, security, up-to-date documentation and professional implementation standards.
Comprehensive Solutions: We welcome both open-source innovations and proprietary solutions. This approach allows experts to share their knowledge broadly while also providing targeted solutions for specific industry needs.

What Does It Take to Become a Certified Publisher?

We are seeking partners who represent the pinnacle of expertise in their respective domains. To join our certified ecosystem, we look for developers who demonstrate:

Domain Expertise: Deep knowledge and proven experience in the specific technology or industry vertical their nodes address
Professional Standards: Commitment to enterprise-grade code quality, comprehensive testing, and security best practices
Continuous Innovation: Ongoing development and enhancement of features that solve real-world enterprise challenges
Expert Support: Ability to provide advanced technical support and guidance that goes beyond basic troubleshooting

Our certification process ensures that every node in the certified nodes ecosystem meets these exacting standards. When enterprises choose certified nodes, they gain access not just to code, but to the expertise and ongoing support of recognized industry professionals. This creates a sustainable model where expert knowledge is properly valued and enterprises receive the reliability they require.

Why Partner with FlowFuse?

Joining the FlowFuse Certified Nodes v2.0 program means becoming part of an elite community of experts. Moreover, there's now a financial reward for doing so. FlowFuse commits a fixed percentage of our FlowFuse Enterprise Platform Fee to be distributed quarterly to the node authors.

If you are an expert developer or organization that has built exceptional Node-RED nodes and are committed to maintaining the highest professional standards, we want to collaborate with you. Let's work together to create a more sustainable, professional ecosystem that connects enterprise users with the industry's leading experts.

Contact us to discuss your node certification

Part 2: Building an Andon Task Manager with FlowFuse

2025-06-26T00:00:00Z

In Part 1, we introduced the concept of an Andon Task Manager—designed to streamline issue reporting and resolution on the factory floor—and outlined the system’s key features, user roles, and dashboard layout.

In this part 2, we move from planning to implementation. The focus now shifts to building the actual system using FlowFuse Dashboard (Node-RED Dashboard 2.0), hosted on the FlowFuse platform. We will begin by developing the Lines view for regular users, along with a line selection menu. The Department View and Admin interface will follow in a later part of the series.

Getting Started

To simplify the development process, the implementation is divided into the following key sections:

Initialize SQLite Database
Seed Demo Data: Departments & Lines
Build Line Selection Menu
Enable URL-Based Dashboard Access
Create Live Request Fetch Flow (Per Line)
Render Request Data in a Table
Setting Up Visual Alerts and Timestamp Formatting
Highlight Requests with CSS & Add Buttons to Update Request Status
Create New Request Submission Flow

Before proceeding, a basic understanding of Node-RED is recommended. If you are new to Node-RED, consider going through this free Node-RED Fundamentals Course to get started.

Tip: Organize your flows into clearly defined groups. For reference, images of each flow are provided. Please use the exact names given to each flow—this will help ensure consistency and make it easier to navigate back to specific flows when referenced later.

Prerequisites

Before you begin building the Andon Task Manager with FlowFuse, make sure you have the following:

Running FlowFuse Instance: Make sure you have a FlowFuse instance set up and running. If you don't have an account, check out the free trial and learn how to create an instance.
@flowfuse/node-red-dashboard: Ensure you have FlowFuse Dashboard (also known as Node-RED Dashboard 2.0 in the community) installed.
SQLite Contrib Node: Install node-red-contrib-sqlite to handle local data storage.
FlowFuse Multi-user Andon: Install @flowfuse/node-red-dashboard-2-user-addon to enable multi-user support.
Enable FlowFuse User Authentication: Enable FlowFuse User Authentication on your FlowFuse instance.
Moment Contrib Node: Install node-red-contrib-moment for date and time formatting.

Initialize SQLite Database

The first step is to set up a database to store requests and their updates.

Drag an Inject node onto the canvas and configure it to trigger on Deploy, after a delay of 0.1 seconds.
Drag an SQLite node onto the canvas. Double-click and click the + icon to add a new database configuration.
Give the database a name and set the mode to Read-Write-Create. Click Add to save.

Set SQL Query to Fixed statement and enter:

CREATE TABLE IF NOT EXISTS requests (
  rowid INTEGER PRIMARY KEY,
  line TEXT NOT NULL,
  support TEXT NOT NULL,
  requested TEXT NOT NULL,
  acknowledged TEXT,
  resolved TEXT,
  notes TEXT
);

Connect the Inject node to the SQLite node.
Click Deploy.

Flow to initialize the SQLite database and create the requests table.

Once deployed, this will create the SQLite database and requests table if it does not already exist.

Seed Demo Data: Departments & Lines

As discussed in the planning section, only the admin role will have the ability to add new departments and lines. Since the admin feature is not yet available, we will populate demo data using a predefined flow to allow ourself to test the application while the standard user interface is being developed.

Import the provided demo flow.
Deploy the flow.

This will store demo lines and departments in the global context as global.lines if not already present.

Now, let us create a new page and menu item for Production Lines. This page will list all currently available production lines, making it easier to navigate through them.

Drag a ui-event node onto the canvas to detect page navigation.
Drag a change node and configure it to:
- Set msg.payload.lines to global.get("lines")
Drag a ui-template node onto the canvas. Create a new page with name “Line Menu” and a group.
Paste the following into the template:

<template>
  <v-container>
    <v-row>
      <v-col>
        <h3>Production Lines</h3>
      </v-col>
    </v-row>

    <v-row class="scrollable-row" no-gutters>
      <v-col v-for="(btn, index) in lines" :key="index" cols="auto">
        <v-btn :href="`/dashboard/lines?line=${btn.value}`" class="custom-btn" rounded>
          
        </v-btn>
      </v-col>
    </v-row>

    <v-alert v-if="selectedLine" type="success" class="mt-3">
      Selected Line: 
    </v-alert>
  </v-container>
</template>

<script>
export default {
  data() {
    return {
      selectedLine: '',
      lines: []
    };
  },
  methods: {
    updateButtonContent(data) {
      this.lines = (data.lines || []).sort((a, b) => a.label.localeCompare(b.label));
    }
  },
  mounted() {
    this.lines = [];
    this.$socket.on('msg-input:' + this.id, (msg) => {
      this.updateButtonContent(msg.payload);
    });
  }
};
</script>

<style scoped>
.scrollable-row {
  display: flex;
  overflow-x: auto;
  padding: 10px 0;
  flex-wrap: wrap;
}
.scrollable-row .v-col {
  flex-shrink: 0;
  margin-bottom: 10px;
}
.scrollable-row {
  min-height: 60px;
}
.custom-btn {
  background-color: rgb(32, 44, 52) !important;
  color: white !important;
  margin-right: 12px;
  padding: 8px 16px;
}
.custom-btn:hover {
  background-color: rgb(54, 70, 86) !important;
}
</style>

Deploy the flow.

Once deployed, the dashboard will show buttons for each production line. Clicking a line redirects the user to a page with following url:

https://<your-instance-name>/dashboard/lines?line=T1

Node-RED flow to create a dynamic menu for production lines on the dashboard.

Dashboard view showing production line buttons generated from the flow.

The "line" URL parameter will be used in the next section to store the user's selected production line.

Enable URL-Based Dashboard Access

In this section, we’ll build a flow that allows users to directly access the dashboard using a URL with a line parameter (e.g., ?line=T1). The flow will validate this parameter and store the selected line for each user session. If the parameter is missing or invalid, the user will be redirected to a Not Found page.

To achieve this, we need to:

Configure the dashboard to expose client-specific metadata.
Create a flow that validates the line parameter from the URL.
Store the user’s selected line using session-aware context data.

Configuring Dashboard Widgets to Include Client Information

To ensure client data is available in your flows, follow these steps:

Open the Dashboard 2.0 sidebar.
Switch to the Client Data tab.
Enable the option “Include client data”.
Tick the checkbox in front of:
- ui-control
- ui-template
- ui-button
- ui-text-input
- ui-dropdown
- ui-notification
Deploy the updated configuration.

Dashboard 2.0 settings to include client metadata from selected widgets like buttons and templates.

With this setting enabled, the selected widgets will include client-related metadata in their output messages under the msg._client property. This metadata is essential for building session-aware features in the Dashboard.

Building a Dashboard Flow for URL Access, Line Validation, and User Selection

In this section, we'll build a Node-RED flow that handles dashboard access via direct URLs, validates the line parameter, and stores the selected line per user session using client metadata. This ensures that each user's line selection is tracked independently and that invalid or missing parameters are handled gracefully.

The flow performs the following key tasks:

Detects when a user accesses the dashboard using a URL containing a line parameter.
Validates the parameter against a list of predefined production lines.
Stores the selected line using session-aware (client-specific) data.
Redirects the user appropriately based on the validity of the parameter.

Steps to Build the Flow:

Drag a ui-event node onto the canvas and configure it with the correct UI base path.
Drag a switch node and name it "Is it a pageview event?" and configure it with the property msg.topic and add the following condition:
- == $pageview
Drag another switch node and name it "Has line key?" and configure it with the property msg.payload.page.params.line, with two conditions:
- has key line
- is empty
Connect the ui-event node to the first switch node (labeled Is it a pageview event?). Then, connect the first output of this switch node to the second switch node (labeled Has line key?). This checks whether the page was accessed via URL and if a line parameter is present.

Drag a function node and name it "Extract Labels from Lines" and paste the following code:

let lines = global.get('lines', 'persistent') || [];
let labels = [
   ...lines.map(obj => obj.label),
];
msg.payload.labels = labels;
return msg;

This retrieves the list of available lines from the persistent global context, extracts their labels, and creates an array for easier verification of whether the user selected line is present.

Drag a change node and name it "Store line selection":
- Set global.store[msg._client.socketId].line to msg.payload.
Drag another switch node and name it "Is the currently accessed page 'Lines'?":

is equal to "Lines"

Connect the function node (Extract Labels from Lines) and the change node (Store line selection) to the first output of the switch node (Has line key?).
Drag another switch node and name it "Is line valid?" and set the property to msg.payload.labels and add following conditions:
- contains global.store[msg._client.socketId].line
For the first output of the switch node (Is the currently accessed page 'Lines'?), drag a change node and name it "Redirect the user to the All Lines menu" and Configure it to:
- Set msg.payload to "All Lines"
Drag a ui-control node onto the canvas and connect it to the change node (Redirect the user to the All Lines menu). This node will handle the redirection or display feedback on the dashboard.

This checks whether the selected line is valid by comparing it with the list of known line labels.

For the second output of the switch node (Is line valid?), drag a switch node and give it name "Is the currently accessed page 'Lines'?" and Set property to msg.payload.page.name and add following condition to check against:

== "Lines"
Otherwise

For the first output of the switch node ((Is the currently accessed page 'Lines'?), drag a change node and configure it to: - Set msg.payload to "Incorrect Link"
Drag a ui-control node onto the canvas and configure it with the correct UI base path and connect it the change node (Redirect to Not found page).
Deploy the changes.

Flow for managing URL-based access, validating line parameters, and storing client-specific selections on the OEE dashboard.

Create Live Request Flow (Per Line)

Let’s build the flow to retrieve the data now based on the user selection.

Drag a Template widget onto the canvas.
Double-click the Template widget to open its configuration.
Set the scope to ui and select the appropriate UI Base.

Paste the following script into the content field. This script triggers every second and sends a message that includes the current user's client data:

<script>
  export default {
    mounted() {
      // Set an interval to update the message every second
      this.intervalId = setInterval(() => {
        this.send('Component has loaded');
      }, 1000);
    },
    beforeUnmount() {
      // Clear the interval when the component is about to be destroyed
      clearInterval(this.intervalId);
    },
  };
</script>

Drag a Change node and name it "Set params".
Configure the Change node with the following rules:
- Set msg.params.$line to global.store[msg._client.socketId].line
- Set msg.query to "line"
Drag a Template node onto the canvas.
Double-click the Template node and set the property to msg.topic.

Paste the following SQL query into the content field:

SELECT * FROM requests WHERE "" = "" AND resolved IS NULL

Drag a Markdown widget and name it "Show currently selected line".
Create a new group in the UI for the Markdown widget to render into.
Enter the following content into the Markdown widget:
```
<h1 style="text-align: center;">Line: </h1>
```

The dashboard displays the selected production line name, retrieved from the client context, rendered using a Markdown widget.

Drag a SQLite node onto the canvas.
Select the appropriate database configuration.
Set the node to use the SQL query via "Prepared Statement".
Connect the Template widget to Change node and Template node to SQLite node.
Drag a link-out node onto the canvas and connect it to the SQLite node.
Deploy the changes.

Flow that triggers periodic queries for open requests specific to the user’s selected line using the client session and a SQLite database.

Preparing Data Rendering it in a Table

Once the data is retrieved, it needs to be validated, formatted, and routed appropriately for display. In this section, a flow will be built to check whether any unresolved requests exist for the selected production line. If there are no requests, a message will be shown to the user. Otherwise, the data will be processed and rendered in a table format using Dashboard widgets.

Drag a link-in node onto the canvas and connect it to the last link-out node.
Add a switch node to check whether the msg.payload is empty, name it "Is Payload empty?".
- Configure the switch with the following conditions:
  - msg.payload is empty
  - Otherwise
Drag a change node, name it "Show 'no outstanding request' message" and configure it to set a message when the payload is empty:
- Set msg.payload to "There are no outstanding requests"
Connect this change node to the first output of the switch node ("Is Payload empty?").
Drag another change node, name it "Remove 'no outstanding request' message" and configure it as follows:
- Set msg.payload to an empty string ""
Connect this second change node to the second output of the switch node ("Is Payload empty?").
Drag a text widget, name it "Text Widget for Message", onto the canvas, double-click it, and add a new group in the "Lines" page to render the message.
Connect the text widget ("Text Widget for Message") to both change nodes that are setting the text message ("Show 'no outstanding request' message" and "Remove 'no outstanding request' message").
Drag another link-out node onto the canvas and connect it to the second output of the switch node ("Is Payload empty?") that checks whether msg.payload is empty.
Drag another link-in onto the canvas.
Drag a split node, name it "Split Node", onto the canvas and connect it to the link-in node.
Drag a link-out node and connect it to the split node.
Deploy the changes.

Flow that checks if unresolved requests exist, sends an appropriate message when none are found, or prepares the data for tabular rendering.

Setting Up Visual Alerts and Timestamp Formatting

To enhance the visibility of production line requests, this section focuses on setting up visual alerts based on the age of each request and formatting timestamps in a user-friendly way. The created timestamp is always shown using relative time (e.g., "5 minutes ago"). For acknowledged and resolved, relative formatting is applied only when those timestamps are available. This improves readability and makes it easier to identify requests that are pending action.

Drag a link-in node and a function node onto the canvas. Name the function node as "Highlight Old Requests" and open it.
Paste the following JavaScript code into the function node:

const requested = msg.payload.requested;
const now = Date.now();

const requestedTime = new Date(requested).getTime();
const difference = now - requestedTime;

const oldRequestThreshold = global.get('oldRequestThreshold');
const veryOldRequestThreshold = global.get('veryOldRequestThreshold');
const alertActivationThreshold = global.get('alertActivationThreshold');

if (difference > (veryOldRequestThreshold * 60 * 1000)) {
   msg.payload.class = 'older';
   if (difference > (alertActivationThreshold * 60 * 1000)) {
       msg.payload.alert = true;
   }
   return msg;
}
else if (difference > (oldRequestThreshold * 60 * 1000)) {
   msg.payload.class = 'old';
   if (difference > (alertActivationThreshold * 60 * 1000)) {
       msg.payload.alert = true;
   }
   return msg;
}
else {
   if (difference > (alertActivationThreshold * 60 * 1000)) {
       msg.payload.alert = true;
   }
   msg.payload.class = 'normal';
   return msg;
}

Connect the link-in node to the function node.
Drag a date time formatter node onto the canvas. Name it "Format Requested Time" and double-click it to configure.
- Set outputFrom to fromNow.
- Set both input and output to msg.payload.requested.
Connect the function node to the date time formatter node.
Drag a link-out node and connect it to the function node.
Drag a switch node onto the canvas. Name it "Check if Acknowledged is null". Set the property to msg.payload.acknowledged, and add the following conditions:
- is null
- Otherwise
Connect the function node to the switch node.
Drag a second date time formatter node onto the canvas. Name it "Format Acknowledged Time".
- Set outputFrom to fromNow.
- Set both input and output to msg.payload.acknowledged.
Connect the second date time formatter node to the second output of the switch node ("Check if Acknowledged is null").
Drag another switch node onto the canvas. Name it "Check if Resolved is null". set the property to msg.payload.resolved. Add the following conditions:

is null
Otherwise

Connect this switch node ("Check if Resolved is null") to the output of the second date time formatter ("Format Acknowledged Time") node and to the first output of the first switch node ("Check if Acknowledged is null").
Drag a third date time formatter node onto the canvas. Name it "Format Resolved Time" and set outputFrom to fromNow. Set both input and output to msg.payload.resolved.
Connect this third date time formatter node to the second output of the second switch node ("Check if Resolved is null") .
Drag a link-out node and connect it to the third date time formatter node.
Drag another link-out node and connect it to the first output of the second switch node. Name it "Link to First Switch Output".
Deploy the changes.

Dashboard showing a request visually highlighted based on how long ago it was made, with applied styling and alert classification.

Flow for setting visual alert classes and formatting timestamps like "5 minutes ago" to enhance clarity and urgency of displayed requests.

Highlight Requests with CSS & Add Buttons to Update Request Status

We have the data prepared, the class property added to each request message, and the timestamp formatted for better readability. In this section, we will add 'Resolve' and 'Acknowledge' buttons for each request to update its status and apply CSS classes based on the status property for visual highlighting.

Drag a link-in node onto the canvas and connect it to the last link-out node.
Drag a switch node, name it "Is acknowledged null?", and set the property to msg.payload.acknowledged. Add the following conditions:
- is null
- otherwise
Drag a template node, name it "Build ack link", set the property to msg.payload.acknowledged, and add the following Mustache:
```
<a href="/dashboard/lines?line=&action=ack&request=" style="color: #000000" class="">ACKNOWLEDGE</a>
```
Connect the link-in node to the switch node. Connect the first output of the switch node ("Is acknowledged null?") to the input of the template node.
Drag another switch node, name it "Is resolved null?", set the property to msg.payload.resolved, and add the following conditions:
- is null
- otherwise
Drag a template node, give it name "Build res link", set the property to msg.payload.resolved, and add the following Mustache:
```
<a href="/dashboard/lines?line=&action=res&request=" style="color: #000000">RESOLVE</a>
```
Connect the input of this second switch node ("Is resolved null?") to the second output of the previous switch node (acknowledged switch), then connect the first output of the resolved switch node to the input of the second template node.
Drag a link-out node and connect both outputs of the resolved switch node to this link-out.
Deploy the changes.

Adding action buttons to update the status of each request directly from the dashboard table.

Adding a Mechanism to Update the Status of a Request in the Database

Drag ui event widget onto the canvas and configure it with the correct ui base.
Drag change node onto the canvas and add the following element:
- Set msg.params to {}
- Set msg.params.$request to msg.payload.query.request
Drag Date/Time Formatter node onto the canvas and set input format to "timestamp: milliseconds since epoch" and output to msg.now.
Drag switch node onto the canvas, set property to msg.query.action, and add the following conditions to check against:
- == ack
- == res
- otherwise
Drag two SQLite nodes onto the canvas, select the correct database configuration for both, and set the query type to 'Prepared Statement'.

For the first, set the following sql query:

UPDATE requests 
SET acknowledged = $now
WHERE rowid = $request 
AND acknowledged IS NULL

For the second, set the following sql query:

UPDATE requests 
SET resolved = $now
WHERE rowid = $request 
AND resolved IS NULL

Connect the ui event widget to change node, change node to date/time formatter node, date/time formatter to switch node, and:

switch node first output to first first sqlite node
switch node second output to second second sqlite node

Flow that handles the update of request status based on user actions (Acknowledged or Resolved).

Render Request Data in a Table

Now, let's display the prepared data in a table. To do this, we'll use a ui_table widget. However, before displaying, we need to convert the data back into an array, as we are currently spilling array data retrieved from the database into a single message.

Drag a link-in node onto the canvas and connect it to the last link-out node.
Drag a join node onto the canvas and connect it to the link-in node. Double-click on the join node and set the mode to automatic.
Drag another link-out node and connect it to the join node.
Drag a link-in node and connect it to the last link-out node.
Drag a ui_table widget onto the canvas and double-click to configure.
Create a new group on the lines page.
Set Action to replace and Interaction to none.
Untick the Auto Calculate Columns option.
Add the following column elements:
- Key: rowid, Label: Request, Align: Left, Type: Text
- Key: line, Label: Line, Align: Left, Type: Text
- Key: support, Label: Support, Align: Left, Type: Text
- Key: requested, Label: Requested, Align: Left, Type: HTML
- Key: acknowledged, Label: Acknowledged, Align: Left, Type: HTML
- Key: resolved, Label: Resolved, Align: Left, Type: HTML
- Key: notes, Label: Notes, Align: Left, Type: Text
Deploy the changes.

Render Data on table.

Create New Request Submission Flow

To create a flow that allows users to submit a request, follow these steps to set up the necessary UI elements, store the request details, validate input, and store the data in a database.

Drag the ui-event widget onto the canvas and configure it with the correct UI settings.
Drag a change node to retrieve the department list and name it "Show Dropdown Options". Add the following:
- Set msg.ui_update.options to global.departments.
Create a new group for the dropdown widget on the lines page. Connect the change node to the input of the dropdown widget, then link it to the ui-event node.
Drag another change node and set msg.payload to msg.store[msg._client.socketId].support. Name it "Store support (department) to context store".
Drag a text input widget for the notes field. Create a group for it in the lines page.
Add another change node to store the notes in the global context and name it "Store notes to context store":
- Set msg.payload to msg.store[msg._client.socketId].notes.
Connect the change node ("Store support (department) to context store") to the input of the dropdown widget and connect the change node ("Store notes to context store") to the text input widget.
Drag the button widget, label it "Request Support," and connect it to the change node that updates the UI with the department list.
Add a change node to store the request details in the global context and name it "Retrieve entered support request data":
- Set msg.request to {}.
- Set msg.request.support to the value msg.store[msg._client.socketId].support.
- Set msg.request.notes to the value msg.store[msg._client.socketId].notes.
- Set msg.request.line to the value msg.store[msg._client.socketId].line.
- Set msg.request.reference to the value msg.store[msg._client.socketId].reference.
Drag the switch node onto the canvas and set property to msg.request and add condtion to check "is not null".
Drag a function node and add the following code. Name it "Does department and notes are not empty?":

let request = msg.request;
if (typeof request !== "object" || request === null) {
   msg.payload = "Request must be an object.";
   return [null, null, msg];
} else if (!request.hasOwnProperty("support")) {
   msg.payload = "Please select the appropriate department for the request.";
   return [null, msg, null];
} else if (!request.hasOwnProperty("notes") || typeof request.notes !== "string" || request.notes.trim() === "") {
   msg.payload = "Please add notes to provide more context on the request.";
   return [null, null, msg];
} else {
   return [msg, null, null];
}

Connect the change node to switch node and switch node to function node. Connect the function node's first output to a Date/Time Formatter node. Set the input to 'Timestamp (milliseconds since epoch)' and the output to msg.request.time.
Drag a change node and set msg.payload to "Are you sure you want to submit a request?". Name it "Set Confirmation message".
Connect the change node ("Set Confirmation message") to the Date/Time Formatter node.
Drag a ui-notification widget, configure it with the correct UI, and set the position to center, checked the checkbox for both allow mnaual dismisal and all amnual confirmation, change close to "Cancel".
Connect the change node ("Set Confirmation message") to the ui-notification widget.
Drag another ui-notification widget, configure it with the correct UI, and set the position to center.
connect it to the second output of the function node.
Add a switch node and set the property to msg.payload with the condition:

== confirm_clicked Name it "Is confirm clicked?"

Drag a change node and add the following elements and give it name "Set Params":

Set msg.params to {}.
Set msg.params.$line to the value msg.request.linet.
Set msg.params.$support to the value msg.request.support.
Set msg.params.$time to the value msg.request.time.
Set msg.params.$notes to the value msg.request.notes.

Connect the change node ("Set Params") to the switch node ("Is confirm clicked?").
Drag a sqlite node, select the correct database configuration, and choose SQL Query via "Prepared Statement" and connect that sqlite node to the input change node ("Set Params")
Drag a change node and set the following, give it name "Clear entered request data":

Delete msg.store[msg._client.socketId].support.
Delete msg.store[msg._client.socketId].notes.

Connect the change node* ("Clear entered request data") to the sqlite node.
Drag a link-out node and connect it to the last change node.
Drag a link-in node and connect it to the last link-out node.
Drag two change nodes and configure them as follows:

First change node: Set msg.payload to an empty array [].
Second change node: Set msg.payload to an empty string "".

Connect the change nodes to the link-in node to complete the flow.
Connect the first change node to the ui dropdown widget and the second to the text input widget.
Deploy the changes.

Node-RED flow to handle request submission, including form validation, timestamp formatting, and SQL database insertion.

We have now successfully built one part of the Andon task dashboard. You can open the line view in the dashboard and check whether you can submit a request, mark it as acknowledged, and resolve it.

Dashboard UI where users select a department, enter notes, and submit a support request for the production line.

Up Next

Up until now, the focus has been on building the core functionality of the Andon Task Manager dashboard, including the Lines page. Design and layout have not been the priority. In the next part, you will learn how to enhance the visual design, improve usability, and create a dedicated page and menu for departments.

Later, we will guide you through building the Admin page for the Andon Task Manager dashboard—enabling request management, department configuration, and overall system control.

What to Measure on the Shop Floor: Factory KPIs Your MES Should Deliver

2025-06-20T00:00:00Z

When discussing an MES, data is always at the core. In previous articles, we explored the crucial steps of collecting and structuring valuable operational data. However, merely having cleaned and structured data is not enough. Many manufacturers find themselves staring at thousands of records while trying to monitor equipment performance or track production, only to feel overwhelmed and unsure of what actions to take. This is not just time-consuming; it often leads to delayed decisions and missed opportunities.

It is not the volume of data that drives improvement, it is clarity. What manufacturers need is a way to cut through the noise and highlight what truly matters. Factory KPIs (Key Performance Indicators) do exactly that. By focusing attention on the metrics that reflect performance and progress, they turn complexity into clarity and enable faster, more confident decisions.

In this article, we will dive into the most critical factory KPIs that directly impact your bottom line and are a fundamental part of any effective MES implementation. These KPIs empower you to drive profit and eliminate waste.

Strategic KPI Categories for MES Success

There are hundreds of factory KPIs available, but not all are relevant for every MES implementation. To effectively leverage MES and improve factory operations, it is important to organize KPIs into logical categories that support its core objectives. These categories provide a holistic view of factory performance and align operational data with key manufacturing goals.

While many KPIs can be tracked, the most impactful ones in the context of MES typically fall into the following strategic categories:

Productivity: Measuring the efficiency and output of production lines.
Processes: Assessing how reliably the production chain functions.
Deadlines: Tracking time-related performance metrics.
Inventory Management: Ensuring materials and products flow smoothly.
Resources: Evaluating equipment reliability and effectiveness.
Quality: Measuring consistency, conformance, and product standards.

Key Factory KPIs

Here are some of the most crucial KPIs your MES should help you track:

KPIs Tables

Turning Your Data into KPIs

Now that you understand the critical factory KPIs, the next logical question is: How does your MES deliver these insights? It’s not about manual calculations or picking up a calculator. The MES should have an integrated pipeline that handles everything—from raw data collection to the clear, actionable KPIs displayed on your dashboards.

Once the data is collected and stored from the factory floor, this pipeline involves four essential stages:

Retrieve Data: Pull the necessary stored data from the central database to perform KPI calculations.
Build Logic: Define the rules, conditions, and formulas based on operational goals and KPI definitions.
Calculate KPIs: Execute real-time or scheduled computations to derive metric values from the retrieved data.
Visualize: Display the results using dashboards to provide clear insights for operators, supervisors, and decision-makers.

Once the workflow is set up, it should run automatically in the background—pulling in fresh data, applying the logic, and updating dashboards in real time. This ensures that performance metrics are always current and actionable.

Building KPI Workflow with FlowFuse

To turn stored factory data into live KPIs, you need a solution with a powerful logic engine capable of processing at scale. Ideally, this solution should also support the rapid development of industrial applications. This is where FlowFuse, built on Node-RED, offers a clear advantage.

FlowFuse provides a low-code environment that unifies data connectivity, processing logic, and visualization. As covered in our previous articles—MES Data Acquisition: How to Unlock Your Factory’s Hidden Data and Structuring and Storing Data for Effective MES Integration—FlowFuse connects seamlessly to nearly all shop floor assets, prepares the data, and stores it in an accessible format.

From there, KPI logic flows can be built visually, defining how and when data is retrieved, how calculations are applied, and how results are displayed. This enables continuous KPI updates without manual effort.

OEE Dashboard built with FlowFuse

The example above shows an OEE Dashboard, updated every 10 seconds using FlowFuse. Operational data is automatically retrieved, processed, and visualized, delivering accurate, real-time metrics through gauges, charts, and tables.

The following flow powers this dashboard:

OEE Dashboard Flow

Each node in this flow performs a specific task: retrieving data, transforming it, applying OEE formulas, and delivering results to the dashboard. The entire process is automated and repeatable, providing a real-time view of equipment performance and production health.

Build Your First KPI Flow

Let’s see how easy it is to calculate a KPI with a practical example where we will calculate Machine Downtime, using demo data stored in an SQLite database.

To Begin

Login to the FlowFuse platform. If you don't have an account, you can register for a free trial to get started. Once registered, create a FlowFuse instance and open its editor.
Install the node-red-node-sqlite from the Palette Manager.
For the demo database, import the following database flow. Upon deployment, it will create an SQLite table and insert the demo data:

Flow Setup

Drag an Inject node onto the canvas and configure it to trigger at your desired interval (e.g., every 10 seconds) to start the data retrieval process.
Drag a Change node and connect it to the Inject node, adding elements to include query parameters for sql query as shown in the following image.

Change node setting parameters

Drag an SQLite node, connect it to the Change node, and configure it with following sql statement and select set query to "Prepared Statement"

SELECT *
FROM machine_runtime_logs
WHERE machine_id = $machine_id
  AND date BETWEEN $start_date AND $end_date;

Drag a Split node and connect it to the SQLite node to break down the returned array or multiple rows from the database.
Drag two Join nodes and connect them to the output of the Split node.
Configure the first Join node in Reduce mode to sum total_operational_time using the expression $A + payload.total_operational_time.
Configure the second Join node in Reduce mode to sum run_time using the expression $A + payload.run_time.
Drag a Change node and connect it to the first Join node to store msg.payload as flow.total_operational_time.
Drag another Change node and connect it to the second Join node to store msg.payload as flow.run_time.
Drag a new Change node and connect both previous Change nodes to it, then set msg.payload using the following JSONata expression to calculate Machine Downtime Percentage:

(($flowContext("total_operational_time") - $flowContext("run_time")) / $flowContext("total_operational_time")) * 100

Drag a Debug node onto the canvas, connect it to the last Change node, and configure it to display msg.payload.
Deploy the flow to continuously calculate and output the Machine Downtime Percentage in real time.

After deploying the flow, observe the debug sidebar on the right. You'll see the calculated machine downtime percentage being continuously printed. To present this data visually, leverage Flowfuse Dashboard.

Downtime printed on debug panel

You’ve just seen how easy it is to calculate a foundational KPI like machine downtime. But with FlowFuse’s low-code environment, this is just the beginning. You not only connect, collect, transform, and visualize data—but also scale effortlessly.

FlowFuse enables you to manage thousands of device instances remotely, with built-in security, access control, and version management. This level of control ensures consistency across your factory operations and allows you to deploy updates and changes quickly with confidence.

There is much more to explore—FlowFuse gives you the flexibility and power to build a fully integrated, intelligent MES solution that grows with your manufacturing needs.

What does this mean for your factory?

You'll put more money in your pocket, by slashing hidden waste and squeezing every drop of efficiency out of your machines and time.
You'll be in total control, ditching the daily firefighting for a clear view that lets you fix problems before they even start.
You'll produce quality you're genuinely proud of, every single time, catching issues on the spot for fewer headaches and happier customers.
You'll unleash the genius of your own team, giving them the insights they need to innovate and drive continuous improvement on the floor.
You'll leap into tomorrow's factory, today, rapidly building powerful solutions that make your entire operation smarter, faster, and truly future-ready.

Final Thought

We've talked a lot about Factory KPIs and how they're not just some numbers on a screen; they're your secret weapon. And we've seen how a powerful MES, especially one built on something as flexible as FlowFuse, is the real workhorse, taking all that raw data and turning it into clear, actionable gold.

Forget about guessing games. With the right MES and smart KPIs, you get the full picture, right now. It means knowing what is happening on your floor, fixing issues fast, and making decisions that drive measurable impact.

Schedule a demo and we'll show you how FlowFuse transforms your operations.

Structuring and Storing Data for Effective MES Integration

2025-06-18T00:00:00Z

Collecting factory data for your MES is just the first step. If that data isn't properly organized, cleaned, and stored, it's a jumbled mess, leading to missed opportunities and wasted investments. Disorganized information prevents your MES from quickly finding, understanding, and comparing crucial data, directly impacting production, increasing errors, and hindering confident decision-making.

FlowFuse simplifies live factory data acquisition, and now it's time to make that data work harder. This article dives into best practices for structuring and storing factory data, helping you maximize your MES's performance and turn raw information into a powerful tool.

Core Strategies for Structuring Your Factory Data

Now that we understand the importance of data structuring, let's explore how to achieve it. This involves giving your data a clear shape and defining rules, ensuring that every system, that is part of your MES, can easily interpret the meaning of each piece of information.

Here are some straightforward ways we get data structred:

Making a Plan for Your Data (Data Modeling): This is like drawing a simple map for your data. It helps you decide exactly what pieces of information you'll collect (like machine temperature, how many items are made, or who operated the machine) and how they connect to each other. This keeps everything neat and consistent. For example, a data model might say that every "production run" must have a "start time" and an "end time." This makes sure your MES always gets the full picture and avoids confusing or incomplete information.
Speaking the Same Language (Standardizing): Imagine if everyone in your factory used different words for the same thing. It would be confusing! Standardizing means always using the same names, units, and formats everywhere. For example, if you measure temperature, always use Celsius. If one machine sends "TempC" and another just "Temperature," standardizing ensures both are read as "Temperature in Celsius." This prevents your MES from getting confused by different terms for the same data.
Adding the Full Story (Contextulization): A raw number like "100" by itself doesn't tell you much. But if you add "100 items made by Machine A on June 10th at 2:00 PM in Batch 123," suddenly you know the whole story! This means attaching important details like the exact time, the machine's name, the batch number, or who was working at that moment. This extra information makes raw numbers meaningful, so your MES can track things accurately and you can make smarter decisions based on the full picture.

How FlowFuse Brings Your Data Strategy to Life

FlowFuse simplifies data structuring with its intuitive, drag-and-drop environment. Raw machine data—often just numeric signals—can be enriched, formatted, and organized in real time, without writing any code.

You can easily:

Add timestamps to readings
Associate data with specific machines or lines
Convert units (e.g., Fahrenheit to Celsius)
Rename fields for consistency

FlowFuse comes with standard nodes, like split, change, join, and switch. These let you visually tell FlowFuse how to transform your data. These nodes handle all the technical work for you. You just connect the blocks that clean your data, add context, and prepare it for use in monitoring dashboards or other industrial applications.

There's another simple and powerful node to tell you about. It lets you handle data modeling, standardization, and contextualization, plus it checks your data to make sure it's in the correct range or type. We call this method JSON Schema validation.

JSON Schema is a vocabulary that allows you to annotate and validate JSON documents. It defines the structure, data types, and validation rules, ensuring consistency and interoperability across different applications and systems.

Setting Up JSON Schema Validation

To get started, open your FlowFuse instance editor.

Next, you'll need to install the specific node for JSON Schema validation. Search for and install node-red-contrib-json-full-schema-validator.

Once the node is installed, your next step is to plan your data schema. This involves deciding:

Which properties are essential for your data.
What data types these properties should have (e.g., number, string, boolean).
The units for numerical data (e.g., if it's temperature, should it be Celsius or Fahrenheit?).
Valid ranges for your data (e.g., a temperature range of -40°C to 150°C).
Other factors like precision, mandatory fields, and any additional attributes.

After planning, you'll prepare this schema in JSON format. For a comprehensive guide on how to define your JSON Schemas, check out this helpful: Getting Started Guide.

{
  "title": "Hydraulic Pump",
  "type": "object",
  "required": ["timestamp", "temperature", "pressure"],
  "properties": {
    "timestamp": {
      "type": "string",
      "format": "date-time",
      "description": "Timestamp of when the data was recorded."
    },
    "temperature": {
      "type": "object",
      "required": ["value", "unit"],
      "properties": {
        "value": {
          "type": "number",
          "description": "The temperature value.",
          "minimum": 0
        },
        "unit": {
          "type": "string",
          "enum": ["Celsius"],
          "description": "The unit of the temperature value."
        }
      }
    },
    "pressure": {
      "type": "object",
      "required": ["value", "unit"],
      "properties": {
        "value": {
          "type": "number",
          "description": "The pressure value.",
          "minimum": 0
        },
        "unit": {
          "type": "string",
          "enum": ["Pascal"],
          "description": "The unit of the pressure value."
        }
      }
    }
  }
}

This JSON schema defines the structure for data related to a hydraulic pump. It includes three key properties: timestamp, temperature, and pressure. The timestamp must be in a valid date-time format. Both temperature and pressure require two properties: value (a number representing the actual measurement) and unit (which must be Celsius for temperature and Pascal for pressure). Both values must be greater than or equal to zero. This schema ensures that all data is recorded with the correct units and valid values, maintaining consistency and reliability.

Implementing Data Schema Validation

Let's implement the data schema validation mechanism to ensure each incoming data adheres to the specified JSON schema.

Drag the JSON Full Schema Validator node onto the Node-RED canvas.
Double-click the node to open its settings.
Copy and paste your schema into the node’s schema field.

Configuring "JSON Full Schema Validator" node with JSON schema for our data

Click Done to save the changes.
Connect the input of the JSON Full Schema Validator node to the data source from where your data is coming.
Connect the node's first output to another node to process or handle the validated data (e.g., an MQTT node, a database node, or any other destination).
Connect the second output to the flow that will handle the situation where data does not meet the schema. This could be a notification flow sending an email or Telegram to your team or a dashboard alert.
Deploy the flow.

Now, let's understand this with an example. Below is the data that we are receiving from the PLC. After transforming it, we’ve added essential properties such as unit and value. However, notice that the data doesn't meet the schema definition because the temperature is given in Fahrenheit and is a negative number, which isn't within the expected range.

Message passes through the second output and includes errors when it does not align with the data schema.

If the data doesn't align with the data schema, it will pass through the "JSON Full Schema Validator" node and flow through the second output. The message will contain an error array with detailed information about what is wrong with the data (e.g., incorrect unit or out-of-range value). From this output, you can easily connect email or Telegram nodes to send alert notifications.

When the data meets the schema, it passes through the first output without errors. The validated data is then sent to the next stage in the flow.

Message passes through the first output and does not include errors when it aligns with the data schema.

Where to Keep All That Factory Data

Once your factory data is structured and validated, you need a smart place to store it. Different kinds of information often require different storage types to be most useful for your MES.

Here are the main types of storage typically used for factory data:

Time-Series Databases (TSDBs): Perfect for constantly changing data like sensor readings (temperature, machine speed). They handle massive updates efficiently, ideal for spotting trends over time. Think of them as a super-efficient diary recording every moment. InfluxDB and TimescaleDB are good examples.
Standard Databases (SQL Databases): Best for structured information with clear connections, such as production orders, material usage per batch, or quality check results. They keep data organized and ensure correct links between pieces of information, like a well-organized spreadsheet. You'll often see PostgreSQL or MySQL used here.
Data Lakes or Cloud Storage: Use these for vast amounts of diverse data, even if it's not perfectly organized. They're great for long-term historical records or data you'll analyze later with advanced tools. Imagine them as a huge warehouse for anything, ready when you need to sort through it. Amazon S3 and Azure Data Lake Storage are common examples.

When choosing storage, consider your data volume and speed, how often you need to access it (real-time vs. historical), cost, scalability, system connectivity, and data security.

FlowFuse Also Helps with Data Routing to Storage

FlowFuse isn't just for changing and cleaning data; it also makes sure your data gets to the right storage spot.

It has tons of nodes for almost every database and cloud storage system you'll find in a factory today.

This includes direct connections to normal databases like MySQL and PostgreSQL for your organized production data.

It also has special nodes for time-series databases like InfluxDB and TimescaleDB to handle fast sensor and machine data.

Plus, FlowFuse connects to big Data Lakes and Cloud Storage services like Amazon S3, Google Cloud Storage, and Microsoft Azure.

FlowFuse Fuels Your MES Dashboards and Applications

Once your factory data is effectively structured, validated, and routed by FlowFuse to the right place, it becomes an incredibly powerful asset for your MES.

FlowFuse doesn't just manage your data; it also empowers you to easily build the user interface (UI) for your MES. You can create insightful dashboards and industrial applications using a no-code, drag-and-drop approach with components from FlowFuse Dashboard. This allows you to design the screens operators use to visualize critical information and control processes, all built upon the reliable data foundation you've established.

Final Thought

Your factory's success hinges on smart decisions, and smart decisions need good data. It's not enough to just collect information from your machines; you need to make sense of it.

That means organizing your data so it's clear and consistent. Think of it like putting all your tools in the right place – easy to find when you need them. You also need to clean up the data, getting rid of errors so you can trust what you see. Finally, you need to store it smartly, choosing the best spot for different types of information so it's always ready for use.

FlowFuse helps with all of this. It's like your data's personal assistant, collecting raw information, tidying it up, and sending it to the right storage, all without complicated coding. This ensures your Manufacturing Execution System (MES) gets the accurate, reliable data it needs to help you run your factory smoother and make better choices. Hundreds of other manufacturing companies are already using FlowFuse to transform their data into a powerful asset.

If you want to see FlowFuse in action, book a demo today!

MES Data Acquisition: How to Unlock Your Factory’s Hidden Data

2025-06-13T00:00:00Z

A Manufacturing Execution System (MES) is the central control system of a factory. To work properly, it needs a steady stream of real-time data from machines and systems on the factory floor. This data is essential for running operations smoothly. But in most factories, the hardest part is getting this data to the MES.

This article dives into the data that fuels your MES and the complex web of sources it comes from. We'll explore the core challenge that keeps this data locked away in silos. Most importantly, we’ll show how FlowFuse acts as the catalyst to liberate this data, empowering you to get the right information to your MES, exactly when and where you need it most.

The Operational Data Your MES Needs

For a factory's main computer system (the MES) to do its job, it needs a constant stream of information. Think of it like a control room that needs to see everything at once. This information can be grouped into four main types:

Production Information: This tells the system how much is being made, how fast it's being made, and if any products had to be thrown out. It's the basic "are we winning?" data.
Machine Information: This is like a live health report for your equipment. It tells the system if a machine is running or stopped, what its settings are (like temperature or speed), and how much power it's using.
Context and Quality Information: This data adds the "why." It tells the system who is working, why a machine stopped, and if the products being made are good enough to sell.
Material Information: This tells the full story of a product. It tracks all the raw materials and parts from start to finish, so you know exactly what went into every single item.

Once the system gets all this information, it does more than just track numbers. It becomes the factory's control center. It gives workers step-by-step instructions on their screens, makes sure rules are followed to prevent mistakes, and lets managers see exactly what’s happening everywhere so they can fix small problems before they become big ones.

The Origins Of Your Operational Data

This critical operational data doesn't live in one place; it's generated across a diverse and complex digital ecosystem.

A vast amount comes directly from shop floor equipment—the PLCs that orchestrate your machines, the thousands of sensors measuring every variable, and the Historians that diligently archive past performance. Then you have your core business systems. The ERP provides the what and why through production orders, while Quality (QCS) and Maintenance (CMMS) systems add essential layers of inspection and machine health data.

Each of these sources speaks its own digital language. A single factory floor is a cacophony of Modbus, OPC UA, EtherNet/IP, and MQTT, etc all running simultaneously. This mix of protocols defines the communication architecture of the operation.

To better understand the data involved, its sources, and the common protocols used, let's look at a detailed breakdown:

A table showing the four main categories of data MES need

Why It's So Difficult, Slow, and Costly to Access Data

You know what data you need and where it is. The fundamental question is: can you actually get it from your machines and deliver it to your MES?

This is the central struggle where real-time decisions get delayed, opportunities are lost, and innovation is stifled. Your most valuable data is trapped. Because your factory’s systems don’t speak the same digital language, data is locked away in "silos," inaccessible and unusable. This isn't a technical inconvenience; it's a critical business problem.

Every new piece of equipment demands expensive, custom-coded integrations that are fragile and brittle. This necessitates a constant reliance on specialized programmers, driving up operational costs significantly. The result is a chaotic patchwork of inconsistent data flows, leaving you with a fragmented view of your operation instead of the unified intelligence you desperately need to make swift, informed decisions. This isn't just inefficient; it actively sabotages your agility, cripples your ability to innovate, and fundamentally undermines your competitive advantage.

Orchestrate Your Factory's Data Flow with FlowFuse

It's frustrating to know the data is there but be unable to reach it. FlowFuse was built to solve this exact problem by acting as a data acquisition layer for your factory. It creates reliable pathways for information to get from your various machines and systems directly to your MES.

The power of FlowFuse lies in its foundation on the vast Node-RED ecosystem. This gives you immediate access to a library of over 5,000 pre-built connectors, or "nodes" ready to communicate with a massive array of industrial protocols. This eliminates the need for expensive, time-consuming custom code. The library includes robust nodes for standards like Modbus, OPC UA, and MQTT, as well as for specific controllers from Siemens, Mitsubishi, Omron, and more.

Following are some of the most commonly used protocol nodes:

Modbus: https://flows.nodered.org/node/node-red-contrib-modbus
OPC UA: https://flows.nodered.org/node/node-red-contrib-opcua
OPC DA: https://flows.nodered.org/node/node-red-contrib-opc-da
MQTT: https://flowfuse.com/node-red/core-nodes/mqtt/
Ethernet/IP: https://flows.nodered.org/node/node-red-contrib-ethernet-ip
Siemens S7: https://flows.nodered.org/node/node-red-contrib-s7comm
MITSUBISHI MC: https://flows.nodered.org/node/node-red-contrib-mcprotocol
OMRON FINS: https://flows.nodered.org/node/node-red-contrib-omron-fins
HTTP: https://flowfuse.com/node-red/core-nodes/http-in/
LwM2M: https://flows.nodered.org/node/node-red-contrib-lwm2m
AMQP: https://flowfuse.com/node-red/protocol/amqp/
Serialport: https://flows.nodered.org/node/node-red-node-serialport
GPIO: https://flows.nodered.org/node/node-red-contrib-gpio
Lorawan: https://flows.nodered.org/node/node-red-contrib-lorawan

This extensive library allows you to reliably acquire data from various assets using a simple drag-and-drop approach, bringing your factory's siloed data into a cohesive and manageable flow.

In addition to protocol connectors, there are also powerful database nodes available to integrate with systems such as InfluxDB, TimescaleDB, PostgreSQL, Microsoft SQL Server, and more—making it easy to store, query, and analyze your factory data.

So, With FlowFuse, you can:

Deploy intelligent agents directly to the edge, all managed from a central platform remotely.
Connect to any industrial asset—PLCs, sensors, SCADA—using ready-made nodes.
Transform raw data with visual logic, so it’s perfectly structured for your MES.
Build custom operator dashboards with pre-built UI widgets to visualize and act on data.
Automate data flows based on schedules, machine events, or production states.
Secure the entire process with enterprise-grade features like multi-user authentication and role-based access control.
Scale seamlessly from a single line to your entire enterprise.

This isn't just about solving a technical challenge. It’s about driving business outcomes. When you can finally see your entire operation in one clear picture, your production lines run more efficiently. You'll see tangible savings as you reduce waste and catch errors before they become costly. When you are known for exceptional quality and effortless compliance, you win. You can turn the messy, trapped data that has been holding you back into the very asset that pushes you ahead of the competition.

Your Next Step Towards Operational Excellence

Bridging the gap between your factory floor and your MES is a huge task. The sheer diversity of machines, systems, and protocols can seem impossible to overcome. But it doesn’t have to be a barrier to innovation.

This is precisely where FlowFuse shines. It acts as the universal translator, bringing all your systems together regardless of the language they speak. With thousands of ready-to-use connectors and an intuitive low-code interface, FlowFuse empowers you to get your data flowing exactly where it needs to go.

Once that live data starts moving, your MES becomes exponentially more powerful—helping you spot problems faster, plan smarter, and run your operations with confidence.

Want to see it in action? Book a live demo and watch FlowFuse unlock your factory data—no custom code required.

Announcing Node-RED Con 2025: A Community Conference on Industrial Applications

2025-06-12T00:00:00Z

At FlowFuse, our commitment to the Node-RED community is at the heart of everything we do. That's why we are thrilled to announce our support as a sponsor for Node-RED Con 2025, a free, online conference taking place on Tuesday, November 4, 2025!

This year's event is dedicated to exploring a vital theme: Node-RED applications in industry. It’s a fantastic opportunity for developers, engineers, and innovators to connect and share how Node-RED is being used to solve real-world challenges.

The Call for Papers is Now Open

The conference agenda is built from community submissions, and the official Call for Papers is now live. This is a chance to contribute your expertise and share your story with the wider Node-RED ecosystem.

The event is seeking submissions from passionate individuals in several categories:

Full Talks & Demos (25-30 mins): Focused on industrial use cases, IoT architectures, and edge computing.
Lightning Talks (8-10 mins): Showcasing fun, creative, or inspiring projects.
Expert Panelists: To discuss the future of industrial automation with Node-RED.

The deadline for submissions is July 25, 2025.

Learn More & Submit Your Proposal

Would you like to attend?

For a direct email reminder when registration opens, you can sign up for updates below.

We are proud to support this fantastic community-led event and can't wait to see the innovations that will be shared. See you in November!

Optimizing operations: Improve Industrial Operations with FlowFuse

2025-06-10T00:00:00Z

The announcement of our latest $7.25 million funding round isn't just a milestone for FlowFuse; it's a catalyst for our mission to revolutionize how industrial data is accessed and used.

Thousands of IT professionals and citizen developers now collaborate with our product on their digital transformation, and we’re expecting hundreds of thousands more to join over the next few years. We're incredibly proud of our recent growth – nearly 5x in customers and revenue just last year, a trend that’s only accelerating. But more than that, we're thrilled by what this allows us to build for you.

Our focus has always been to empower engineers and operational managers to connect the physical shop floor with their digital enterprise systems. We see FlowFuse, powered by Node-RED, as that critical layer that makes data accessible, understandable, and actionable. And with this new investment, we're doubling down on making this experience even more powerful and intuitive.

FlowFuse: The Low-Code Powerhouse for Industrial Data

FlowFuse is enabling customers to bridge the gap between their physical and digital operations. They are leveraging FlowFuse to extract the data required to implement new use-cases from a wide range of sources. FlowFuse spans both digital systems like ERPs and physical equipment on the shop floor. Using the low-code interface of Node-RED within the FlowFuse platform, this captured data is then transformed and efficiently transported to various destinations. Significantly, users are orchestrating multiple Node-RED instances through FlowFuse to collaboratively inform and automate operational decisions, even incorporating crucial operator feedback directly into the workflow.

FlowFuse creates a singular and unified platform for users that not only extracts and transports data but also actively utilizes it for decision-making and incorporates human expertise, effectively closing the loop through fusing your operations with the corporate systems. The void often filled by complex SCADA systems and disparate, siloed solutions can now be seamlessly integrated and managed with FlowFuse.

Where We're Going: Infusing AI for an Even Smarter Tomorrow

Over the past years we’ve been focused on augmenting Node-RED to enable it to scale better for an organization. This entails many facets:

Ensure companies that are in regulated industries meet their compliance frameworks.
Make it easy to run and maintain hundreds or thousands of Node-REDs.
Extend DevOps to operational technology teams, ensure development is done outside of production systems.

Our shift towards becoming an end to end platform to connect the physical world with your digital realm is next, and we’ve already started this journey. Over the past months we’ve enabled customers to store data long term by allowing them to store files on the platform. Also, we noticed that customers took longer than ideal to transport data between data consumers and producers and back again. Building a data orchestration layer, for example through a Unified Namespace (UNS), is vital to ensure data is available for building applications. So FlowFuse has allowed thousands of clients to send data through MQTT, a quick on-ramp to further the abilities for the platform of FlowFuse. Lastly, in the next FlowFuse release a data storage layer will be provided to persist and allow querying of events.

While we'll continue to enhance the core capabilities users already love, a significant portion of this new investment is earmarked for integrating AI more deeply into the FlowFuse platform. The FlowFuse AI assistant already has proven itself countless times. However, we believe improving our AI suggestions and capabilities are the key to unlocking the next level of low-code development.

While Node-RED is low-code and enables many engineers the power to integrate, automate, and interact with their operations, we want every engineer – mechanical, electrical, or operational – to harness its full potential quickly. AI will act as an intelligent guide, helping new users understand Node-RED's capabilities, learn best practices, and troubleshoot effectively. Imagine an assistant that helps you build your first flow, suggests optimal configurations, or explains complex functions in simple terms.

Furthermore, we see that AI can offer suggestions, identify potential optimizations, and even help generate partial flows in Node-RED. Allowing both new and experienced users to gain momentum. FlowFuse is on a mission to get a billion people automating, having AI make suggestions allows more people to learn how, and get started, as well as advanced users remove boilerplate to create and get to brass tacks faster.

The Vision: Everyone Can Increase Operational Excellence

There are millions of brilliant engineers and managers out there who understand their operations inside and out. They know what needs to be optimized, and have hunches to validate, but often lack the accessible tools to bridge the data gap. That’s what FlowFuse is for.

We are committed to making it super easy to get data, derive insight, and act on that insight to optimize operations. The infusion of AI into our low-code platform is the next logical step in this journey. We're incredibly excited about the path ahead and grateful to our customers, partners, and investors for their support. The future of industrial operations is intelligent, connected, and user-empowered – and we're building it, together.

Want to see how FlowFuse can help you optimize your operations? Let's talk about your specific needs and see our platform in action. Schedule a demo with our team today.

FlowFuse Forms: Easy Data Collection for Your Factory Floor

2025-06-10T00:00:00Z

It's often a pain to get important data from the factory floor. Things like doing quality checks still rely on old methods like manual notes and slow spreadsheets. This can lead to delays, errors, and a lot of wasted time before anyone can actually use the information. It's especially tough when you need quick feedback from an operator.

This article will show you an easy way to gather data via a form entry. We'll look at how forms in FlowFuse Dashboard can make collecting data from factory workers much simpler. You'll learn how to build useful forms that connects your team's knowledge directly to your industrial processes. As a practical example, we'll walk you through building a solution to digitize production recipe updates, showing you exactly how to implement it.

Prerequisites

Before you begin, make sure you have the following:

Node-RED: Make sure you have an instance of Node-RED up and running. The quickest way to do this is via FlowFuse. If you don't have an account, check out our free trial.

Then you'll need to add two more sets of nodes to your palette:

FlowFuse Dashboard: Ensure you have FlowFuse Dashboard (also known as Node-RED Dashboard 2.0 in the community) installed and properly configured on your instance.
SQLite: Install the node-red-node-sqlite package, which will be used in the practical example.

and finally:

Basic Node-RED Knowledge: You are familiar with creating and deploying basic flows in Node-RED. If not, consider taking the Node-RED Fundamentals Course sponsored by FlowFuse.

Building Forms in FlowFuse Dashboard

The FlowFuse Dashboard makes it easy to build interactive industrial applications using drag-and-drop components — no coding required.

One of these components is the Form widget, which allows you to create versatile forms within your applications. The Form widget supports a wide range of input types, including:

Text Fields
Number Inputs
Date Pickers,
Multi-line Text Areas
Dropdown Selection
Checkboxes

A key benefit of this widget is that you can configure the form fields either statically (with predefined values) or dynamically (updated through your Node-RED flow), depending on your application’s needs.

Drag the Form widget onto the canvas.
Double-click on the widget and create a new group for it with the correct page configuration to render it. (note: if this is the first widget you have, this will automatically be created for you)
Set an appropriate size (width and height) according to your preferences.
Enter the label for the form.

Now that we have completed all the basic and necessary configurations for the form, let’s add the input elements.

Adding Input Fields to the Form Statically

Adding Form Elements

The widget supports various input element types that can be tailored to specific use cases — from collecting simple text to selecting dates or choosing from predefined options.

To add input elements:

Click the + add button in the widget’s configuration dialog.
A new configuration row will appear for the element.
Configure each input element with the following fields:

Label: This is the visible label for the field shown to the user.
Name: A unique key used in the message payload (e.g., msg.payload.firstname) when the form is submitted.
Type: Select the input type. Supported types include:
- Text: For short text inputs (e.g., name, city).
- Number: For numeric inputs (e.g., age, price).
- Date: For selecting a date.
- Text Area: For longer free-form text.
- Dropdown: For selecting from a list of predefined values.
  We will cover how to add options to the dropdown field in a later section.
- Checkbox: For boolean values (checked or unchecked).
Required: Check this box to make the field mandatory. The form cannot be submitted unless this field is filled.
Row:: If Multiline is selected, this defines the number of visible rows in the text area.

When you add Dropdown type input element to the Form widget, you need to provide a list of options that the user can choose from. These options can be configured in the widget's configuration dialog.

In the widget's configuration dialog, switch to the "Dropdown Options" tab.
Click the + add button to insert a new option row.
In the new row, fill in the following fields:
- Dropdown: Select the dropdown input field you want to add options to.
- Value: The internal value that will be sent in the form payload when this option is selected.
- Label: The visible text shown to the user in the dropdown list.

Repeat this process for each option you want to add.

Pre-filling Forms with Default Values

You can pre-fill forms with default values to streamline user input, reduce typing errors, and save time. This is especially useful in scenarios like editing an existing recipe, where the current details can be loaded directly into the form.

We can pass data to the ui-form node in our flow to set these values dynamically. To do this, send an object in msg.payload to the input of the relevant node. Each key of msg.payload corresponds to a form field and its value represents the pre-filled data.

For example, if your form includes fields for product_name and target_temperature_c, you can send a msg.payload like this:

{
    "product_name": "Eco-Friendly Coating",
    "target_temperature_c": 120.0
};

Add Form Input Elements Dynamically at Runtime

In some cases, you may need to define form elements dynamically based on real-time data.

For example, you might want to show additional fields based on a user’s selection or load dropdown options from an external API. This dynamic capability adds a new level of flexibility and interactivity to your forms.

To define form fields at runtime:

Use the msg.ui_update.options.
options should contain an array of objects, where each object defines the new configuration for the element:

Below are the supported element types and their corresponding JSON configurations:

Element Type	JSON Configuration
Text	`{ "type": "text", "label": "Name", "key": "name", "required": true }`
Multiline	`{ "type": "multiline", "label": "Name", "key": "name", "required": true, "rows": 4 }`
Password	`{ "type": "password", "label": "Password", "key": "password", "required": true }`
Email	`{ "type": "email", "label": "E-Mail Address", "key": "email", "required": true }`
Number	`{ "type": "number", "label": "Age", "key": "age", "required": true }`
Checkbox	`{ "type": "checkbox", "label": "Subscribe to Newsletter", "key": "newsletter" }`
Switch	`{ "type": "switch", "label": "Enable Notifications", "key": "notifications" }`
Date	`{ "type": "date", "label": "Date of Birth", "key": "dob", "required": true }`
Time	`{ "type": "time", "label": "Time of Birth", "key": "tob", "required": true }`
Dropdown	`{ "type": "dropdown", "label": "Dropdown", "key": "selection" }`

To update the options of a dropdown field at runtime, use the msg.ui_update.dropdownOptions property in your flow.

This is useful when you want to update just the dropdown options without changing the rest of the form.

Example:

[
   {
        "dropdown": "Machine Type",
        "value": "A",
        "label": "Option A"
   },
   {
        "dropdown": "Machine Type",
        "value": "B",
        "label": "Option B"
   }
]

The "dropdown" refers to the name of the dropdown field you want to add options for. The "value" represents the internal value that is sent when the user selects the option. The "label" is the option displayed to the user in the dropdown.

Handling Input Data Collected from the Dashboard Form

When a user submits the dashboard form, the input data is sent to Node-RED, where it can be accessed and processed. This enables you to perform tasks such as validating the data, transforming it, or sending it to other systems like databases or APIs.

Retrieving Submitted Data

The data submitted from the form is transmitted to any nodes connected to the output of the ui-from node, and is contained within msg.payload. Each field’s value can be accessed using the field’s key or name as the property within msg.payload.

For example, let’s say the form includes the following fields:

Device Name (key: device_name)
Device ID (key: device_id)
Device Serial Number (key: serial_number)
Country (key: country)

After submission, you can access these values like this in your flow:

Device Name: msg.payload.device_name
Device ID: msg.payload.device_id
Device Serial Number: msg.payload.serial_number
Country: msg.payload.country

You can use this data anywhere in your flow — for example, to save it in a database or store it in FlowFuse’s context storage. Crucially, this collected data can also directly instruct machines on the shop floor, with FlowFuse Device Agent managing that precise control.

Building Your Dynamic Production Recipe Update Form

In this section, you will build an advanced flow for dynamically updating production recipes using FlowFuse Forms.

A production recipe, often referred to as a manufacturing recipe or master batch record, is a critical set of instructions that defines the precise parameters, ingredients, and steps required to produce a specific product consistently. This includes details like material quantities, temperature, mixing speeds, pressures, and hold times.

This setup uses a ui-dropdown for selecting recipes and a ui-form that dynamically populates and allows updates to recipe parameters. Everything you have learned so far will come together here to create a practical and interactive solution.

Set Up Your SQLite Database

Use the following flow to quickly set up your SQLite database. It creates a recipes table and populates it with demo data.

Steps:

Import the flow into your Node-RED editor (from the example provided below).
Deploy the flow to activate it.
Click the Inject node labeled "Populate Demo Recipes" to insert the sample data.

We want this flow to run when our dashboard page loads. It queries your exiting recipes and then dynamically defines both the ui-dropdown's options and the ui-form's structure.

Drag an Event node onto the canvas. This node send a message when the dashboard page loads.
Connect the ui-event node to an sqlite node. Configure it to connect to your SQLite database, set SQL Query to fixed, and enter SELECT recipe_id FROM recipes; as the query. Ensure Return Output is set to a "Parsed JSON Object".
Connect the sqlite node's output to a new function node. Name it "Generate Form & Dropdown Definition". In this function, you will write JavaScript to dynamically create the form's elements and populate the dropdown options. Set the function to have 2 outputs.

// msg.payload contains the recipe_id and recipe_name from SQLite query.
let dropdownOptions = [];
if (msg.payload && Array.isArray(msg.payload)) {
    dropdownOptions = msg.payload.map(recipe => {
        return {
            value: recipe.recipe_id,        // Internal value for dropdown
            label: recipe.recipe_name       // Display text for dropdown
        };
    });
}

// --- Define the ui_form structure (all input elements) ---
let formElements = [
    { type: "text", label: "Recipe ID", key: "recipe_id_display", readOnly: true },
    { type: "text", label: "Product Name", key: "product_name", readOnly: true },
    { type: "text", label: "Version No.", key: "version_no", readOnly: true },
    { type: "number", label: "Target Temp (°C)", key: "target_temperature_c", required: true },
    { type: "number", label: "Mixing Speed (RPM)", key: "mixing_speed_rpm", required: true },
    { type: "number", label: "Pressure (Bar)", key: "pressure_bar" },
    { type: "number", "label": "Material A (kg)", "key": "material_a_kg", "required": true },
    { type: "number", "label": "Material B (kg)", "key": "material_b_kg" },
    { type: "number", "label": "Catalyst (ml)", "key": "catalyst_ml" },
    { type: "number", "label": "Hold Time (min)", "key": "hold_time_min", "required": true },
    { type: "multiline", "label": "Description", "key": "description", "readOnly": true, "rows": 3 }
];

// Output 1: For the ui_dropdown node (msg.options)
let msg1 = { options: dropdownOptions }; 

// Output 2: For the ui_form node (msg.ui_update.options)
let msg2 = { ui_update: { options: formElements } };

return [msg1, msg2]; // Send two separate messages

Drag a ui-dropdown node onto the canvas. Configure its dashboard group and label (Select Recipe ID:). Ensure its "Options" list is empty, as it will be populated dynamically. Connect the first output of the "Generate Form & Dropdown Definition" function to the input of this ui_dropdown node.
Drag a ui-form widget onto the canvas. Configure its dashboard group and label (Recipe Parameters). Crucially, leave its "Options" list completely empty in its properties. Set the "Submit" button text to Apply and "Cancel" to Clear. Connect the second output of the "Generate Form & Dropdown Definition" function to the input of this ui-form node.
Deploy your flow and open the dashboard. You should now see your form with the "Select Recipe" dropdown populated.

Populate Form on Recipe Selection

This flow segment pre-fills the form with recipe details when an operator selects a recipe from the dropdown.

Connect the output of your dropdown node (from Step 2). This output will carry the selected recipe_id in msg.payload.
Connect the ui-dropdown output to a change node. Name it Set Params & Flow Context. Set msg.params.$recipe_id to msg.payload and flow.selected_recipe_id to msg.payload.
Connect the change node to an sqlite node. Configure it for your database, set SQL Query to prepared statement, and enter SELECT * FROM recipes WHERE recipe_id = $recipe_id; as the prepared statement. Ensure you add a rule in change node:
- msg.params.$recipe_id to msg.payload.recipe_id
Connect the sqlite node's output to a function node. Name it Show values to form fields. This function will format the retrieved recipe details to pre-fill the form.

let recipeDetails = msg.payload[0]; // Get the first (and only) result

if (recipeDetails) {
    // Map recipe details to the keys of your form elements for pre-filling.
    msg.payload = {
        recipe_id_display: recipeDetails.recipe_id, // For the display field in ui_form
        product_name: recipeDetails.product_name,
        version_no: recipeDetails.version_no,
        target_temperature_c: recipeDetails.target_temperature_c,
        mixing_speed_rpm: recipeDetails.mixing_speed_rpm,
        pressure_bar: recipeDetails.pressure_bar,
        material_a_kg: recipeDetails.material_a_kg,
        material_b_kg: recipeDetails.material_b_kg,
        catalyst_ml: recipeDetails.catalyst_ml,
        hold_time_min: recipeDetails.hold_time_min,
        description: recipeDetails.description
    };
} else {
    // If selection is cleared, prepare an empty payload (except for selected_recipe_id)
    msg.payload = {}; 
}
return msg;

Connect the output of the Show values to form fields function node back to the input of your form widget (from Step 2).

Handle Form Submission & Update Database

This flow segment processes the data when the operator clicks the "Apply" button, updating the recipe in your database and providing feedback.

Connect a new wire from the main output of your ui-form widget. This output fires when the form is submitted.
Connect the form's output to a change node. Name it Prepare Update Params. This node will prepare the msg.params object for the SQLite update.

Rules:
- set msg.params to JSON {}.
- set msg.params.$recipe_id to flow.selected_recipe_id.

For each editable field in your form (e.g., target_temperature_c, mixing_speed_rpm), add a rule: set msg.params.$[FIELD_NAME] to msg.payload.[FIELD_NAME].

Connect the change node to an sqlite node.
- Configure it for your database, set SQL Query to prepared statement.
- Paste your UPDATE SQL query into the "Prepared Statement" field, using the $parameters that match your msg.params.
Connect the sqlite node's output to a switch node. Name it Check for Update Success.

Set Property to payload and Rules to is empty.
Add 1 output.

Connect the switch node's output to a change node. Name it Success Message.

Set msg.payload to str "Recipe updated successfully".

Connect the change node to a ui-notification node to display the success message on the dashboard.
Deploy the flow, open the dashboard, and try selecting different recipes and updating them.

For practice, we use an SQLite database. However, since your recipe is often used across an entire production line, it is recommended to store it in a dedicated database instead of locally in SQLite. This ensures it is accessible to all systems and can be utilized by other components in the workflow.

Note: This is just a simple demo we built. When using it in a production environment, you might need to make additional considerations based on your specific requirements."

A demonstration of the dynamic form for recipe updates in action, showing how it streamlines data entry and submission.

Below is the complete flow of the system we built.

Conclusion

So, getting your factory data digital doesn't have to be a headache. Relying on paper or tricky old systems just causes slowdowns and mistakes. Plus, many digital form tools are too complicated or don't play nice with your current setup.

That's where FlowFuse comes in. It lets your engineers build exactly what they need for the factory, using simple drag-and-drop tools – no coding required. This means you can ditch the manual steps, cut down on errors, save time, and even lower your IT costs.

Also wiith FlowFuse, you get accurate, real-time data and better control, helping your factory run smarter and much more efficiently.

Want to see how FlowFuse can reduce costs, boost profits, and increase production? Get in touch with us.

MES: What It Is and Why You Need It for Your Factory

2025-06-05T00:00:00Z

Running a factory means constantly pushing for better production. You want to make more products, make them faster, and ensure they're all high quality. But often, the challenge is simply knowing what's actually happening on the factory floor, right now. Is a machine broken? Are we on track with our orders? Is the quality holding up? Getting these answers often involves manual checks, waiting for reports, or just guessing.

A Manufacturing Execution System (MES) solves this. It's the central system that connects your factory's production to its plans. It gives you clear, instant visibility and control over every step on your shop floor.

Whether you've managed factory operations for years or are just starting to understand how they work, the need for this kind of clarity is universal.

In this article, our goal is to make sure you clearly understand exactly what an MES is and, just as importantly, what it isn't. We'll explore why it's a critical tool for any modern factory that wants to produce better, faster, and with fewer problems, and we'll look at its major components.

What is MES?

A Manufacturing Execution System (MES) is the operational backbone of a modern factory. It's not merely a software program, but a dynamic, integrated system designed to bridge the crucial gap between your enterprise-level business planning and the real-time execution of production on the shop floor.

Think of MES as the intelligent conductor of your manufacturing orchestra. It orchestrates all the elements of production – machines, materials, people, and processes – in real-time, ensuring that your strategic plans translate into tangible products efficiently and effectively.

The MES collects real-time information to tell you:

What products are currently being built.
How many of them are finished.
Which machines are working, and if any are having issues.
What materials are being used up.
If the quality of the products is good, right as they're being made.

This means you always know the exact status of your production, live. Such real-time insights and operational control are at the core of what a modern MES delivers, often leveraging flexible platforms like FlowFuse to connect diverse factory data and orchestrate workflows.

What MES is NOT

It's easy to get confused about all the different computer systems in a factory. To really get what a MES does, it helps to know what it isn't.

Many people think an MES is the same as their ERP system. But that's not quite right. Your ERP (Enterprise Resource Planning) handles the big company plans like money, sales orders, and buying materials for the long run. An MES doesn't do this planning. Its job is focused purely on the factory floor, managing what's happening right now to build products. It makes sure the production plans actually get done.

Another common confusion is that an MES is like a SCADA or PLC system. Again, this isn't accurate. SCADA (Supervisory Control and Data Acquisition) and PLC (Programmable Logic Controller) systems are connected directly to individual machines. They tell machines what to do—like turning them on or off—and collect basic data from them. An MES doesn't control machines directly. Instead, the MES acts like the main manager for the whole factory's production. It gathers information from those machine controllers (SCADA/PLCs) and uses it to oversee the entire process, including guiding workers, checking quality, and making sure all the machines work together to finish an order.

So, while ERP plans the business, and SCADA/PLC run the machines, the MES is the crucial system that manages the actual production process that happens in between.

Where Does MES Sit in Your Factory?

To truly get the clear view and control you need over your factory's operations, it helps to understand exactly where a MES fits. Your factory's computer systems are often set up in different layers, a common way to organize them is by following the ISA-95 standard.

Your MES sits right in the crucial middle layer. It acts as the key link between the big plans made higher up and the actual machines doing the work.

[MES System in the isa-95 layers]

At the very top, you have your main planning system, usually an ERP. The MES takes the plans from this ERP. Its job is to ensure they are carried out perfectly on the factory floor, moment by moment, guiding and watching every single step of making your products. Below the MES are systems like SCADA. The MES tells these systems what to do with the machines, and they send live information back, giving you an instant picture of production.

So, the MES is the central connection. It joins your company's big plans with the exact, real-time work on the factory floor

Why Your Factory Needs MES

Your factory needs to do more than just make products. It needs to stay ahead of rivals, innovate, and boost profits. An MES helps your factory achieve these important goals.

Here's why an MES is vital for your factory:

You'll always be ready: Instead of just fixing problems, you'll see them coming. This helps you make things better and react quickly to changes.
Top quality, every time: An MES helps you check and control quality at each step. This means fewer mistakes, and customers will trust your brand more.
Make the most of everything: You'll use your machines, materials, and people better. This cuts down on waste and makes sure every part of your factory works at its best.
Easier to innovate: With good data and clear processes, you can try new ideas and bring better products to market faster.
Increased profits: By making things more efficiently, cutting errors, and delivering on time, an MES directly helps your factory earn more money and grow.

An MES isn't just another system. It's a key tool that helps your factory become smarter, more responsive, and more profitable.

Essential Modules of MES

As mentioned earlier, MES isn't just one big piece of software; it's made up of several important parts that work together to manage your factory floor.

One key part helps with scheduling and dispatching production – it decides what specific jobs need to be done, when, and on which machines. Another important piece is for managing all your resources, meaning it keeps track of your equipment, tools, and even your people, making sure everything is available when needed.

Then there's the part that handles data collection, gathering all the live information directly from machines and sensors on the floor. This ties into quality management, which makes sure products meet standards at every step by guiding checks and recording results. An MES also includes product traceability, building a complete history for every item, so you always know what went into it and how it was made. Finally, there are components for performance analysis, showing you how well your production is running, and often for maintenance management to help keep machines in good working order.

These parts all connect to give you full control and insight into your manufacturing process.

Major Challenges with MES

While an MES offers huge benefits, putting one in place and getting the most out of it can have its challenges. It's important to know what these might be so you can plan for them.

First and foremost challenge is cost and time to implement MES. Investing in an MES can be expensive upfront, including the software, hardware, and the considerable time it takes to set it up correctly across your factory. Beyond that, getting all your machines to talk to the MES can be complex, especially with older equipment from different manufacturers – it's like getting everyone to speak a single language. Another hurdle is changing how people work; employees may need significant training and can resist new ways of doing things. Also, choosing the right MES system from many options to perfectly fit your factory's unique needs can be tough. Finally, an MES needs ongoing care, updates, and adjustments as your factory changes. Without this, it might become outdated. Plus, the system is only as good as the data it gets; if the information isn't accurate, the MES won't provide reliable insights, making data quality a continuous effort.

How FlowFuse Solves These Challenges

So, how can we solve these problems, especially the ones related to getting started, integrating machines, and training people? This is exactly where FlowFuse steps in as a powerful solution. FlowFuse is a platform which directly addresses several of the major challenges we just discussed. Its visual, "drag and drop" interface means that engineers and factory personnel can build and deploy solutions much faster, significantly cutting down on the time and specialized talent usually needed for MES implementation and customization. This reduces the need for complex coding or developing deep programming skills.

FlowFuse also excels at connecting diverse systems. Its vast library of nodes allows for easy integration with a wide range of industrial equipment, sensors, and existing IT systems, solving the complex problem of getting older machines or systems from different vendors to "talk" to each other without extensive custom development. This also enhances flexibility, as you can easily adapt and extend your MES functionality as your factory needs evolve. Furthermore, ensuring good data quality is made easier with the platform's powerful data transformation capabilities, allowing you to clean, filter, and structure raw data effortlessly, ensuring your MES always operates with accurate insights. By simplifying integration and development, and reducing the reliance on highly specialized coders, FlowFuse can dramatically lower the overall cost of implementing and maintaining an MES.

In our upcoming articles, we will go deeper. We plan to explain and practically demonstrate how FlowFuse can be used to build your own MES, giving you the control and flexibility you need without the typical high investment or the need to buy a pre-packaged system. Stay tuned to see how you can create a tailored MES solution for your factory with FlowFuse.

If you're ready to explore how FlowFuse can help you build a modern MES tailored to your factory, get in touch with our team today. We'd love to learn about your needs and help you take the next step toward a more efficient and profitable factory.

FlowFuse 2.18: Smarter Monitoring, AI Integration, Improved DevOps, and a preview of exciting things to come

2025-06-05T00:00:00Z

This release is focused on improvements that help you manage and optimize the performance of your Node-RED instances and takes an important step in integrating AI with FlowFuse so that you can build applications even more quickly.

Enhanced Observability for Better Performance Management

Screenshot of Performance Feature

Understanding how your Node-RED instances perform is crucial for maintaining reliable applications. Our new observability feature provides detailed CPU usage metrics at both the instance and team levels, giving you the visibility needed to optimize performance and troubleshoot issues before they impact your operations.

With these insights, you can make informed decisions about scaling your instances, identify performance bottlenecks, and ensure your Node-RED instances run smoothly in production environments. This feature is available exclusively for Enterprise customers, providing the enterprise-grade monitoring capabilities your organization needs.

Blueprint: OpenAI LLM with Chat Agent

Video of OpenAI LLM Blueprint demo

We're bringing AI speed and power directly to your FlowFuse Dashboard. The new LLM Blueprint enables you to deploy an AI chat agent that can query and analyze data connected to your FlowFuse environment.

This Blueprint makes it simple to surface insights relevant to your Node-RED flows, allowing team members to ask natural language questions and get immediate answers about their connected systems and devices. Whether you're monitoring sensor data, analyzing trends, or troubleshooting issues, the AI chat agent will speed up your workflow.

Check out the video demo to see it in action, featuring the agent connected to a worldmap node!

To put this Blueprint to use, check out the Blueprint page for OpenAI LLM Chat Agent.

Complete Git Integration with Pull Support

Building on our previous Git push functionality, we've now added Git pull support, completing the core Git integration experience within FlowFuse.

You can now seamlessly synchronize changes from your remote repositories, collaborate more effectively with team members, and maintain consistent version history across your Node-RED projects.

More details are available in the Git Integration changelog.

Self-Hosted Blueprint Support

Organizations running self-hosted FlowFuse installations can now take advantage of the Blueprints we publish, bringing the same rapid development capabilities to on-premises and private cloud deployments.

Self-hosted installations will automatically pull down the blueprint library, and will stay up to date when we publish new blueprints.

This update ensures that all FlowFuse users, regardless of their deployment model, can benefit from our growing library of pre-built solutions.

Where are we headed?

Our Engineering team is hard at work on the next major developments in bringing the speed of AI to FlowFuse, developing AI functionality that will be integrated directly into the Node-RED editor. This upcoming feature set will dramatically accelerate your development process, helping you build and deploy applications faster than ever before.

By combining AI assistance with Node-RED's visual programming approach, we're creating a development experience that's both more intuitive for newcomers and more powerful for experienced developers.

Here is a sneak peek of something we're working on: an AI chat in the Node-RED editor that allows you to ask questions about the instance you are working in.

What else is new?

For a full list of everything that went into our 2.18 release, you can check out the release notes.

We're always working to enhance your experience with FlowFuse. We're always interested in your thoughts about FlowFuse too. Your feedback is crucial to us, and we'd love to hear about your experiences with the new features and improvements. Please share your thoughts, suggestions, or report any issues on GitHub.

Which feature do you think you're most likely to use? Email me directly and let me know! You can reach me at greg@flowfuse.com.

Together, we can make FlowFuse better with each release!

Try FlowFuse

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is FlowFuse Cloud.

Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

Connect Your Shop Floor to Your ERP – Odoo Edition

2025-06-02T00:00:00Z

A major problem in manufacturing today is when your ERP system isn't getting real-time information from the factory floor. This gap causes big issues, like ordering too much material because inventory numbers are old, or missing important production deadlines. This lack of instant, correct information directly leads to higher costs and lost opportunities for your business.

This problem often comes from old ways of recording data. Many factories still rely on paperwork, which takes up valuable space, and manual entries. These methods require extra human effort, causing big delays and added costs. These old, error-prone ways are simply not sustainable for modern manufacturing.

This post gives you a vital solution. We'll show you how to connect your factory floor directly to your ERP system using FlowFuse. This way, you'll see near real-time data in your ERP, helping you avoid issues such as costly over-orders, missed deadlines, and the burdens of excessive paperwork. For this article, we'll focus on integrating with the popular ERP system, Odoo.

Basic Demo: Automating Production Data from the Shop Floor to Odoo with FlowFuse

Before we start diving into how you can connect your shop floor to ERP, let's first see a simple demo. This basic demo shows how FlowFuse acts as a smart link, making sure your production line data is always accurate in your ERP. We're doing this with a Raspberry Pi running the FlowFuse Agent, which talks to a Siemens S7 PLC. A counter in the PLC, which ticks up every second to act like products being made, is precisely read using the S7 protocol through FlowFuse. This accurate count is then automatically sent to Odoo as the quantity for a "table leg product," keeping your inventory data always up-to-date.

This is just a simple example of what FlowFuse can do. But it has much more power! Imagine FlowFuse also checking your production orders (MOs) in your ERP to see what you need to make. It can look at your Bills of Material (BOMs) in your ERP to figure out all the parts required. If it sees you're short on something, it can automatically create purchase orders in your ERP to buy the missing parts. It can even make new manufacturing orders for components you need to build.

Below is the complete flow for this demo, in case you would like to explore it further or try it out yourself after reading the article

Getting Data Into and Out of Odoo with FlowFuse

In this section, we will show you how you can connect your ERP (Odoo) with your shop floor using FlowFuse. This connection lets you read information, create new records, update existing ones, and search for specific data, bringing real-time factory insights right into your business system.

Prerequisites

Before you begin, make sure you have the following:

Running FlowFuse Instance: Make sure you have a FlowFuse instance set up and running. If you don't have an account, check out our free trial.
node-red-contrib-odoo-xmlrpc-filters-fields: Ensure you have node-red-contrib-odoo-xmlrpc-filters-fields installed. This package will enable operations like reading, creating, updating, and searching data, with specific capabilities for filtering records and selecting precise fields.

Configuring the Odoo Connection Node

Before you can send or receive any data from Odoo, FlowFuse needs to know how to connect to your Odoo instance. This is a one-time setup for your connection details, which can then be reused across all your Odoo nodes in FlowFuse.

Drag any odoo-xmlrpc node (like odoo-xmlrpc-read or odoo-xmlrpc-create) onto your Node-RED canvas.
Double-click on the node to open its configuration.
Next to the "Host" field, click the pencil icon to add a new Odoo connection.
In the configuration dialog, you'll need to enter your Odoo instance's details:

Host URL: This is the web address of your Odoo instance (e.g., https://databaseName.odoo.com).
Database: The name of your Odoo database.
Username: Your Odoo login username (e.g., your email address).
Password: Your Odoo login password.

Click "Add" to save this configuration.

Configuring Odoo Node

Now, any odoo-xmlrpc node you use can select this saved host configuration, meaning you only have to enter your credentials once.

Note: These configuration details (Host, Database, Username, Password) are confidential. To prevent exposing them when sharing your flows, it's crucial to use FlowFuse Environment Variables. These variables allow you to store sensitive information securely outside of your flow code. For more information, refer to our guide on Environment Variables in Node-RED.

Understanding Odoo Models

Once your connection is set up, the next key concept for interacting with Odoo is understanding Models. In Odoo, a "model" represents a specific type of business object or data record, much like a table in a traditional database. Every piece of data you want to read, create, update, or delete belongs to a specific model.

Common Odoo models relevant to manufacturing include:

product.template: For general product information (e.g., product names, descriptions).
stock.quant: For inventory quantities and locations.
mrp.production: For manufacturing orders/production orders.
res.partner: For contacts (customers, suppliers).
stock.picking: For internal transfers or delivery orders.

When you use an odoo-xmlrpc node in FlowFuse, you'll always need to specify which model you want to work with. If you're unsure of a specific model's name, you can often find it by enabling "Developer Mode" in your Odoo instance and hovering over fields in the Odoo interface.

Let’s get started. When explaining each operation, I will demonstrate it using different models such as product.product or mrp.production. This is just for demonstration and your understanding. You can perform these operations in the same way with other models—just make sure to pass the correct parameters according to the model and its data.

Reading Data from Odoo

To read data from Odoo, you'll use the odoo-xmlrpc-search_read node. This node requires you to send the id (or ids) of the record(s) you wish to read to this node with msg.payload. The msg.payload should contain an array of the IDs you want to read.

Here is how you can read products data:

Drag an inject node onto your canvas.
Connect it to a change node. Here, you'll set the query details:

Set msg.payload to the following array:

[ID]

Replace ID with the actual product ID you want to read. You can include multiple IDs, for example:

[1, 5, 12]

Connect the change node to an odoo-xmlrpc-search_read node. Select your Odoo connection, enter model to product.product (or the Odoo model you want to query).
Connect to a debug node to view the data.
Deploy the flow and click the inject node button to see the result.

Creating New Record in Odoo

To create new records in Odoo using FlowFuse, use the odoo-xmlrpc-create node. This node requires you to send an array of objects containing the record information as msg.payload. The array can include multiple objects, allowing you to create multiple records at once.

Here is how you can create manufacturing order:

Drag an inject node onto your canvas and set it to trigger manually.
Connect it to a change node. Configure it to set msg.payload with the details for your new Odoo manufacturing order:

Set msg.payload to:

[{
    "product_id": 39,      
    "product_qty": 500,     
    "product_uom_id": 1 
}]

Connect the change node to an odoo-xmlrpc-create node. Select your configured Odoo connection for its Host and enter model to mrp.production
Connect the odoo-xmlrpc-create node to a debug node to see the ID of the new record Odoo creates.

Updating Existing Data in Odoo

To modify existing records in Odoo using FlowFuse, you'll use the odoo-xmlrpc-update node. This node requires the ID of the record(s) you want to update and the new values for the fields you wish to change. The msg.payload should contain an array, where the first element is a list of record IDs and the second element is an object with the fields to update.

Here is how you can update the status of manufacturing order:

Drag an inject node onto your canvas. Configure it to trigger manually.
Connect it to a change node. This node will prepare the msg.payload with the order ID and the new status.

Set msg.payload to :

[
    [13],
    {"state": "progress"}
]

Connect the change node to an odoo-xmlrpc-update node. Select your configured Odoo connection for its Host and enter model to mrp.production.
Connect the odoo-xmlrpc-update node to a debug node to confirm the update operation. (A successful update typically returns true or an empty payload).
Deploy the flow and click the inject node button to see the result.

Deleting Records from Odoo (Unlink)

To delete records in Odoo using FlowFuse, you'll use the odoo-xmlrpc-unlink node. This node requires you to send the id (or ids) of the record(s) you wish to remove. The msg.payload should contain an array of the IDs you want to delete.

Here is how you can delete product from inventory:

Drag an inject node onto your canvas. Configure it to trigger manually.
Connect the inject node to a change node. This node will prepare the msg.payload with the ID(s) of the record(s) to delete.

Set msg.payload to a JSON array containing the ID of the manufacturing order to delete:

[16]

Connect the change node to an odoo-xmlrpc-unlink. Select your configured Odoo connection for its Host and enter model to mrp.production.
Connect the odoo-xmlrpc-unlink to a debug node to confirm the unlink operation.
Deploy the flow and click the inject node button to see the result.

Advanced Search with Filters and Fields

For advanced queries, you'll use the odoo-xmlrpc-search_read node. This versatile node combines the ability to search for records using complex criteria (filters) and to retrieve only the specific data fields you need from those results.

Understanding Filters

Filters are conditions you apply to narrow down your search results. They are structured as a list of lists, where each inner list defines a single condition: [field, operator, value].

field: The name of the Odoo field you want to filter by (e.g., qty_available, state, name).
operator: How you want to compare the field. Common operators include:
- =: Equal to
- !=: Not equal to
- >: Greater than
- <: Less than
- >=: Greater than or equal to
- <=: Less than or equal to
- in: Value is in a list (e.g., [["id", "in", [1, 2, 3]])
- not in: Value is not in a list
- ilike: Case-insensitive "like" (contains substring)
- =like: Case-sensitive "like"
value: The value you're comparing against.

When you include multiple conditions within your filters list, Odoo treats them as an "AND" relationship by default. This means all conditions must be true for a record to be returned.

Example Filters:

[[["list_price", "<", 10]]]: Find products with less than 10 units in stock.
[[["state", "=", "progress"], ["product_id", "=", 38]]]: Find manufacturing orders for a specific product that are currently "in progress."
[[["name", "ilike", "coating"]]]: Find products where the name contains "coating" (case-insensitive).

Understanding Fields

The fields parameter allows you to specify exactly which columns or properties you want to retrieve for the matching records. This is important for efficiency, as it avoids pulling unnecessary data, making your flows faster and your payloads smaller.

Structure: A simple list of field names (e.g., ["name", "qty_available", "default_code"]).

Controlling Results: Offset and Limit

For larger datasets, you'll want to control how many records are returned and where the results start.

offset: This parameter specifies the number of records to skip from the beginning of the result set. It's useful for pagination.
limit: This parameter specifies the maximum number of records to return in a single query. It's crucial for managing the amount of data you retrieve.

Example Flow

Here’s an example FlowFuse flow to find products with list price (more than 1000) that are also marked as "saleable" in Odoo, retrieving only their name, quantity, internal reference, and list price, and limiting the results.

Drag an inject node onto your canvas and configure it to trigger manually.
Connect it to a change node. This node will define your search criteria (filters and fields) and also set the offset and limit.

Set msg.filters to JSON:

[[
    ["list_price", ">", 1000],
    ["sale_ok", "=", true]
]]

Set msg.fields to JSON:

["name", "qty_available", "default_code", "standard_price"]

Set msg.offset to Number 0 (Start from the first record).
Set msg.limit to Number 5 (Retrieve a maximum of 10 records).

Connect the change node to an odoo-xmlrpc-search_read node. Select your configured Odoo connection.
Connect to a debug node to inspect the filtered and selected data in the debug sidebar.
Deploy the flow and click the inject node button to see the result.

Final thought

So, we've talked about how those manual data methods—paper, spreadsheets—can really slow things down, cause mistakes, and cost money in your factory. And let's be honest, many digital fixes out there just add more complexity or demand specialized coding skills that your team might not have.

This is where FlowFuse comes in. FlowFuse is a platform made for factory floors that runs on your devices right there. It connects to all your machines, old or new, and even your ERP systems like Odoo. FlowFuse collects, cleans, and moves your data. It helps your engineers, who know your operations best, build industrial applications and solutions using simple drag-and-drop actions. This means they can link your factory data directly to your ERP, getting rid of all those manual steps and saving your IT team time and money.

What's the real payoff? You get to see less wasted time and money, fewer mistakes with accurate, real-time data, and simply better control over your whole factory. FlowFuse helps your entire operation run smarter and more reliably. If you're looking for a practical way to bring these kinds of improvements to your own manufacturing processes, we'd be glad to discuss how FlowFuse can assist. Get in touch here

Designing Flexible Cron Schedules in FlowFuse with Node-RED

2025-05-15T00:00:00Z

Automation isn’t just about reacting to events—sometimes it’s about doing things at the right time. In Node-RED, the Inject node is great for triggering flows at set intervals, but it’s limited when you need more control. Cron jobs offer precise scheduling, letting you set up custom times for your tasks. In this guide, we'll show you how to create flexible cron schedules in FlowFuse with Node-RED, so your flows run exactly when needed.

What is a Cron Job?

Let’s kick things off by demystifying what a cron job actually is. You’ve probably heard the term before, and while it might sound complex, it’s really just a way of setting up tasks to run at specific times — automatically.

Think of it this way: with Node-RED’s Inject node, you can trigger tasks at intervals like every 5 seconds, every minute, or even on specific weekdays at set times (for example, every Monday, Tuesday, or Sunday). But when you use cron jobs, you gain much more control over the timing.

For example, you can trigger a task every two hours, only on weekdays, but skip holidays or run a job every 5 minutes during business hours, but only in the first week of each quarter. You can even schedule flows to run at 6:45 AM on the last Friday of every month, or at 11:59 PM on the last day of the year — these kinds of patterns are either extremely complex or completely unachievable using just the Inject node.

The magic of cron lies in its ability to express complex time logic in a simple, compact format — perfect for orchestrating automation schedules that go well beyond what the basic Inject node can offer.

Prerequisites

Before we start building flexible cron schedules in FlowFuse, make sure you have the following in place:

Running FlowFuse Instance: Make sure you have a FlowFuse instance set up and running. If you don't have an account, check out our free trial and learn how to create an instance in FlowFuse.
node-red-contrib-cron-plus: Ensure you have node-red-contrib-cron-plus installed, It’s developed by Steve, a software engineer here at FlowFuse and one of the core maintainers of Node-RED.

Building Scheduled Automations with cron-plus

Now that you understand what cron jobs are and why they’re useful, let’s dive into building them inside Node-RED using the cron-plus node. When working with cron-plus, you’ll encounter different types of schedules—each suited for different needs—and varying levels of complexity depending on what you're trying to automate.

At the most basic level, you can define static schedules using familiar cron expressions (like "every 5 minutes" or "at 8:00 AM daily"). As you progress, you’ll learn to use solar event triggers (like sunrise or sunset), create date-specific schedules, and even manage schedules dynamically at runtime—adding, removing, or modifying them based on incoming data or user interactions.

In this section, we’ll walk through each of these layers step by step, starting with the simplest use cases and gradually moving into more powerful and flexible scheduling techniques—giving you full control over when and how your flows run.

Tip: This article draws information from the node’s README, which is highly informative. I recommend going through it as well for more details.

Static Schedules

The most straightforward way to use cron-plus is to define static schedules using cron expressions. These are pre-configured inside the node and run on a fixed pattern—perfect for predictable, repetitive tasks. For example we need to Trigger a flow every day at 8:00 AM.

Drag and drop the cron-plus node onto your Node-RED workspace.
Double-click on the cron-plus node to open its configuration panel.
If no schedules are configured yet, click the +add button to add a new schedule. Enter the following:
- Schedule Name: e.g., "Daily 8 AM"
- Topic: Enter a topic to send with the message when triggered, such as "daily-trigger".
- Payload: Choose what payload you want to send when the cron job triggers, such as "Triggering Flow at 8 AM".
Select Cron from the Schedule Type dropdown.
In the Schedule field, enter the following cron expression to run the task at 8:00 AM every day:

   0 8 * * *

A cron expression is composed of five fields (sometimes six or seven, depending on the system) that determine the schedule for executing tasks. Below is a breakdown of each field that node-red-contrib-cron-plus supports:

Field	Possible Values	Special Symbols
Second (optional)	`0-59`	`* / , -`
Minute	`0-59`	`* / , -`
Hour	`0-23`	`* / , -`
Day of Month	`1-31`	`* / , - ? L W`
Month	`1-12` or `JAN-DEC`	`* / , -`
Day of Week	`0-6` or `SUN-SAT`	`* / , - ? L #`
Year (optional)	`1970-2099`	`* / , -`

Here are some examples of how you can use the special symbols and shorthand's:

Symbol	Meaning	Example	Explanation
`*`	All possible values	`* * * * *`	Every minute of every hour, day, month, and weekday
`?`	No specific value	`0 0 12 ? * MON`	At 12 PM Only on Mondays (no specific day of the month)
`-`	Range	`0 10-12 * * * *`	Minutes 10, 11, and 12 of every hour
`,`	List of values	`0 0 12 * 1,3,5 *`	At 12 PM only in January, March, and May
`/`	Step values	`/15 * * *`	Every 15 minutes (00, 15, 30, 45)
`L`	Last	`0 0 12 L * *`	12 PM on the last day of the month
`W`	Nearest weekday	`0 0 0 15W * * *`	At midnight on the nearest weekday to the 15th of the month
`#`	nth weekday of the month	`0 0 0 * * MON#1 *`	At midnight on the first Monday of the month

Connect the cron-plus node to other nodes (e.g., a debug node or an action node) to specify the actions when the flow is triggered.
Click Deploy to save and activate your flow. The cron-plus node will now trigger your flow every day at 8:00 AM.

Here are some advance patterns:

Every weekday at 9:30 AM

30 9 * * 1-5

Every hour

0 * * * *

Every 15 min during work hours (Mon–Fri, 9–5)

*/15 9-16 * * 1-5

First Monday of the month at 10:00 AM

0 10 * * MON#1

Last Friday of the month at 6:45 AM

45 6 ? * FRIL

Easy Builder Feature

To make it even easier to create and customize cron patterns, the cron-plus node includes a feature called Easy Builder. This feature provides a user-friendly interface that lets you quickly generate and adjust cron expressions without needing to write them manually. You can select options like time intervals, days of the week, and more, and the Easy Builder will generate the correct cron syntax for you.

Image showing the easy builder feature

Solar Event Schedules

Solar event-based triggers are a great feature in cron-plus for automating tasks based on sunlight events like sunrise, sunset, dawn, and dusk. You can fine-tune your triggers with offsets, like triggering an action 30 minutes after sunset.

Here are the solar events you can use:

nightEnd: End of night, start of twilight.
nauticalDawn: Horizon becomes faintly visible, used by sailors.
civilDawn: Light enough for outdoor activities without lights.
sunrise: Sun first visible on the horizon.
sunriseEnd: Full sun above the horizon.
morningGoldenHourEnd: End of the morning golden hour.
solarNoon: Sun is at its highest point in the sky.
eveningGoldenHourStart: Start of the evening golden hour.
sunsetStart: Sun starts to set.
sunset: Sun is fully below the horizon.
civilDusk: Last light before it gets dark.
nauticalDusk: Horizon is no longer visible, dark sky.
nightStart: Full darkness after twilight.
nadir: Darkest point of the night.

Let's start and learn how to use it. Suppose we need to trigger the flow 30 minutes after sunset. Here's how you do it:

Let’s start by setting up a flow that triggers 30 minutes after sunset. Here’s how:

Drag a new cron-plus node onto your Node-RED canvas.
Set the location — solar events depend on your geographic location. You can configure this at the node level or per schedule. In the Location field, either:
- Enter your latitude and longitude manually, or
- Click the three-dot icon to open a map and select your location.
Add a new schedule. Enter the following Schedule Name, Topic, Payload
Choose the solar event — set the Schedule Type to solar.
You can choose "All Solar Events" or "Selected Solar Events" to pick specific ones.
For this example, choose "sunset".
Set the offset — this defines how much earlier or later the trigger should happen compared to the solar event.
For 30 minutes after sunset, enter:
```
30
```
You can also use negative numbers (like -10 for 10 minutes before sunset) or larger values like 60 for 1 hour after.
Click Done, connect the node to the rest of your flow, and Deploy.

Your flow will now trigger 30 minutes after sunset every day — automatically adjusting for seasonal changes based on your location.

Date Sequence Schedules

While cron expressions and solar events are great for recurring patterns, sometimes you need to schedule flows to run at very specific, one-time moments—like a product launch, system maintenance window, or a holiday-specific action. This is where the Date Sequence schedule type in cron-plus comes in.

With this method, you can define exact dates and times (including timezone support), and the node will trigger your flow at those precise moments—once or multiple times, depending on the list you define.

The sequence field supports:

UNIX timestamps (in milliseconds)

1767225600000

Date and time (in plain text)

2026-04-03 00:00

Date and time with timezone

2026-04-06 12:00 GMT+0

You can list multiple times, separated by commas:

1767225600000, 2026-04-03 00:00, 2026-04-06 12:00 GMT+0

Let’s learn how to set this up:

Drag a new cron-plus node onto the canvas.
Double-click the node to open its settings.
Click +add to create a new schedule.
Give the schedule a name and configure the topic — this is the value that will be sent with the message when the schedule triggers.
Set the payload to whatever message or data you want to send when triggered.
Choose Date Sequence from the Schedule Type dropdown.
In the Expression field, enter one or more dates using any of the 8. supported formats we discussed above (UNIX timestamp, plain date/time, or date/time with timezone). You can separate multiple values with commas.
Click Done, then connect the cron-plus node to the rest of your flow (e.g., a debug node to see it trigger, or an action node to perform something).
Finally, click Deploy to save and start your schedule.

The flow will now trigger exactly at each date and time you've specified.

Handling Time Zones and Daylight Saving Time (DST)

When dealing with scheduled tasks, managing time zones and Daylight Saving Time (DST) is crucial to ensure your cron jobs trigger at the correct local time. With cron-plus in Node-RED, this is made easy. Cron-plus provides global time zone support, allowing you to specify the time zone for all schedules within a particular cron-plus node. When configuring the cron-plus node, you'll see an input field labeled "Timezone", where you can start typing your desired time zone and select from suggested options.

Screenshot showing the Timezone input field in the cron-plus node configuration with auto-suggestions while typing

For example, if your tasks need to run in the Eastern Time Zone, you would enter "America/New_York" in the Timezone field. Similarly, for the UK time zone, you would enter "Europe/London".

When scheduling tasks in a time zone that observes Daylight Saving Time (DST), cron-plus will automatically adjust your task’s execution times to account for the DST changes. If you set a schedule for 8:00 AM daily, cron-plus will ensure that the task triggers at 8:00 AM local time, whether it's during Standard Time (e.g., EST) or Daylight Saving Time (e.g., EDT).

When DST begins (e.g., in spring), cron-plus will shift the scheduled task forward by one hour. Similarly, when DST ends (e.g., in fall), the task will shift back by one hour. This automatic adjustment is handled based on the time zone you enter.

Understanding Node Status Symbols and Their Descriptions

The cron-plus node visually indicates its state using status markers in the flow editor:

● (Dot): Indicates a static schedule configured directly in the node.
○ (Ring): Indicates a dynamic schedule added via input messages.

Also, the node indicates the next event, along with the type of schedule. For example, node in the following image specifies that the next event is on May 26, 2025, at 12:00 AM GMT +5:30. It is a static schedule, and its name is 'Schedule1'

A node showing the next event scheduled for May 26, 2025, at 12:00 AM GMT +5:30 with a static schedule named 'Schedule1'.

Dynamic Schedule Control via Input Messages

In some cases, you might not know your schedule ahead of time—or you may want it to change based on user actions or incoming data. The cron-plus node supports this with dynamic control using input messages. This means you can add, update, or remove schedules while your flow is running, without opening the editor. It’s a powerful way to make your automations more responsive and adaptable.

Each control message is sent to the cron-plus node using a specially formatted msg.payload with a command and associated configuration.

Below are some examples of dynamic commands. Please refer to the built-in help of the cron-plus node for more details:

Command	Description	Example
`trigger`	Triggers a schedule by name.	`{ "command": "trigger", "name": "dynamic-1" }`
`add`	Add (or update) a dynamic schedule.	`{ "command": "add", "name": "dynamic-1", "topic": "dynamic-schedule", "payloadType": "default", "expressionType": "cron", "expression": "/2 * * *" }`
`remove`	Removes a specific schedule by name.	`{ "command": "remove", "name": "dynamic-1" }`
`start`	Starts a specific schedule by name.	`{ "command": "start", "name": "dynamic-1" }`
`stop`	Stops a specific schedule by name.	`{ "command": "stop", "name": "dynamic-1" }`
`pause`	Pauses a specific schedule by name.	`{ "command": "pause", "name": "dynamic-1" }`
`export`	Exports a schedule by name.	`{ "command": "export", "name": "dynamic-1" }`
`status`	Provides the status of a specific schedule by name.	`{ "command": "status", "name": "dynamic-1" }`
`describe`	Provides a human-readable description of a cron or solar expression.	`{ "command": "describe", "expression": "0 8 * * 1-5", "expressionType": "cron" }`

Commands can also include a filter to operate on multiple schedules at once. Below are a few examples. Please refer to the built-in help of the cron-plus node for more details:

Filter	Description	Example
`-all`	Operate a command on all schedules.	`{ "command": "start-all" }`
`-all-dynamic`	Operate a command on all dynamic schedules.	`{ "command": "export-all-dynamic" }`
`-all-static`	Operate a command on all static schedules.	`{ "command": "pause-all-static" }`
`-all-active`	Operate a command on all active schedules.	`{ "command": "stop-all-active" }`
`-all-inactive`	Operate a command on all inactive schedules.	`{ "command": "start-all-inactive" }`
`-all-active-static`	Operate a command on all active static schedules.	`{ "command": "stop-all-active-static" }`
`-all-active-dynamic`	Operate a command on all active dynamic schedules.	`{ "command": "stop-all-active-dynamic" }`
`-all-inactive-static`	Operate a command on all inactive static schedules.	`{ "command": "start-all-inactive-static" }`
`-all-inactive-dynamic`	Operate a command on all inactive dynamic schedules.	`{ "command": "remove-all-inactive-dynamic" }`

Dynamic Demo 1

For example, we need to build a flow that triggers on UK public holidays to stop recording the OEE (Overall Equipment Efficiency) or lock the entry gates of the factory. To achieve this, we can integrate a UK public holiday API into our Node-RED flow, fetch the holiday data, and then trigger actions based on those holidays.

Drag the Inject node onto the canvas and set it to trigger on deploy after 0.1 seconds.
Next, drag the HTTP request node onto the canvas, set the method to GET, and use the URL https://www.gov.uk/bank-holidays.json. Set the return to "parsed JSON object".
Drag the Function node onto the canvas and add the following JavaScript code into it:

// Retrieve public holidays for England and Wales from the API response
const engHols = msg.payload["england-and-wales"].events;

// Clear out any existing schedules before adding new ones
node.send({ topic: 'remove-all' });

// Create an array to hold the new holiday schedules
const newSchedules = [];

// Loop through all the holiday events
for (let index = 0; index < engHols.length; index++) {
    const hol = engHols[index]; // Get the current holiday
    const date = new Date(hol.date); // Convert the holiday date to a Date object

    // Skip holidays that are in the past (before the current date)
    if (date.valueOf() < Date.now()) {
        continue; // Skip to the next holiday
    }

    // Create a new schedule for upcoming holidays
    const newSchedule = {
        "command": "add", // Command to add a new schedule
        "name": hol.title + ` (${date.getFullYear()})`, // Holiday name with year
        "topic": hol.title, // Holiday title as topic
        "expression": hol.date, // Holiday date to use as an expression
        "expressionType": "dates", // Define the type as dates
        "payload": hol, // Send the holiday details as the payload
        "payloadType": "json" // Specify that the payload is in JSON format
    };

    // Add the new schedule to the list of new schedules
    newSchedules.push(newSchedule);    
}

// Set the topic as empty (not used for now)
msg.topic = '';
// Set the payload to the new schedules array created above
msg.payload = newSchedules;

// Return the updated message with new schedules
return msg;

Drag a cron-plus node onto the canvas. Connect the Inject node to the HTTP request node, the HTTP request node to the Function node, and the Function node to the cron-plus node.
Deploy the flow.

Now you can check the dynamic schedules list (see how at the end of this section).

Dynamic Demo 2

Additionally, I'd like to share another demo that Steve has prepared for the community, which demonstrates dynamic scheduling based on the best energy prices:

If you need to see the dynamic schedules of a specific node, double-click on it and click on the 'Dynamic Schedules' button from the configuration panel. This will show all of the dynamic schedules associated with that node.

Image showing the 'Dynamic Schedules' button and the list of all dynamically scheduled events.

As you can see, creating flexible and dynamic cron schedules Node-RED can give you complete control over your automation tasks. Whether it's simple, recurring events, or complex, time-sensitive triggers, the combination of cron expressions and dynamic controls allows for smarter, more efficient workflows.

Take some time to explore these features and experiment with your own schedules. The more you play around with them, the better you'll understand how to tailor your flows to meet your exact needs.

Thanks for reading, and happy automating! If you run into any questions or need assistance along the way, don’t hesitate to reach out. We’re here to help!

If you’re using Node-RED in your production environment, it’s important to keep your instances organized, scalable, and secure. FlowFuse can help with that by making it easier to manage and maintain your Node-RED setup, while also supporting faster deployment, scaling, and improved security.

Wrapping Up

Designing flexible and intelligent schedules is a key part of building robust automation with Node-RED. Whether you’re triggering actions based on time, solar events, or dynamic runtime conditions, the cron-plus node gives you a powerful set of tools to fine-tune when your flows should run.

By combining these scheduling techniques with the management features of FlowFuse, you can confidently build and operate reliable automation systems at any scale.

How to Embed Webpages on the FlowFuse Dashboard

2025-05-13T00:00:00Z

When you build a dashboard, sometimes you need more than just internal data. Maybe it’s a live map, a report hosted elsewhere, or another dashboard — whatever it is, having to switch tabs breaks the flow. FlowFuse lets you embed external content like web pages, dashboards, PDFs, and widgets right into your dashboard. This guide shows you how to do exactly that — step by step — so your team has everything they need, all in one place.

Why Embed Webpages in Your Dashboard?

Embedding external content directly into your FlowFuse dashboard can make your life a lot easier. Here’s why it’s worth considering:

Streamline Your Workflow: No more hopping between tabs or switching apps. Everything you need can be in one place.
Save Time on Rework: If you’ve already built a report, chart, or page somewhere else, just embed it into your dashboard. No need to start from scratch.
Quick Decisions: Having all your key data together helps you see what’s important at a glance and act faster.
Cut Down on Clicks: The fewer actions needed to get to your information, the more time you can spend on actually getting things done.

How to Embed Webpages On your FlowFuse Dashboard

Embedding external content into your FlowFuse dashboard is straightforward and flexible. In this section, you'll learn two ways to do it: using a direct URL and using embed code. We’ll also cover common issues you might face and how to fix them. Lastly, you'll see how to embed one FlowFuse dashboard inside another, making it easier to centralize important views in one place.

Prerequisites

Before you begin embedding webpages on FlowFuse Dashboard, make sure you have the following:

Running FlowFuse Instance: Make sure you have a FlowFuse instance set up and running. If you don't have an account, check out our free trial.
FlowFuse Dashboard: Ensure you have FlowFuse Dashboard (also known as Node-RED Dashboard 2.0 in the community) installed and properly configured on your instance.
@flowfuse/node-red-dashboard-2-ui-iframe: Ensure you have node-red-dashboard-2-ui-iframe installed.

Step 1: Obtain the URL or Embed Code of the Webpage You Want to Embed

The first step is identifying and grabbing the URL of the webpage or external content you want to embed into your FlowFuse dashboard. This could be a live dashboard, report, Google Maps, video, or any other type of content.

When embedding content from third-party sources, make sure the following conditions the page or content you're embedding should be publicly accessible or have the proper permissions for embedding. For example, private reports or webpages require login credentials or an API key, which should be handled securely.

Some websites may restrict embedding through iframes due to Cross-Origin Resource Sharing (CORS) policies. Check whether the external site allows embedding if the content doesn’t load properly.

Many platforms, such as YouTube and Google Maps, provide a specific "embed code or URL" that is more suitable for embedding. Ensure you use the correct embed link or code these platforms offer to guarantee smooth integration.

Once the URL or embed code is ready, move on to the next step.

Step 2: Embedding the Webpage on FlowFuse Dashboard

Now that you’ve gathered the URL or embed code for the external content you want to embed, it’s time to add it to your FlowFuse dashboard. Below are two methods for embedding external content:

2.1 Embed via URL

The easiest and most straightforward way to embed external content is by using the URL. FlowFuse's iframe node allows you to use an external URL directly. Here’s how to do it:

Drag the ui_iframe widget onto the canvas.
Double-click the widget to open its configuration dialog.
- Create a new group for it to render in.
- Set the size (width and height).
- Enter the URL you want to embed.

iframe widget configuration

Click Done and then Deploy.

For a quick hands-on practice, you can try embedding a weather widget, Google Maps, Google Calendar, or a hosted PDF on your dashboard.

Weather widget embedded in FlowFuse Dashboard

Google Map embedded in FlowFuse Dashboard

PDF embedded in FlowFuse Dashboard

Google Calendar embedded in FlowFuse Dashboard

2.2 Embed via HTML Embed Code

If you have an embed code from third-party services, you can use this code to embed the content into your FlowFuse dashboard. Here’s how to do it:

Drag the ui-template widget onto the canvas.
Double-click on it to open its configuration dialog.
- Create a new group for it to render in.
- Set the size (width and height).
Paste your embed code into the template widget. Most embed codes include both HTML and JavaScript, so follow this structure:

<template>
  <!-- Paste your HTML code here -->
</template>
<script>
  // Paste your JavaScript code here
</script>

Some services provide an iframe tag. In this case, you need only copy the URL and use the embedding via the URL method.

Click Done and Deploy to save your changes once you've added the code.

Animated weather widget on the Flowfuse dashboard, embedded with code.

Now that you’ve learned how to embed external content into your FlowFuse dashboard, one day you may need to embed your FlowFuse dashboard elsewhere—either on another FlowFuse dashboard or an external site. If you’ve tried and found that it’s not working as expected.

This is a security feature designed to protect your data. FlowFuse dashboards, like many other web applications, implement security policies such as Cross-Origin Resource Sharing (CORS) and the X-Frame-Options header. These policies ensure that your dashboard is only viewed in trusted environments, preventing malicious sites from tampering with your data or exposing it to unauthorized users.

However, if you need to embed your FlowFuse dashboard into other websites or on another FlowFuse dashboard, it’s possible to do so with some configuration changes. Below is a section on how to enable embedding securely of FlowFuse Dashboard:

Enabling Embedding of FlowFuse Dashboards

Go to your FlowFuse instance settings.
Switch to the editor settings and enable "Allow Dashboard to be embedded in an iFrame"

FlowFuse instance settings showing the option to allow dashboard embedding in an iframe.

Click Save Settings and restart your instance for the changes to take effect.

FlowFuse OEE Dashboard embedded in another FlowFuse dashboard.

FlowFuse dashboards offer great flexibility, making it easy to embed external content like weather widgets, maps, and PDFs directly into your workspace. With a few simple steps, you can also embed FlowFuse dashboards into other websites, ensuring everything you need is in one place.

Up Next

If you're interested in learning more about embedding webpages or enhancing your FlowFuse dashboards, check out the following blog articles:

Mapping Location on Dashboard: In this article, we dive into how you can embed location maps into your FlowFuse dashboard. Learn how to map locations, track real-time data, and make your dashboards more interactive and informative.
Generating PDF Reports with Node-RED and FlowFuse: This guide explains how to generate PDF reports directly with Node-RED and FlowFuse and how to preview these reports within your FlowFuse dashboards.

FlowFuse 2.17: Easier remote instance onboarding, Dashboard blueprint, PDF generation, and more

2025-05-08T00:00:00Z

This release is focused on improvements that help you get up and running with FlowFuse much more quickly. Our vision is that you can get started with FlowFuse and have a successful application up and running, from scratch, in hours, not days, weeks or months. This release gets us closer to that vision by focusing on improvements to the installation process for the Device Agent, and two new Blueprints.

Device Agent onboarding

If you already had a Node-RED instance running on a device, it was a bit of a hassle to get it connected to FlowFuse as a remote instance. You had to install the Device Agent, find that it clashed with your existing instance, turn off that instance, run the Device Agent again, find that you can't import your existing instance...and so on, until finally getting copies of your flows and adding them to FlowFuse manually.

Lots of friction. We heard you.

Now, when you install the Device Agent, it will automatically scan for an existing Node-RED instance running locally and help you import its flows into FlowFuse.

This streamlines the whole process, saving you valuable time and effort. It ensures you can manage the Node-RED flows running on your edge device as quickly as possible.

Blueprint: Getting Started with Dashboard

Screenshot of Getting Started with Dashboard

One of the most popular features of Node-RED is Dashboard 2.0. And starting now, getting started with Dashboard is as simple as one click.

Our new Getting Started with Dashboard Blueprint deploys to a new Node-RED instance in a single click and demonstrates several examples of how to use Dashboard. These include various ways of visualizing data, the data entry widget that allows direct entry to a table, and audit log creation.

New Dashboard nodes are added on a regular basis, and we will keep in mind which ones users would like help using as we iterate on this Blueprint.

To put this Blueprint to use, check out the Blueprint page for Getting Started with Dashboard.

Blueprint: PDF Report Generator

Screenshot of PDF Report Generator

Until now, creating a presentable report using data accessed in your Node-RED instance was a manual effort.

This new Blueprint makes it very easy to create PDF reports from your data. Using SQLite nodes and connecting to your database, this Blueprint enables drag-and-drop field selection.

To get you started using this Blueprint, we've included sample data that is generated automatically.

Instructions for using this Blueprint, including how to map fields from your database to our preconfigured fields, check out the Blueprint page.

Where are we headed?

We are focused on making it as easy as possible to get started with Node-RED, to manage Node-RED instances, and start building applications quickly. Some improvements on the way include pulling from a Git repo (we shipped Git push last release), including Blueprints for self-hosted installations, and better information about resource usage. We're also busy at work on a number of core Node-RED items for the forthcoming 4.1.0 release.

With this work and more on the way, we are continuing to deliver our vision of FlowFuse being the best way to unlock your industrial data, integrate everything and optimize faster.

What else is new?

For a full list of everything that went into our 2.17 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try FlowFuse

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is FlowFuse Cloud.

Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

Part 1: Building an Andon Task Manager with FlowFuse

2025-05-08T00:00:00Z

In modern manufacturing and service environments, speed and transparency are critical for addressing issues as they arise. An Andon system helps achieve this by enabling frontline workers to signal problems in real time, triggering quick responses from support teams.

However, many manufacturers struggle to find a solution that truly fits their needs. Some tools lack essential features, while others are overloaded with unnecessary ones that add complexity.

This blog series introduces a practical approach to building a real-time Andon Task Manager using FlowFuse and Node-RED. In this first part, the focus is on understanding the concept of an Andon system and laying the foundation for the solution.

What is the Andon Task Manager?

The Andon Task Manager is a digital system designed to streamline real-time issue reporting, escalation, and resolution tracking. Inspired by the traditional Andon systems used in lean manufacturing, it brings these concepts into a modern, cloud-enabled environment.

At its core, it’s a communication and response tool designed to improve transparency and speed on the factory floor or within service teams. Frontline workers can quickly raise issues—like equipment breakdowns, material shortages, or support needs—which are immediately sent to the right person or team. Once the issue is resolved, the responder updates the status so everyone stays informed and the task is properly closed.

What Problem It Solves?

In a typical manufacturing environment, multiple processes run simultaneously across large factory floors. Each area—or line—has specific machinery, workflows, and potential points of failure. When something goes wrong, quick and clear communication is essential. However, factories are often spread out, and support teams are divided across different departments (e.g., maintenance, quality control, safety, etc.).

In many cases, workers rely on informal or manual systems—such as radio calls, phone messages, or shouting across the floor—to report issues. These methods are inefficient, error-prone, and often delay response times. The lack of a structured, real-time communication system leads to:

Delayed responses because support staff are unaware of new issues
Lack of visibility into the status of reported issues = No accountability for weather the issue is acknowledged/resolved or not
Unstructured logging that makes follow-up or audits difficult

The Andon Task Manager solves this by acting as a centralized system where any frontline worker can quickly raise an issue. Once submitted, the request is instantly visible to the relevant department—without needing someone to manually assign it. This enables self-routing and real-time visibility, ensuring the right people take action quickly and efficiently, even when the requester and responder are in completely different parts of the factory.

Planning the Andon Task Manager

At the core of the system is the concept of a request. Every request represents a task or issue raised by an operator. To ensure traceability and clarity, each request should include key details. This structured format makes it easier for departments to manage and resolve issues efficiently.

Each request must include the following:

id: A unique identifier for the request.
line: The line or machine where the issue was raised.
department: The department responsible for resolving the issue.
created: The timestamp when the request was created.
acknowledged: Timestamp indicating when the request was acknowledged.
resolved: Timestamp indicating when the issue was resolved.
note: Text added by users for context or follow-up. Only predefined values for line and department should be allowed. These values will be managed through admin settings to ensure consistency across the system.

Defining Key Features

The system needs to support core operations that reflect how issues are reported and resolved in real-life factory environments. These features help ensure that tasks are handled efficiently and that everyone involved knows the current status.

The essential features include:

Request creation: Users select the line and department, enter a note, and submit a request.
Acknowledge requests: A responder can mark a request as acknowledged once they start working on it.
Resolve requests: After resolving the issue, the responder marks it as resolved.
View filtering: Requests can be filtered by line or department.
Admin tools: Admins can add and manage the list of departments and lines.
Status display: Requests display their current state — pending, acknowledged, or resolved.
Alerts: Visual or sound alerts for unacknowledged requests after a time threshold.

Each of these actions will be timestamped to provide a clear history of who did what and when.

Dashboard Visualization & UI Design

The next step after defining the core features is to design an intuitive and efficient dashboard for both frontline workers and admin users. A well-organized interface ensures quick interactions and smooth navigation, especially in settings where timely responses are crucial.

The system will support two user roles: admins and regular users. Regular users will have access to features such as submitting requests, viewing requests by department or line, and managing tasks within their area (e.g., acknowledging and resolving requests). Admins will have additional capabilities, including creating and managing departments and lines, and accessing all request data.

The regular user's view will be a single-page interface with dynamic content updates. Rather than traditional page navigation, content will update based on the user’s selection of a department or line. For example, when a user selects a production line, the request list and relevant controls will automatically update to display only the requests related to that line.

The admin view will have a dedicated view, including a form for creating new lines or departments and a table displaying all requests. This view will also feature a menu for quickly switching between specific department or line section, improving system management efficiency.

This design keeps the interface focused and responsive. It avoids unnecessary complexity while providing all necessary tools for users to perform their tasks efficiently — whether they are reporting an issue or managing overall operations.

The following dashboard image illustrates the intended design and key objectives of our Andon Task Manager.

Storage Mechanism

To ensure a simple and efficient data management system for the Andon Task Manager, we will use SQLite to store user requests. SQLite is a lightweight, easy-to-manage database that is well-supported in Node-RED through the node-red-contrib-sqlite node. This makes it an ideal choice for local deployments or scenarios where a lightweight database is needed.

For dynamic runtime data—such as the user's selected line or department, as well as the full list of available lines and departments—FlowFuse’s built-in context storage will be utilized. This solution allows for fast access to real-time data while maintaining persistent state across sessions, without introducing unnecessary database complexity or overhead.

By using both SQLite for structured request data and context storage for dynamic, session-based information, the system remains efficient and easy to maintain.

Up Next

In the next part of this series, we will focus on developing the Lines view for regular users, along with the navigation menu for switching between different line sections. Later, we will cover the development of the lines view and Admin interface.

But if you can't wait to get started right away, don’t worry! You can register for FlowFuse and get started with our ready-made Andon Task Manager blueprint, which is pre-configured for easy deployment. Stay tuned for the next installment to continue your journey toward building a comprehensive, real-time Andon Task Manager solution.

How to Generate PDF Reports Using Node-RED in FlowFuse

2025-05-07T00:00:00Z

Generating PDF reports is a common need in many workflows—whether you're logging data, sharing results, or creating summaries. With Node-RED and FlowFuse, you can easily automate turning your data into well-structured PDF files. This guide will show you how to set up step-by-step PDF report generation using simple tools and flows.

Generating reports allows you to capture snapshots of critical data, summarize system activities, and distribute insights in an easy-to-read and stored format. PDF is one of the most universally accepted formats for sharing documents, making it ideal for delivering structured information from your Node-RED flows.

Prerequisites

Before you begin, make sure the following requirements are met:

You have an active FlowFuse account and a running FlowFuse instance.
You are familiar with creating and deploying basic flows in Node-RED. If not, consider taking the Node-RED Fundamentals Course sponsored by FlowFuse.
Ensure you have installed flowfuse/node-red-dashboard @flowfuse/node-red-dashboard-2-ui-iframe and node-red-contrib-sqlite (The SQLite node is required for the demo data generation flow we provided. If you're not using that flow, you can skip this.).

Setting Up PDF Generation in Node-RED

Once the prerequisites are in place, the next step is setting up your Node-RED environment to generate PDF reports. In this section, we will go over how to install the necessary Node-RED node and configure a flow to generate PDF reports.

Step 1: Install the @platmac/node-red-pdfbuilder

The platmac/node-red-pdfbuilder node is the primary node for creating PDF reports in Node-RED. To install this node:

Open your Node-RED editor.
Navigate to the "Manage palette" section from the top-right menu.
Click on the "Install" tab and search for @platmac/node-red-pdfbuilder.
Click "Install" to add the node to your palette.

This node allows you to dynamically generate PDFs from various inputs, which is exactly what you will need to generate reports.

If you haven't installed the @flowfuse/node-red-dashboard, @flowfuse/node-red-dashboard-2-ui-iframe and node-red-contrib-sqlite nodes, you can install them similarly.

Step 2: Understanding How to Use the Pdfbuilder Node

Now that the required node is installed, let's dive into how to use it and how to leverage the different attributes to customize your PDF reports. The pdfbuilder node in Node-RED simplifies generating PDFs by allowing you to define content, layout, and styling directly in your flow.

The key advantage of using pdfbuilder node is that it operates server-side, meaning PDFs can be generated automatically without a browser or manual interaction. This makes it ideal for automated workflows where consistent, programmatically created documents are needed.

When working with this node, you can use various attributes to customize the content and layout of the PDF, such as text, tables, images, page sizes, margins, headers, footers, and more. Below are the most commonly used attributes:

Attribute	Description	Example
`content`	Defines the content of the PDF (text, tables, images, etc.).	`{ "content": "Hello, World!" }`
`style`	Specifies the style for content (font size, font family, etc.).	`{ "style": "headerStyle" }`
`layout`	Defines the layout of a table (e.g., 'lightHorizontalLines', 'noBorders').	`{ "layout": "lightHorizontalLines" }`
`pageSize`	Defines the page size for the PDF.	`{ "pageSize": "A4" }`
`pageMargins`	Sets the margins for the PDF (left, top, right, bottom).	`{ "pageMargins": [40, 60, 40, 60] }`
`header`	Specifies a header for the PDF. Can be a static text or dynamic content.	`{ "header": "My PDF Report" }`
`footer`	Specifies a footer for the PDF. Can be a static text or dynamic content.	`{ "footer": "Page {PAGE_NUM} of {PAGE_COUNT}" }`
`defaultStyle`	Defines the default style for all content in the PDF.	`{ "defaultStyle": { "font": "Helvetica", "fontSize": 12 } }`
`background`	Adds a background to the page or content area.	`{ "background": { "image": "imageData" } }`
`width`	Sets the width of table cells or other elements.	`{ "width": 150 }`
`height`	Sets the height of table cells or other elements.	`{ "height": 50 }`
`alignment`	Specifies the text alignment (left, center, right).	`{ "alignment": "center" }`
`border`	Defines the border for tables or table cells (style, width, and color).	`{ "border": [true, true, true, true] }`

For additional attributes and information, refer to the pdfmake documentation, as pdfbuilder-node uses this library to generate PDFs.

Here’s a simple example of how you can use these attributes to create a basic PDF:

{
  "content": [
    {
      "svg": "logoDataHere",
      "width": 150,
      "alignment": "center",
      "margin": [0, 0, 0, 20]
    },
    {
      "text": "Production Report - 2025",
      "style": "header"
    },
    {
      "text": "Daily Production Summary with Operator Performance",
      "style": "subheader",
      "alignment": "center",
      "margin": [0, 10, 0, 20]
    },
    {
      "layout": "lightHorizontalLines",
      "table": {
        "headerRows": 1,
        "widths": ["auto", "auto", "*", "auto", "auto", "*"],
        "body": [
          ["Date", "Shift", "Product", "Units Produced", "Defective Units", "Operator"],
          ["2025-01-01", "Morning", "Product A", "1000", "20", "John Doe"],
          ["2025-01-01", "Afternoon", "Product B", "950", "15", "Jane Smith"],
          ["2025-01-02", "Morning", "Product A", "1050", "10", "James Brown"],
          ["2025-01-02", "Afternoon", "Product C", "800", "30", "Emily Clark"],
          ["2025-01-03", "Morning", "Product B", "1100", "25", "Michael Green"],
          ["2025-01-03", "Afternoon", "Product A", "980", "18", "Sarah White"]
        ]
      }
    },
    {
      "text": "This table summarizes the daily production output across different shifts and operators. It includes total units produced and defective units recorded for quality analysis.",
      "fontSize": 12,
      "alignment": "justify",
      "margin": [0, 10, 0, 20]
    },
    {
      "text": "Internal Use Only - Manufacturing Co.",
      "style": "footer",
      "alignment": "center",
      "margin": [0, 20, 0, 0]
    }
  ],
  "styles": {
    "header": {
      "fontSize": 20,
      "bold": true,
      "alignment": "center",
      "margin": [0, 20, 0, 10]
    },
    "subheader": {
      "fontSize": 14,
      "italics": true,
      "color": "grey",
      "margin": [0, 10, 0, 20]
    },
    "footer": {
      "fontSize": 10,
      "color": "grey"
    }
  },
  "pageSize": "A4",
  "pageMargins": [40, 60, 40, 60]
}

This example creates a simple PDF featuring a centered logo, a title, a subtitle, a table with a light horizontal line layout, a paragraph of text, and a footer at the end. The following screenshot shows how it looks. You can customize it by adjusting the styles, layout, and content.

Example pdf result

Step 3: Creating a Flow to Generate a PDF

Let's learn how to generate a PDF using dynamic inputs. For this, we’ll use the same example PDF report shown earlier—but this time, we’ll replace the hardcoded values with dynamic input data.

For this guide's practical example, we will use the following SQLite flow that generates simulated production data. If you don't have the data source, you can import the flow below to follow along. After importing, deploy the flow and click the Inject node button to generate and insert the data.

When generating PDFs for your specific data, start by creating a flow to collect the information you want in the report. This data can come from sensors, databases, APIs, or even manual inputs.

Drag an Inject node onto the canvas.
Drag an SQLite node and connect it to the Inject node. Configure the SQLite node with the same database to generate the simulated data. Set the SQL Query type to "fixed statement" and use the following query:

SELECT * FROM production_report;

Drag a Function node onto the canvas and paste the following JavaScript code. When generating PDFs for your specific data, make sure to adjust the code to match your data structure.

// Initialize table body with headers
const tableBody = [
    ['Date', 'Shift', 'Product', 'Units Produced', 'Defective Units', 'Operator']
];

const logo = `<replace-this-your-logo-svg`

// Loop through data rows from SQLite (msg.payload)
for (const row of msg.payload) {
    tableBody.push([
        row.date,
        row.shift,
        row.product,
        row.units_produced.toString(),
        row.defective_units.toString(),
        row.operator
    ]);
}

const docDefinition = {
    content: [
        {
            svg: logo,
            width: 150, // Adjust the logo size as needed
            alignment: 'center',
            margin: [0, 0, 0, 20]
        },
        // Header
        {
            text: 'Production Report - 2025',
            style: 'header'
        },

        // Subheader
        {
            text: 'Daily Production Summary with Operator Performance',
            style: 'subheader',
            alignment: 'center',
            margin: [0, 10, 0, 20]
        },

        // Table
        {
            layout: 'lightHorizontalLines',
            table: {
                headerRows: 1,
                widths: ['auto', 'auto', '*', 'auto', 'auto', '*'],
                body: tableBody
            }
        },

        // Description
        {
            text: 'This table summarizes the daily production output across different shifts and operators. It includes total units produced and defective units recorded for quality analysis.',
            fontSize: 12,
            alignment: 'justify',
            margin: [0, 10, 0, 20]
        },

        // Footer
        {
            text: 'Internal Use Only - Manufacturing Co.',
            style: 'footer',
            alignment: 'center',
            margin: [0, 20, 0, 0]
        }
    ],

    styles: {
        header: {
            fontSize: 20,
            bold: true,
            alignment: 'center',
            margin: [0, 20, 0, 10]
        },
        subheader: {
            fontSize: 14,
            italics: true,
            color: 'grey',
            margin: [0, 10, 0, 20]
        },
        footer: {
            fontSize: 10,
            color: 'grey'
        }
    },

    pageSize: 'A4',
    pageMargins: [40, 60, 40, 60]
};

msg.payload = docDefinition;
return msg;

Drag a pdfbuilder node onto the canvas. Set the input property to msg.payload, set output type to Buffer, and output property to msg.payload.
Drag a Write File node, configure it with:
- Filename: test.pdf
- Action: Overwrite file
- Add newline (\n) to each payload?: Checked
Connect the SQLite node to the Function node, then to the pdfbuilder node, and finally to the Write File node.
Deploy the flow and click inject node to generate the pdf.

Once the PDF is generated, you can find it in the .node-red directory.

However, if you want to share the PDF with others, display it on the dashboard, and provide a download button, you can use the HTTP API, an iframe, and a few supporting nodes. Let's walk through how to do that next.

Step 4: Serving the PDF via HTTP and Previewing It on the Dashboard

In this step, we’ll make the generated PDF accessible through a web interface. You’ll be able to preview the PDF directly in the browser and embed it in your FlowFuse dashboard for a smooth, integrated experience. We’ll also add a download button so users can easily save the report. Instead of manually retrieving the file, we’ll create an HTTP endpoint to serve the PDF and use an iframe to display it.

Exposing the PDF via HTTP

Drag the ** http-in ** node onto the canvas. Set the method to 'GET' and the URL to /report.pdf. This will create an HTTP endpoint for retrieving the generated PDF.
Connect the ** http-in ** node to the ** SQLite ** node. This ensures that when a request is made to this endpoint, the necessary data is fetched from the database.
After the Write File node in your flow, add a Change node. Connect it to the Write File node, and configure it to set the following headers for the HTTP response:
- Set msg.headers to:
```
{   
   'Content-Type': 'application/pdf',   
   'Content-Disposition': 'inline; filename="report.pdf"' 
}
```
Drag the HTTP-response node onto the canvas and connect it to the Change node.
Deploy the flow

Now, this will send the generated PDF as a response to the incoming HTTP request, allowing it to be previewed in the browser. You can check by entering the URL:

https://<your-instance-name>.flowfuse.cloud/report.pdf

Embedding the PDF on the Dashboard and Adding the Download Button

Now, let's embed the PDF into the dashboard:

Drag a ui-event node onto the canvas and configure it with the appropriate UI base settings.
Next, drag an iframe node onto the canvas.
- Select the correct group where the PDF should be displayed.
- Adjust the size according to your preferences.
- In the URL field, enter:
```
https://<your-instance-name>.flowfuse.cloud/report.pdf
```
Click Done and Deploy the flow.

Once deployed, when you open the dashboard, the generated PDF will be embedded and displayed directly on the dashboard page.

Now, let's add a download button:

Drag a ui-template widget onto the canvas and paste the following HTML code into it:

<div style="text-align:center; margin-top: 20px;">
    <a href="https://<your-instance-name>.flowfuse.cloud/report.pdf" download="report.pdf"
        style="display: inline-block; background-color: #4f7a28; color: white; padding: 14px 20px; text-align: center; text-decoration: none; font-size: 16px; border-radius: 5px; box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2); transition: background-color 0.3s ease;">
        Download Report
    </a>
</div>

Deploy the flow.

[Dashboard displaying embedded PDF with a download button]

Final thought

Automating PDF report generation in Node-RED is a great way to save time and effort. Using tools like the node-red-contrib-pdfmake node, you can quickly turn your data into well-designed PDFs without manual work. If you want to save time and avoid the setup process, you can directly use our ready-made PDF generation blueprint. It’s an easy way to get started and generate professional reports quickly.

Part 3: Building an OEE Dashboard with FlowFuse

2025-04-16T00:00:00Z

In Part 2, we built the flow to calculate OEE for the production line using simulated production and downtime data and created a dashboard interface for visualization. However, we did not focus much on theme, layout, or styling.

In Part 3, we will focus on improving the theme and design of the OEE dashboard. We will learn how to connect a real data source, adjust fields if your data structure differs, scale the dashboard for multiple production lines, and finally, explore how you can use it to take action based on insights.

Let's get started!

Enhancing the Dashboard Theme and Design

In the planning section of Part 1, we introduced a mockup of the dashboard with a modern dark theme. The theme was built around a sleek, professional aesthetic, using high-contrast colors for readability and a visually appealing layout.

The primary colors in the theme include:

Black (#000000) — used for the page background to create contrast and reduce eye strain.
Charcoal Blue (#1A1C24) — a deep, muted tone that adds depth while maintaining a clean and modern look, used for the groups.
White (#FFFFFF) — used for text elements to ensure maximum readability against the dark background.
Accent Colors — vibrant colors such as teal, orange, green, yellow, and blue are used across widget elements, including chart bars, line graphs, and indicators. These accents help differentiate data types and bring attention to key metrics.

But how do you come up with a dashboard design like this on your own? It starts with understanding why the theme matters. The design should reflect the context it is used in, the people interacting with it, and the mood it should convey. A dashboard on a factory floor may need to feel bold and focused, while one used by executives might aim for minimal and polished. A hospital system would need a tone that is calm, clean, and highly legible.

If you have a brand palette, that’s a great starting point. If not, choose colors that support the usability and tone of your dashboard. Our OEE dashboard, for instance, was designed for manufacturing teams who need to quickly read live data. The layout needed to be sharp, high-contrast, and low on visual noise—ideal for control rooms with limited lighting. The dark theme helps key data stand out while reducing eye strain over long periods of use.

Modifying Theme

Open the Dashboard 2.0 sidebar from the Node-RED editor.
Switch to the Theme tab.
In the list of themes (you will likely see only the default one), click the settings (gear) icon next to it.
In the theme settings, click any colored rectangle to open the color picker. You can use the wheel or the dropper tool at the bottom to pick exact colors:

Color tool for selecting colors for the theme

Set Charcoal Blue (#1A1C24) as the color for the header background, group background, and group outline.
Set Black (#000000) as the page background.

Click Update and Deploy Changes.

Your dashboard should display the updated dark theme with a clean, modern appearance and improved visual contrast.

However, additional adjustments are needed to fully align the visuals, specifically the chart grid lines and label text colors.

To update these:

Double-click on a chart widget to open its configuration panel.
Scroll to the bottom of the chart config UI.
Uncheck the following options:
- Use ChartJs Default Text Colors
- Use ChartJs Default Grid Colors
Set the text color to #FFFFFF (white) and the grid line color to #606060.
Click Done, then Deploy the changes.

These tweaks will ensure the charts match the dark theme and maintain good readability.

Improving Layout Consistency Across Screen Sizes

When you open the same dashboard on different screen sizes—such as a mobile phone, tablet, or smaller desktop monitor—you might find the layout inconsistent or cramped. For example, widgets may overlap or appear too small.

OEE Dashboard broken layout on smaller screen

To make the dashboard truly responsive:

Open the Page Settings in the Node-RED Dashboard editor.
Scroll down to locate the Breakpoint Settings Table for different device sizes.
Identify the Tablet row in the table.
Notice that the current Tablet column count is set to 9.

Our OEE dashboard has:

Four KPI widgets (OEE, Performance, Availability, Quality), each set to 3 columns wide.
A total of 3 × 4 = 12 columns, which does not fit in the 9-column grid—so the layout breaks, and one widget drops to the next row.
Other widgets like Production Summary and Downtime Events are each 6 columns wide, which leaves 3 columns of unused space in a 9-column layout.

To correct this, set the Tablet column count to 6 in the breakpoint table.

This change ensures:

Two KPI widgets fit perfectly per row (3 + 3 = 6).
Summary widgets span the full row (6/6), making the layout cleaner and more consistent on tablet devices.

Click Deploy the changes.

Even after adjusting the breakpoint settings, one more issue may appear: inconsistent heights between the Top Underperforming Machines and Recent Downtime Events sections—especially when one of the tables has fewer rows than the other.

Inconsistent height of the widgets on the OEE Dashboard

This can make the dashboard layout uneven, with one card appearing much shorter.

To fix this visual imbalance, apply custom CSS:

Drag a Template widget onto your canvas.
Set its type to CSS (all pages).
Paste the following CSS into the template:

.nrdb-ui-group > .v-card {
    height: 100% !important;
}

Deploy the changes.

Adding Header Elements: Logo and Dashboard Title

To give your OEE Dashboard a professional look, add branding elements such as a company logo and a clear dashboard title. These additions improve usability and help users instantly recognize the dashboard's purpose.

Drag Template widget onto the canvas.
Double click on it and add the following Vue code to it:

<template>
   <!-- Teleport the title and logo to the #app-bar-actions area -->
   <Teleport to="#app-bar-title">
       <h3 style="color: white; margin-left: auto; margin-right: auto;">OEE Dashboard</h3>
   </Teleport>
   <Teleport to="#app-bar-actions">
       <div style="display: flex; align-items: center;">
           <img
               height="30px"
               src="https://flowfuse.com/handbook/images/logos/ff-logo--wordmark--white.png"
               style="margin-right: 25px;"
           />
       </div>
   </Teleport>
</template>

<script>
   export default {
   data() {
       return {
           mounted: false
       };
   },
   mounted() {
       this.mounted = true;
   }
};
</script>

Update the src attribute in the <img> tag to your logo's path. If you are using FlowFuse, you can host your logo using the static assets service.
Click Deploy the changes.

We are using Vue’s Teleport feature to insert a custom dashboard title and logo into the top bar of the Dashboard 2.0 layout. For more information, please read our article: Customise theming in your FlowFuse Dashboard.

The dashboard now looks clean, adapts well to all screen sizes, and maintains visual consistency across different UI elements. The header elements have also been enhanced to align with the overall design.

OEE Dashboard with proper styling, theme

OEE Dashboard with proper styling, theme on smaller screen

Scaling the Dashboard for Multiple Production Lines

Currently, the dashboard is configured for a single production line. To support multiple lines, you must adjust your flows and dashboard structure to handle each line separately while keeping a consistent layout and theme.

Follow these steps:

Select the dashboard flow that handles your current production line. Include all relevant change nodes that set values like msg.quality, msg.performance, etc., to msg.payload.
From the main menu, hover over Subflows and click Create Subflow.
Inside the subflow:
- Add an Input node, and connect it to all the change nodes you included from the original flow.
- Reconnect any Link In node (that was previously wired to the change nodes) to the input of the newly created subflow.
Open the subflow properties, and define environment variables to represent widget groups. In the dashboard widgets inside the subflow, reference these variables instead of hardcoding group names.
Click Deploy to apply the changes.

This modular approach simplifies scaling and reduces manual work when adding new production lines to the dashboard.

To reuse it for another production line:

Copy the entire OEE dashboard flow.
Create a new tab.
Paste the copied flow into the new tab.
Rename the tab to match the new production line.
Create a new dashboard page with the same configuration but a different name and path.
Open the subflow by double-clicking on it and add a new group for dashboard widgets.
Go to the configuration flow, and update the line's name to match the new production line.
Adjust both shift duration values to reflect the new line’s schedule.
Click Deploy.

Once deployed, you will have a separate page ready for your new production line. You can create as many pages as needed to monitor multiple production lines.

Connecting Your Real Data Source

Now that you have built a complete OEE dashboard using simulated factory data and learned how to reuse it for all your production lines, the next step is to connect it to your real factory environment.

To make the dashboard truly useful in a live setting, you must understand how to integrate it with your data sources. Most commonly, the OEE dashboard relies on static or retained data, such as values stored in a database. First, determine whether your factory uses a relational database like MySQL or PostgreSQL, a NoSQL database like MongoDB, or a time-series database like InfluxDB.

Then:

Use the Palette Manager in Node-RED to install the corresponding contrib node for your selected database.
Replace the existing sqlite nodes in your flow with the nodes for the database you are using.
If using SQL based database, queries may remain unchanged. For NoSQL or time-series DBs, rewrite the queries as needed.

For help, refer to our Database section, which includes guides for MongoDB, PostgreSQL, InfluxDB, TimescaleDB, and DynamoDB.

When connecting to your real data source, you may notice that the field names used in your database differ from those used in the our oee dashboard sqlite node queries. While this seems like a lot of manual work, the dashboard is designed with flexibility in mind. You only need to make two changes to adapt the queries to your schema.

To match your schema:

Open each database node and update the query to reflect your field names.
- Do not change the alias names — they are used throughout the dashboard.
Replace table names with those used in your actual database.
Do not change the dynamic parameters like $startTime, $endTime, and $line.

Example query:

SELECT
   timestamp as timestamp,
   machine_name as machine_name,
   area as area,
   line as line,
   total_produced_units as total_produced_units,
   good_units as good_units,
   defect_units as defect_units,
   target_output as target_output
FROM ProductionData
WHERE
   timestamp BETWEEN $startTime AND $endTime AND line = $line;

Suppose your database uses different field names, such as time instead of timestamp, machine instead of machine_name, section instead of area, production_line instead of line, produced_units instead of total_produced_units, quality_units instead of good_units, faulty_units instead of defect_units, or planned_output instead of target_output. In that case, you should update the query accordingly. After modification, it should look like this:

SELECT
    time AS timestamp,
    machine AS machine_name,
    section AS area,
    production_line AS line,
    produced_units AS total_produced_units,
    quality_units AS good_units,
    faulty_units AS defect_units,
    planned_output AS target_output
FROM YourTableName 
WHERE 
    time BETWEEN $startTime AND $endTime AND production_line = $line;

How to Use Your OEE Dashboard

Your OEE dashboard is live. It updates in real-time and shows key metrics. But what should you do with the information?

The dashboard is not just for display—it is there to help you take action. When OEE drops, do not stop at the number. Dig into the cause by checking the three main metrics: availability, performance, and quality.

If availability is low, check for unplanned stops, long changeovers, or idle machines.
If performance is down, the line may run slower than expected.
If quality has dropped, you may produce more rejects or rework.

Say your OEE drops from 82% to 65%, and performance is the problem. Start by checking how many good parts were produced. Look at reject counts—more bad parts affect both quality and output. Then, check downtime logs and machine performance. One or two machines are often behind the drop—maybe they had repeated issues or ran slowly after a setup.

Use the 30-day trend graph to spot patterns over time. A sudden drop might show a specific issue, while a slow decline could signal a more significant process problem. Trends can also help you confirm if recent changes are making a real difference. Finally, share what you find. Use the dashboard during team reviews or shift handovers to keep everyone focused on what needs fixing. An OEE dashboard's real value is how you respond to it.

Conclusion

This final part completes our series on building a real-time OEE dashboard with FlowFuse. You now have a fully functional, visually refined, and scalable dashboard that connects to live production data, adapts to multiple lines, and reflects your plant’s branding and layout requirements.

By the end of this journey, you have built a dashboard and created a foundation for continuous improvement in your manufacturing environment using open-source, low-code tools. We hope this series helped you understand how FlowFuse and Node-RED can quickly prototype and deploy powerful industrial applications. Thank you for following along!

Suppose you have not built your OEE dashboard yet or are facing issues. In that case, you can get started instantly—sign up now and use our ready-made OEE Dashboard Blueprint to accelerate your deployment.

FlowFuse 2.16: Git Integration, improved log retention and more

2025-04-10T00:00:00Z

Another release from the FlowFuse team to keep realising our mission to empower you to fuse the digital realm and physical reality.

Git Integration

Screenshot of a Git Pipeline Stage

This has been one of those features that has come up a number of times with our users; we knew we wanted to have Git integration in the platform, but we also wanted it to fit in a natural way with the developer workflows we provide.

With this release, you can now add a Git Repository stage to your deployment pipelines. When the pipeline is triggered, the latest snapshot will get pushed to the configured repository.

This is very much a "first-iteration" of the feature that will allow us to get feedback early and continue to iterate.

With this release, the following restrictions apply:

Only GitHub.com hosted repostories are supported
Users must create a GitHub Personal Access Token and add to their Team Settings
We currently only support pushing snapshots to a Git repository

This last point is important; this release lets you backup your flows to git, but we haven't yet enabled the return journey of pulling a snapshot from a Git repository back to your Node-RED instance. That'll come in the near future and will unlock a full git-based review workflow within the pipelines.

We'll also look at enabling other Git hosting providers - let us know which you'd like to see on the list.

This feature is available to Enterprise teams on FlowFuse Cloud and self-hosted customers.

Better Node-RED log handling

We've improved the log handling within our Hosted Node-RED instances. Previously we were using a fix sized buffer in memory; meaning the noisier your Node-RED instance was, the less history you'd have. The UI for browsing the logs was also awkward when you wanted to jump back to an earlier section of the logs.

With this release, once you update your instances to the latest version, we will now store the last 7 days worth of logs for each hosted Node-RED instance.

To go along side this, we've added the ability to jump to a specific time/date in the logs without having to endlessly scroll.

To start benefiting from the extended logs, make sure you update the latest version via your Instance Settings page.

Screenshot of browsing Node-RED logs by timestamp

Remote Instance Provisioning

We've updated the provisioning token support to allow you to automatically assign your remote instances to an application within your team.

The option to assign to a hosted instance is still there, but being able to assign to the appilcation is more generally useful for most workflows on the platform.

Details available in the changelog.

One of the great features of our Remote Instance management is that we enable secure remote access to the Node-RED editor through the platform. To date, this approach has meant we disable direct local access to the editor.

With the most recent Device Agent release, we've added the ability to configure a local user login for the editor. This can be used when the remote instance is not able to reach the FlowFuse platform.

We're keen for feedback on this and will continue to explore otherwise to provide secure local access to the remote instance.

Resource Alerts

We expanded the notficiations we send to help you track the health of your Node-RED instances. We will now send notifications if the CPU and/or memory usages exceeds 75% of the available capacity for a prolonged time.

You can further opt-in or out of these notifications via the instance settings.

Details available in the changelog

Changes to tags for `flowfuse/node-red` containers

For kubernetes and docker environments, we've updated the base container our latest tag points at to ensure it defaults to the latest Node.js and Node-RED versions.

Check the changelog entry for full details

What Else Is New?

For a full list of everything that went into our 2.16 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try FlowFuse

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is on our own hosted instance, FlowFuse Cloud.

Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

Part 2: Building an OEE Dashboard with FlowFuse

2025-04-09T00:00:00Z

In Part 1, we explored the fundamentals of OEE, outlined a basic design of the dashboard, and identified the key elements to include in the OEE dashboard. In this Part 2, we will focus on building the OEE dashboard interface using FlowFuse Dashboard (Node-RED Dashboard 2.0) and FlowFuse, utilizing simulated production and downtime data.

Getting Started

To simplify the development process, we will divide development into five key parts:

Collecting and configuring data
Preparing data for calculations
Calculating OEE and key metrics
Detailed breakdown of OEE data
Building the dashboard

Before we start, it is recommended to have a basic knowledge of Node-RED. For that, I recommend this free Node-RED Fundamental Course.

Additionally, ensure that you organize flows into well-structured groups. To match my group organization, I have provided images of the flow for each section. Also, if a Link In node is present at the start, create the group starting from the Link In node and ending at the Link Out node.

Prerequisites

Before you begin building the OEE Dashboard with FlowFuse, make sure you have the following:

Running FlowFuse Instance: Make sure you have a FlowFuse instance set up and running. If you don't have an account, check out our free trial and learn how to create an instance in FlowFuse.
FlowFuse Dashboard: Ensure you have FlowFuse Dashboard (also known as Node-RED Dashboard 2.0 in the community) installed and properly configured on your instance.
SQLite Contrib Node: Ensure you have node-red-contrib-sqlite installed.

Preparing Simulated Data

Before building the dashboard, we need a data source for production and downtime metrics. This data will serve as input for OEE calculations. We will focus on connecting a real source in the next part, but for now, let's generate simulated data.

Import the provided flow for data generation.
Click the Deploy button to activate the flow.
On deployment, it will create two SQLite tables: ProductionData and DowntimeData.
Find the Inject node labeled Click to generate and insert demo data.
Click the inject node to trigger data generation.

The flow will generate data with the following fields:

Demo Production and Downtime data object

Collecting and Configuring Data

Once the simulated data is generated and stored in SQLite, the next step is to create a flow for configuration settings. These settings will be used across the entire flow, allowing the flow to be reused by simply modifying the settings. The configured data will then be collected for use in the OEE dashboard.

Adding flow to configure settings:

Click on the "+" to create a new flow.
Name the newly created flow to OEE Dashboard for Line-1.
Drag a Change node onto the canvas, double-click it, and add the following elements:
- Set flow.line to "Line-1"
- Set flow.shift_duration to 12
- Set flow.shiftDuration24h to 24
Drag an Inject node, set it to trigger on deploy by enabling Inject once after X seconds (set delay to 0.1 seconds).
Click Deploy to apply changes.

In this flow, we are configuring the production line based on the demo data, specifically for Line-1, as we are building the OEE dashboard for this line. The settings define the shift duration for the last X hours used in OEE calculations and the total shift duration within a 24-hour period.

Flow to set basic configuration settings that will be used across the OEE dashboard flow for calculations.

Retrieving Data from SQLite:

Drag an Inject node and configure it to trigger at regular intervals.
Drag a Change node and add following elements:
- Set msg.params to {}
- Set msg.params.$startTime to $moment($millis() - ($number($flowContext('shift_duration')) * 60 * 60 * 1000)).format('YYYY-MM-DD HH:mm:ss')
- Set msg.params.$endTime to $moment($millis()).format('YYYY-MM-DD HH:mm:ss')
- Set msg.params.$line to flow.line

Drag an SQLite node and insert the following query:

SELECT timestamp, machine_name, area, line, total_produced_units, good_units, defect_units, target_output
FROM ProductionData
WHERE timestamp BETWEEN $startTime AND $endTime AND line = $line;

Drag a Change node onto the canvas and set the following element to store the retrived production data result as new property:
- Set msg.payload to msg.productionData
Connect the Inject node’s output to the input of the Change node that sets parameters. Then, connect the Change node’s output to the input of the SQLite node that retrieves production data. Finally, connect the SQLite node’s output to the input of last change node we added.

Drag another SQLite node and insert the following query:

SELECT timestamp, machine_name, downtime_start, downtime_duration_minutes, downtime_reason
FROM DowntimeData
WHERE timestamp BETWEEN $startTime AND $endTime AND line = $line;

Drag a Change node onto the canvas and set the following element to store the retrived production data result as new property:
- Set msg.payload to msg.downtimeData
Connect the SQLite node’s output to the input of last change node we added.
Now, drag the Link Out node onto the canvas and connect it to the last Change node.

Flow that retrives the data from the sqlite table

Preparing Data for OEE Calculations

Now that we have a flow to retrieve production and downtime data, we can calculate key OEE metrics. The total number of good units, defective units, total produced units, target output, and downtime duration are summed across all production lines. Using these values, we can calculate availability, performance, and quality for the entire production system, which can then be used to calculate OEE.

Drag the link in node onto the canvas and connect it to the link out node.
Drag two Change nodes onto the canvas and connect them to the Link In node.
- In the first Change node, set msg.payload to production_data.
- In the second Change node, set msg.payload to downtime_data.
Drag a Split node onto the canvas and connect it to the first Change node, the one setting production_data. Configure the Split node so that msg.payload is assigned to production_data.
Drag three Join nodes onto the canvas and connect them to the Split node to sum individual data points. Configure each Join node with the following settings:
- Mode: Reduce Sequence
- Initial Value: 0
- Fix-up Expression: $A
Set the reduce expressions as follows:
- First Join Node: $A + msg.payload.total_produced_units
- Second Join Node: $A + msg.payload.good_units
- Third Join Node: $A + msg.payload.target_output
Drag three Change nodes onto the canvas and connect each to a Join node.
Configure these Change nodes to store the summed values using the following variables to flow context:
- total_produced_units
- total_good_units
- total_target_output
Drag a Switch node onto the canvas and connect it to the Change node that sets the retrieved downtime data to msg.payload, for switch node set the Property to msg.payload and add the following conditions:
- is not empty.
- Otherwise.
Drag a Split node onto the canvas and connect it to the first output of the Switch node.
Drag a Join node onto the canvas and connect it to the Split node.
Configure the Join node with the following settings:
- Mode: Reduce Sequence
- Initial Value: 0
- Fix-up Expression: $A
- Reduce Expression: $A + payload.downtime_duration_minutes
Drag a Change node onto the canvas and connect it to the Join node, Configure this Change node to store the total downtime duration in the flow context with following element:
- Set flow.total_downtime to msg.payload
Drag another Change node onto the canvas and connect it to the second output of the Switch node, Set this Change node to store 0 in the flow context for total_downtime with following element:

Set flow.total_downtime to 0

Drag a Link Out node onto the canvas and connect it to any of the Change nodes that store the summed metrics in the flow context.

Flow to prepare the data necessary to calculate OEE and all its three components.

Calculating OEE and Key Metrics

Now that we have all the necessary pieces, we can calculate the key metrics for OEE: Availability, Performance, and Quality and later OEE.

Drag a Link In node.
Drag a Change node and add element as following:
- Set msg.quality to ($flowContext('total_good_units') / $flowContext('total_produced_units')) * 100 as JSONata expression.
- Set msg.availability to (($flowContext('shift_duration') - $flowContext('total_downtime')) / $flowContext('shift_duration')) * 100 as JSONata expression.
- Set msg.performance to ($flowContext('total_produced_units') / $flowContext('target_output')) * 100 as JSONata expression.
- Set msg.oee to $round(((msg.availability / 100) * (msg.performance / 100) * (msg.quality / 100)) * 100, 2) as JSONata expression.
- Set msg.qualityto $round(msg.quality, 2)
- Set msg.availability to $round(msg.availability, 2)
- Set msg.performance to $round(msg.performance, 2)
- Set msg.productionData to JSONata expression:
```
[
{
    "reason": "Total Good Units Produced",
    "units": $flowContext("total_good_units")
  },
  {
    "series": "Total Defective Units Produced",
    "units": $number($flowContext("total_produced_units")) - $number($flowContext("total_good_units"))
  }
]
```
Drag a Link Out node and connect it to the Change node.
Drag a separate Link In node for visualization and keep it in a separate flow. This will be the Link In node where all the calculated final data for visualization will be stored.
Connect link out node to this link in node.

Flow that calculates availability, quality, performance, and OEE, and also prepares production data for visualization.

Detailed Breakdown of OEE Data

We have calculated the OEE and other key metrics. However, as discussed in the planning section of our previous article, we will also visualize recent downtime events, a downtime summary, the top underperforming machines (OEE-wise), and the OEE trend over the last 30 days on the dashboard.

Let’s do that.

Drag the link in node onto the canvas and connect it to the link out node that is part of the SQLite flow, which is also connected to the change node that sets the retrieved downtime result to msg.payload.
Drag a change node onto the canvas and set the following element: Set msg.downtime_data to msg.payload.

Downtime Summary

Drag a function node onto the canvas and add the following JavaScript to calculate the downtime summary:

function calculateDowntimeByReason(downtimeData) {
   if (!Array.isArray(downtimeData) || downtimeData.length === 0) {
       return []; f
   }
   const summary = {};
   downtimeData.forEach(({ downtime_reason, downtime_duration_minutes }) => {
       summary[downtime_reason] = (summary[downtime_reason] || 0) + downtime_duration_minutes;
   });
   return Object.entries(summary).map(([reason, duration]) => ({
       downtime_reason: reason,
       downtime_duration_minutes: duration
   }));
}
msg.payload = calculateDowntimeByReason(msg.payload) || [];
return msg;

Drag a change node onto the canvas and set:
- Set msg.payload to msg.downtimeSummary.
Drag a link out node and connect it to the change node that sets msg.downtime_data to msg.payload.
Connect this link out node to the link in node that we added earlier to receive all the calculated metrics for visualization.

Recent Downtime

Drag a Switch node onto the canvas and set the property to msg.payload. Add the following condition:
- is not empty
- otherwise
Drag a Split node onto the canvas and connect it to the first output of the Switch node.
Drag a Sort node onto the canvas and connect it to the Split node. Set the sort to "message sequence", key to msg.payload.downtime_start, and order to "descending." This will sort the downtime data from most recent to oldest based on its start time.
Drag a Join node onto the canvas and set the mode to automatic, then connect it to the Sort node.
Drag a Change node onto the canvas and set the following element:
- Set msg.recentDowntime to payload^(10) as a JSONata expression.
Connect the Change node to the Link Out node that was added before.

Top Underperforming Machines

Drag a Function node onto the canvas and connect it to the Link In node that is receiving the SQLite result.
Add the following JavaScript code to the Function node:

const productionData = msg.production_data;
const downtimeEvents = msg.downtime_data;
const shiftDuration = (flow.get('shift_duration') || 1) * 60; // Convert hours to minutes

// Group production data by machine (including area)
let machineData = {};
productionData.forEach(data => {
    if (!machineData[data.machine_name]) {
        machineData[data.machine_name] = {
            total_produced_units: 0,
            good_units: 0,
            target_output: 0,
            count: 0,
            area: data.area // Store area
        };
    }
    machineData[data.machine_name].total_produced_units += data.total_produced_units;
    machineData[data.machine_name].good_units += data.good_units;
    machineData[data.machine_name].target_output += data.target_output;
    machineData[data.machine_name].count += 1;
});

let oeeResults = Object.keys(machineData).map(machineName => {
    let data = machineData[machineName];

    let machineDowntime = downtimeEvents.filter(event => event.machine_name === machineName);

    function calculateOEE(data, downtime) {
        if (data.target_output === 0) {
            return { availability: 0, performance: 0, quality: 0, oee: 0 };
        }

        let totalDowntime = downtime.reduce((acc, event) =>
            typeof event.downtime_duration_minutes === 'number' ? acc + event.downtime_duration_minutes : acc
            , 0);

        let availability = (shiftDuration - totalDowntime) / shiftDuration;
        availability = Math.max(0, Math.min(1, availability));

        let performance = data.target_output > 0 ? data.total_produced_units / data.target_output : 0;
        let quality = data.total_produced_units > 0 ? data.good_units / data.total_produced_units : 0;

        let oee = availability * performance * quality;

        return {
            availability: parseFloat((availability * 100).toFixed(2)),
            performance: parseFloat((performance * 100).toFixed(2)),
            quality: parseFloat((quality * 100).toFixed(2)),
            oee: parseFloat((oee * 100).toFixed(2))
        };
    }

    let metrics = calculateOEE(data, machineDowntime);

    return {
        machine_name: machineName,
        area: data.area,
        oee: metrics.oee
    };
});

// Filter only machines with OEE < 85
msg.payload = oeeResults.filter(machine => machine.oee < 85);

return msg;

Flow that prepares the Recent Downtime, Downtime Summary, and Top Underperforming Machines (OEE-wise)

OEE Trend for the Last 30 Days

Now, to calculate the OEE for the last 30 days, we need the complete production and downtime data for that period. However, the current SQLite flow retrieves only the last 12 hours. Therefore, we need another SQLite flow to retrieve data from the last 30 days.

Retrieving Production and Downtime Data for the Last 30 Days

Copy the existing SQLite flow from the Inject node to the Change node that sets the retrieved downtime result to msg.payload.
Click on the Change node that sets the parameters for the SQL query, keep only the element setting the line parameter, and remove the rest.
Modify the first SQLite node's SQL query to the following:

SELECT
    timestamp AS timestamp,
    machine_name AS machine_name,
    area AS area,
    line AS line,
    total_produced_units AS total_produced_units,
    good_units AS good_units,
    defect_units AS defect_units,
    target_output AS target_output
FROM ProductionData
WHERE line = $line
  AND timestamp >= datetime('now', '-30 days');

Modify the second SQLite node's SQL query to the following:

SELECT
    timestamp AS timestamp,
    machine_name AS machine_name,
    downtime_start AS downtime_start,
    downtime_duration_minutes AS downtime_duration_minutes,
    downtime_reason AS downtime_reason
FROM DowntimeData
WHERE
    timestamp BETWEEN $startTime AND $endTime
    AND line = $line;

Calculating last 30d days OEE

Drag the Link Out node onto the canvas and connect it to the last Change node of the SQLite flow.
Drag the Link In node onto the canvas and connect it to the last Link Out node.
Drag the Function node onto the canvas, add the following JavaScript, and connect the Function node to the Link In node:

let productionData = msg.production_data;
let downtimeData = msg.downtime_data;
let line = flow.get('line');
let shiftDuration = flow.get('shiftDuration24h') * 3600;

let groupedData = {};

productionData.forEach(entry => {
    if (entry.line === line) {
        let date = entry.timestamp.split(" ")[0];

        if (!groupedData[date]) {
            groupedData[date] = {
                totalShiftDuration: shiftDuration,
                totalGoodUnits: 0,
                totalProducedUnits: 0,
                totalDowntimeSeconds: 0,
                totalCycleTime: 0,
                cycleCount: 0,
                totalTargetOutput: 0,
                timestamp: entry.timestamp
            };
        }

        groupedData[date].totalGoodUnits += entry.good_units;
        groupedData[date].totalProducedUnits += entry.total_produced_units;
        groupedData[date].totalCycleTime += entry.cycle_time;
        groupedData[date].cycleCount++;
        groupedData[date].totalTargetOutput += entry.target_output;
    }
});

downtimeData.forEach(downtime => {
    if (downtime.line === line) {
        let date = downtime.timestamp.split(" ")[0];
        if (groupedData[date]) {
            groupedData[date].totalDowntimeSeconds += downtime.downtime_duration_minutes * 60;
        }
    }
});

let oeeResults = Object.entries(groupedData).map(([date, data]) => {
    let avgCycleTime = data.cycleCount > 0 ? data.totalCycleTime / data.cycleCount : 0;
    let availableTime = data.totalShiftDuration - data.totalDowntimeSeconds;
    let availability = availableTime / data.totalShiftDuration;
    let performance = data.totalTargetOutput > 0 ? data.totalProducedUnits / data.totalTargetOutput : 0;
    let quality = data.totalProducedUnits > 0 ? data.totalGoodUnits / data.totalProducedUnits : 0;
    let oee = (availability * performance * quality * 100).toFixed(2);

    return { date, availability, performance, quality, oee, timestamp: data.timestamp };
});

// Sort data by timestamp (oldest to most recent)
oeeResults.sort((a, b) => new Date(a.timestamp).valueOf() - new Date(b.timestamp).valueOf());
msg.payload = oeeResults;
return msg;

Drag the Change node onto the canvas and set msg.payload to msg.oeeTrend.
Drag the Link Out node onto the canvas and connect it to the Change node.
Connect this Link Out node to the Link In node that was added earlier to receive all the calculated metrics for visualization.

Flows that calculate the OEE for each day over the last 30 days.

Building the OEE Dashboard

Now that the key OEE metrics have been calculated and detailed insights into production performance have been gathered, it is time to bring everything together in a visually intuitive and interactive dashboard. The OEE dashboard will provide real-time visibility into availability, performance, and quality while also displaying recent downtime events, downtime summaries, underperforming machines, and historical OEE trends.

Using FlowFuse Dashboard (Node-RED Dashboard 2.0), a clean and efficient interface will be designed, allowing operators and decision-makers to monitor production efficiency at a glance.

Drag a Switch node onto the canvas, set the property to msg.oee, and add the condition:
- "Is not null".
Connect it to the Link-In node that receives calculated metrics.
Drag a Change node, set msg.oee to msg.payload, and connect it to a Gauge widget.
- Create a new Group on a new page named Line-1.
- Set the page layout to Grid, adjust the range from 0 to 100, and label the gauge OEE.
- Choose Half Gauge as the type, set the style to Rounded, and adjust the width and height to 6 and 3 for both the group and the widget.
Repeat these steps for msg.quality, msg.availability, and msg.performance, ensuring each has a separate Group with the correct label.
Drag a Switch node for msg.productionData and connect it to a Change node setting msg.productionData to msg.payload:
- "Is not null".
Repeat this step for msg.downtimeSummary, msg.recentDowntime, msg.topUnderPerformingMachines, and msg.oeeTrend, ensuring each has a separate Switch node and Change node.
Drag a Bar Chart widget, create a new Group, set the width to 6 and height to 8 for both the group and widget, label it Production Data, group data by Stacks, and map X to series and Y to units. Connect it to the node setting msg.productionData.
Duplicate the chart for Downtime Summary, mapping X to downtime_reason and Y to downtime_duration_minutes, and connect it to the node setting msg.downtimeSummary to msg.payload.
Drag a Table widget, create a new Group, set width 6 and height 2 for both the group and widget, label it Recent Downtime Events, set max rows to 5, and add columns with keys:
- machine_name
- downtime_start
- downtime_duration_minutes
- downtime_reason
Connect it to the node setting msg.recent_downtime to msg.payload.
Duplicate the table for Top Underperforming Machines, adding columns with keys:
- machine_name
- area
- oee
Connect it to msg.topUnderPerformingMachines.
Drag a Line Chart widget, create a new Group, set width 12 and height 5 for both the group and widget, label it Daily OEE Trend Over 24 Hours, set X-axis to Timescale, format Y-l-d, and map X to date and Y to oee. Connect it to the Change node setting msg.oeeTrend to msg.payload.
Click Deploy.
Open the dashboard by clicking the Dashboard 2.0 button located at the top-right corner of the Dashboard 2.0 sidebar.

OEE Dashboard UI flow

Your OEE dashboard is now set up and ready to use. It will visualize key metrics, including OEE, quality, availability, performance, production data, downtime events, and machine performance trends.

OEE Dashboard results without proper theming and styling.

OEE Dashboard results without proper theming and styling

However, the dashboard may not yet look exactly as it did in the previous design or intended layout. Some components may not align correctly with adjacent components in terms of width and height. Additionally, on different screens, you may notice layout inconsistencies, and the top header elements, such as the OEE Dashboard title and logo is missing.

Do not worry—in the next part of this series, we will style the dashboard to match the original design. Later, we will demonstrate how to connect it to a real data source, scale it across your production lines, and explain how you can use this dashboard to improve production efficiency.

What Next?

Part 3 of this series will follow soon. In the meantime, if you’re excited to quickly launch your OEE dashboard in your factory environment, don’t delay! Register for a FlowFuse account now and initiate your journey with our new effective, ready-made OEE Dashboard Blueprint.

Part 1: Building an OEE Dashboard with FlowFuse

2025-04-01T00:00:00Z

OEE (Overall Equipment Effectiveness) is a KPI used in manufacturing to measure equipment performance based on availability, efficiency, and quality.

To effectively track this KPI, an OEE dashboard is built, but creating one can be complex, especially when consolidating data from various sources, with limited flexibility to integrate data across different systems. Additionally, building a customizable dashboard to suit specific needs adds another layer of complexity.

With FlowFuse, it's possible to build a customized, OEE Dashboard, without writing any code, that can provide real-time production data based on your needs.

In this first part of a new blog series on building an OEE dashboard with FlowFuse, we explain the concept of OEE, how it is calculated, and outline the basic plan for the dashboard. In that plan, we cover the scope of OEE calculation, key metrics, visualization strategies, and the expected design of the dashboard.

Let’s get started!

What is OEE?

Overall Equipment Effectiveness (OEE) is a crucial metric in manufacturing that assesses the productivity of equipment through three key components. These components evaluate the efficiency of equipment during the production process:

Availability: How often does the equipment perform when needed?
Performance: How much product does the equipment produce?
Production Quality: How many high-quality products does the equipment produce?

The concept of OEE was introduced by Seiichi Nakajima in the 1960s as part of the Total Productive Maintenance (TPM) initiative in Japan. Nakajima, an engineer at the Japan Institute of Plant Maintenance (JIPM), developed OEE to measure and enhance manufacturing productivity by identifying inefficiencies. This metric has since become widely adopted across the manufacturing industry. Today, OEE remains one of the most critical KPIs, with a really huge number of manufacturers considering it either important or very important for improving production efficiency and minimizing waste.

Measuring and improving OEE allows you to improve the utilization of existing machinery and improves operational efficiency. In many cases, improving OEE is the most strategic and cost-effective approach to increasing output.

How is OEE calculated?

OEE is calculated using the formula:

OEE (%) = Availability × Performance × Quality

Where:

Availability (%) = (Operating Time ÷ Planned Production Time) × 100
Performance (%) = (Actual Output ÷ Maximum Possible Output) × 100
Quality (%) = (Good Products ÷ Total Products) × 100

For example, if a machine is available 90% of the time, runs at 95% of its ideal speed, and 98% of products are defect-free, your OEE would be: 0.90 × 0.95 × 0.98 = 83.7%

Planning Your OEE Dashboard

Now that we’ve covered what OEE is, let's focus on designing a basic plan that details what are the things that we should display on our dashboard. This should consist of three parts:

Scope of the Calculation: How much data will be collected and analyzed?
Key Metrics: Which metrics are the most important to track?
Layout & Visualisation: What visual elements will be used to present the data?

Defining the Scope of OEE Calculation

The first and most important step before creating the dashboard is defining the scope of the OEE calculation. The tracking level can vary based on the focus on area. Scope can vary between:

Machine-level OEE: Concentrates on individual machines, aiding in the identification of specific inefficiencies that impact performance.
Line-level OEE: Assesses the entire production line, offering insights into the collaboration of multiple machines and pinpointing where bottlenecks arise.
Factory-level OEE: Compiles data from various production lines to provide a comprehensive overview of overall efficiency and trends.

For those building dashboards from scratch, it’s advisable to start at the machine level. This approach allows for faster time to value, as data collection can typically begin from a single point, reducing initial complexity. Once you’ve established the machine-level tracking and identified the inefficiencies, you can scale up to line-level and eventually factory-level OEE. Starting with machine-level data ensures that you can quickly uncover key insights and iteratively improve the scope and detail of your dashboard.

For this series, we will be building the dashboard at the line-level. In this case, we will collect data specific to a production line and perform the OEE calculation based on that data.

Key Metrics and Insights

As mentioned earlier, the dashboard will calculate OEE for a production line, presenting key metrics such as availability, performance, quality, and the overall OEE score. While the overall OEE score provides a quick snapshot of performance, it does not offer enough detail to pinpoint specific areas that need improvement.

To address this, the dashboard will break down the OEE calculation at the machine level as well, enabling managers to identify underperforming machines that affect overall efficiency. Additionally, it will display recent downtime incidents, summarizing this data to uncover trends and identify potential root causes. This breakdown will provide a clearer understanding of where inefficiencies are occurring and allow for targeted corrective actions.

The dashboard will also track production quality, displaying the number of acceptable versus defective parts to ensure a continued focus on quality control. Additionally, last 30-days OEE trend analysis will be included, offering insights into performance changes over time. This will help managers identify patterns, monitor improvements, and highlight areas requiring attention.

Dashboard Visualization & UI Design

To ensure that insights are easy to understand and act upon, the dashboard will feature a well-structured visual layout that presents complex data in a clear and intuitive manner. After analyzing various OEE dashboards, I designed this one with a focus on clarity, usability, and actionable insights. It will include gauges for a quick OEE overview, bar charts to track downtime and production trends, tables to highlight underperforming machines and recent downtime events, and line charts to monitor efficiency patterns over time. This setup ensures managers can quickly spot problems, understand their causes, and take the necessary steps to optimize production.

The following dashboard image illustrates the intended design and key objectives of our OEE dashboard. Based on the plan outlined in this part, we will build the dashboard interface in the next part of the series using simulated production and downtime data.

Later, we will show how to connect real factory data, scale the dashboard across multiple production lines, and use it to enhance OEE effectively.

OEE Dashboard

What Next

Here’s Part 2 on the next steps to build your OEE dashboard with FlowFuse. But if you rather skip the tutorials and dive straight in, just register for a FlowFuse account and start using our ready-made OEE Dashboard Blueprint to optimize your operations and boost efficiency right away!

Managing MQTT Connections at Scale in FlowFuse

2025-03-28T00:00:00Z

FlowFuse makes it easy to deploy Node-RED flows at scale using DevOps pipelines and device groups. However, different stages in a pipeline may need different MQTT brokers—for example, one for development and another for production. Manually configuring each stage can be time-consuming, especially when a stage has multiple remote instances (devices).

This article shows how to continue using FlowFuse’s one-click deployment while ensuring that remote instances in each stage of your pipeline connect to the desired MQTT broker without manual configuration.

Goal and Prerequisites

This article explains how to deploy Node-RED flows across different pipeline stages while ensuring each stage connects to its appropriate MQTT broker.

To proceed, ensure that the DevOps pipeline is created with the correct stages. If a stage includes remote instances, verify that all instances are running the FlowFuse Device Agent and are connected to your team.

For more information on how to create a DevOps pipeline, refer to How to Build and Automate DevOps Pipelines for Node-RED Deployments. For instructions on how to create a device group, refer to the Device Groups Documentation.

Setting Environment Variables for Development Instance

For this guide, environment variables will be the key tool to ensure each pipeline stage connects to the correct MQTT broker without manual intervention, allowing for a smooth deployment process.

Since the development remote instance is where the flow will be built and tested, start by adding the necessary environment variables for its MQTT configuration. Setting these up first ensures the flow runs as expected before deploying it to other pipeline stages.

Go to the remote/hosted instance settings in the FlowFuse platform.
Switch to the Environment settings.
Add the following environment variables with the appropriate values for that specific device:
- HOST – The MQTT broker's hostname or IP address.
- PORT – The port number the broker is listening on.
- USERNAME – The authentication username for the MQTT broker.
- PASSWORD – The authentication password for the MQTT broker.
- CLIENT_ID – A unique identifier for the device connecting to the broker.
- CLIENT_ID_SUFFIX – A suffix shared among client IDs within the broker.
- TOPIC – The MQTT topic used for message communication.
Click Save Settings to apply the changes and restart the device.

Configuring MQTT in Node-RED with Environment Variables

Now, let's explore how these environment variables can be used within Node-RED to configure the MQTT broker. Node-RED offers multiple ways to reference environment variables. Here are two primary methods to configure MQTT nodes using environment variables:

1. Using the Configuration Dialog:

Environment variables can be directly referenced in the MQTT node properties using the ${ENV_NAME} syntax as shown in the following images.

Setting up MQTT connection using environment variables.

Configuring MQTT node security settings using environment variables in Node-RED.

Configuring the MQTT topic in Node-RED using environment variables.

2. Setting Values Dynamically via the `msg` Object

In this approach, a Change node is used to retrieve environment variables and set the necessary MQTT configuration properties in the msg object. These properties include:

msg.broker.broker – The MQTT broker’s URL or IP address.
msg.action – Must be set to "connect" when establishing a connection.
msg.broker.force – Must be set to true to enforce the connection.
msg.broker.port – The port number for the MQTT connection.
msg.broker.clientid – The unique client identifier for the device.
msg.broker.username – The MQTT username for authentication.
msg.broker.password – The MQTT password for authentication.
msg.topic – The MQTT topic to which the device will publish or subscribe.

While the first method (direct reference in the MQTT node) is simpler and does not require additional nodes, it has limitations. It works well when there is only a single instance in the pipeline stage. However, when multiple instances exist within the same stage, the client ID, username, password, and topics often vary from device to device. The second method provides greater flexibility by dynamically adjusting these values, ensuring each device connects with the correct credentials and configurations. This approach makes the setup scalable and adaptable, eliminating the need for manual updates during deployment.

Unlike the first approach, which restricts direct combinations (e.g., string + environment variables or environment variables + environment variables), the second method enables dynamic modifications.

Ensuring Unique MQTT Credentials and Topics

As we mentioned in the multi-device deployment scenario, each device needs to establish its own connection to the MQTT broker while maintaining unique credentials and topics. If multiple devices in the same stage use identical configurations, connection conflicts—such as client ID duplication—may occur. To avoid these issues, each device must be assigned a unique client ID, username, password for security, and topic.

To ensure uniqueness, we can use the default environment variables available for each remote instance, such as:

FF_DEVICE_NAME
FF_DEVICE_ID

When generating the client ID for the MQTT broker, the device name (FF_DEVICE_NAME) can be used as the username. Since all client IDs share the same suffix, this suffix can be stored as a device-level environment variable (CLIENT_ID_SUFFIX). By combining both values, we can get the client ID of the device without manual intervention.

For the password, you can use the device ID (FF_DEVICE_ID), which is assigned when creating the client. Alternatively, you can set a common password for all clients by defining it as a device group-level environment variable.

Using a Change node to dynamically set MQTT broker connection properties.

For topics, a combination of a string and FF_DEVICE_NAME can be used to ensure uniqueness.

Configuring MQTT topics dynamically using a Change node in Node-RED.

Note: Ensure that the topic configuration is set dynamically when sending the payload, not when establishing the connection.

Once you have built your flow to connect to the intended MQTT broker using environment variables, deploy it and verify that it works as expected.

Also, if you need an example flow to test and explore in more detail, the following flow is provided. It demonstrates how to configure the MQTT connection dynamically using environment variables and, where needed, generate some settings by combining strings with environment variables.

Setting Environment Variables for a Device Group

After confirming that your flow in the development stage remote instance works as expected and connects to the broker correctly, the next step is to add environment variables.

If your target stage has only a single instance, you can set the environment variables at the instance level, as shown in the image below, and use the first method discussed earlier. This approach is straightforward and efficient for configuring a single instance using environment variables.

Setting environment variables at the instance level in FlowFuse.

However, when multiple remote instances exist within the same stage, such as in a device group, configuring them individually can be impractical, especially when most settings remain the same. To simplify this process, FlowFuse allows you to set environment variables at the device group level, and you can use the second method to make the configuration quick and easy while using remote instance default environment variables.

To add the device group level environment variables follow the steps:

Go to your device group’s settings in the FlowFuse platform.
Add the following environment variables with the appropriate values:
- HOST
- PORT
- CLIENT_ID_SUFFIX
Click Save Settings to apply the changes.

Configuring environment variables at the device group level.

With this approach, you do not need to set environment variables separately for each instance. Instead, the environment variables defined at the device group level will apply to all remote instances within the group, ensuring a consistent and efficient configuration.

Deploying Flow with Stage-Specific Configurations via DevOps Pipeline

Now that everything is set up, trigger the deployment pipeline for the development stage. This will push the flow and settings to the next-stage instances while preserving the existing environment variables. Before applying the new configuration, all remote instances in the target stage will restart automatically.

Deploying Node-RED flows using FlowFuse's DevOps pipeline.

If everything is configured correctly, the MQTT nodes in each remote Node-RED instance will connect to the appropriate broker configured at the device group level.

Monitoring MQTT Topic Hierarchy with FlowFuse

Once the Node-RED flow is deployed on all remote instances in the device group and the MQTT nodes in each instance are connected to the broker, you can monitor and manage all topics across all brokers directly in FlowFuse.

Monitoring MQTT topics in FlowFuse across multiple brokers.

Watch this short video to learn how to bring your own brokers for topic monitoring in FlowFuse: https://youtube.com/shorts/-8TPXb0h0vA?si=wi3wghi4vUWlXJTZ

Conclusion

FlowFuse makes it easy to deploy Node-RED flows while ensuring each stage connects to the right MQTT broker. By using environment variables at both the instance and device group levels, you can automate MQTT configurations, reducing manual setup and ensuring consistency.

Get Started Now

FlowFuse 2.15: Personal Node Collections, Smart Schema Suggestions and more control in DevOps Pipelines!

2025-03-12T00:00:00Z

Our three focal points for the latest release of FlowFuse have been:

Collaborative Development: Our new Custom Node Catalogues provides a place for you to centralise your own private nodes and Javascript libraries for Node-RED.
Full Stack Applications: We've added our new "Smart Schema Suggestions" feature for automatically generating documentation for your MQTT Brokers.
DevOps: We've improved Pipelines now to let you deploy to Device Groups in the middle of a Pipeline, this is just the first step in a wider set of improvements to come for DevOps Pipelines.

Custom Node Catalogues

Screenshot of the new "Custom Nodes" view in Team Library

Pain Point

Many of our customers have very mature Node-RED setups, including large collections of their own, custom node packages that they have built. These packages range significantly in purpose, from small utility functions, to custom hardware integrations.

Until now, to utilise these packages within FlowFuse, you would either need to publish to the public Node-RED Community Catalogue, meaning all of your nodes are available to anyone in the world using Node-RED, or you had to setup and manage your own private NPM registry, which is very time consuming and requires deeper technical knowledge.

Now in FlowFuse

With our new update, every Team- and Enterprise-Tier Library in FlowFuse has an in-built private Node collection, ready for you to go. This means that you can push your custom node packages directly to that registry, and make it available to all of your Instances running in FlowFuse within seconds. This comes built in with full version control and all of the great update mechanisms that you already have in Node-RED.

This new feature also integrates seamlessly ith our Bill of Materials view, providing you the single source of truth to all of your Instance's dependencies in one-place, making it easier to audit and manage your Node-RED instances and their dependencies.

MQTT Broker Integration

Smart Schema Suggestions

We are very pleased to announce our new "Smart Suggestions" feature. When working with an MQTT Broker for live data, it can be difficult to understand the structure of the data and topics that are being used. We recently released the new "Hierarchy" view, showing the topic structure present on a Broker, and we've now evolved that even further.

With Smart Suggestions, you will be presented with proposals as to what FlowFuse thinks your payload schema is, based on the data that is being published to your Broker. If you approve these suggestions, then FlowFuse wll start constructing a schema to represent the traffic on your Broker, and make that available in our new "Schema Documentation" view.

This will save you days of effort in documenting your Broker, and provide a single source of truth for your schema to ensure your team is always on the same page when working with your MQTT data.

Searching for Topics

A very nice, small, improvement we've made to the Broker view too is the ability to search for topics to quickly find the topics of interest. This is a small but very useful feature, especially for those with large numbers of topics on their Broker, enabling you to find the topics of interest much faster.

DevOps Pipelines Improvements

Last year, we announced the introduction of Device Groups. For those that are not familiar with Device Groups, this feature enables users to logically group their Remote Instances so that they can be targeted in a DevOps Pipeline, facilitating streamlined and efficient deployments across your fleet of devices, rolling out a single flow to thousands of Remote Instances within seconds.

Previously, you could only use a Group as the last stage in a Pipeline. With this update, you can now have Groups at other stages in a pipeline. For example, you may have a group of test Remote Instances that you want to push updates to, before pushing them out to your larger group of production Instances.

This improvement not only saves time but also enhances the consistency and reliability of Remote Instance management across your fleet.

Removing Credit Card Requirement for Free Tier

When we recently introduced the new Free Tier for FlowFuse Cloud, we had some legacy architecture in place that meant that, whilst it was entirely free, the Free Tier still require you to put in credit card details.

This is something we've completely overhauled in the new version of FlowFuse, so now, you can just sign up and get started with building your own Remote Instances without the need for any credit card details. It was deployed to FlowFuse Cloud a week ago, and is already proving popular with new users. We can't wait to see what everyone builds on the free tier.

FlowFuse Dashboard Authentication Now Includes User's Role

An enhancement to FlowFuse's underlying Node-RED launcher is the inclusion of the FlowFuse user's role in the user object return by the FlowFuse User Addon. This means you can start building your own RBAC (Role Based Access Control) into your own Node-RED/Dashboard applications, without the need to define roles and access levels directly within your Node-RED flows.

Screenshot showing the inclusion of the user's role within Dashboard's "user" object

What Else Is New?

For a full list of everything that went into our 2.15 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try FlowFuse

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is on our own hosted instance, FlowFuse Cloud.

Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

Monitoring Device Health and Performance at Scale with FlowFuse

2025-02-21T00:00:00Z

Edge devices are everywhere, and their numbers are skyrocketing—from 2.7 billion in 2020 to a projected 7.8 billion by 2030, according to various reports. As these devices become critical for automation and data processing, monitoring their health is essential to ensure reliability and efficiency.

Tracking CPU usage, memory, and system performance helps detect potential issues early, preventing downtime and optimizing operations. In this post, we will explore how to monitor devices using Node-RED and scale this process efficiently with FlowFuse.

What is Device Health Monitoring, and Why is it Important?

Edge devices power IoT and automation, handling communication and data processing. As their numbers grow, ensuring they run efficiently is crucial.

Monitoring device health means tracking key metrics like CPU usage, memory, uptime, and system load. High CPU usage or low memory can slow down processes, disrupt data flow, and reduce efficiency.

For example, in manufacturing, edge devices connect machines to cloud systems for real-time data. If a device fails, production can be impacted.

Regular monitoring helps detect issues early, prevents downtime, and keeps devices running smoothly.

Getting Started with Monitoring Devices

We will begin by monitoring a single device, such as a Raspberry Pi, collecting system data, and visualizing it using FlowFuse. Once the process is clear, we will expand it to monitor multiple devices at scale.

Prerequisites

Before you begin, ensure you have the following:

Running Node-RED Instance: You need a running Node-RED instance on the device you want to monitor. The easiest way to set this up is with the FlowFuse Device Agent, which provides secure remote access, real-time collaboration, snapshots for quick recovery, DevOps tools, and device group management. With it, you can push updates to multiple devices with a single click.

For a step-by-step installation guide, refer to the FlowFuse Device Agent Quickstart.

If you haven’t yet signed up for a FlowFuse account, sign up now.

Required Node-RED Nodes: To collect system data and display it on a dashboard, install the following Node-RED nodes via the Node-RED Palette Manager:

node-red-contrib-os: Retrieves system information such as memory, uptime, and load.
node-red-contrib-cpu: Monitors CPU usage.
@flowfuse/node-red-dashboard: Provides UI components for visualizing system metrics.
node-red-contrib-moment: Formats uptime duration in a human-readable format.

Collecting CPU and System Metrics with Node-RED

Now that Node-RED is running on your device, it’s time to gather essential system metrics. Monitoring CPU usage, memory consumption, system uptime, and load averages helps you monitormonitor performance and spot potential issues before they become serious problems.

Let’s break it down step by step.

Collecting CPU Usage Data

To start, let’s capture CPU usage in real time:

Drag a CPU node from the "Performance" category onto the canvas.
Double-click the node and uncheck all options except "Send a message for overall usage." This ensures you get a clear view of total CPU performance. If you need per-core metrics, you can enable the other options.
Add an Inject node, double-click it, and set it to trigger at a suitable interval (e.g., every second, every 10 seconds, or every 30 seconds). Connect its output to the CPU node.
Add a Debug node and connect it to the output of the CPU node. This lets you view CPU data in the debug pane.
Click Deploy in the top-right corner of the Node-RED editor.

Your debug pane will now start showing live CPU usage data:

An image showing the flow that gathers CPU usage data and prints it in the debug pane

Monitoring Memory Usage

Next, let’s track memory consumption:

Drag a Memory node onto the canvas and double-click it.
Choose the unit for memory display (e.g., gigabytes for easier readability).
Connect the Memory node’s input to the Inject node’s output.
Connect the Memory node’s output to the existing Debug node.
Click Deploy to start monitoring.

Once deployed, you will see a structured object in the debug pane containing along with cpu usage:

An image showing the flow that gathers memory usage data and prints it in the debug pane

totalmem: Total available memory
freemem: Free memory
memusage: Current memory usage

Tracking System Uptime

Monitoring uptime helps detect unexpected reboots and ensures system stability.

Drag an Uptime node onto the canvas.
Connect its input to the Inject node’s output.
Connect its output to the Debug node.
Click Deploy to activate uptime tracking.

Each time the Inject node triggers, the debug pane will display the uptime in seconds and CPU and memory usage.

An image showing the flow that gathers system uptime data and prints it in the debug pane

Analyzing Load Average

To understand how busy your system has been over time, let’s analyze the load average:

Drag a Loadavg node onto the canvas.
Connect its input to the Inject node’s output.
Connect its output to the Debug node.
Click Deploy to start tracking.

This will give you three key metrics:

1-minute load average: Immediate system load
5-minute load average: Recent short-term trend
15-minute load average: Long-term system trend

If these values remain consistently high, your system may struggle under excessive demand, signaling a need for optimization or additional processing power.

With these metrics in place, you have a solid foundation for real-time system monitoring.

Once we have the data, we must send it to the Node-RED instance handling visualization. Keeping the dashboard separate is essential for scalability. As the number of devices increases, a dedicated instance ensures we can monitor all of them from a single, centralized dashboard. This approach also makes management more efficient.

To send data between multiple Node-RED instances we can use FlowFuse's Project Nodes.

Before sending the data though, we combine all collected metrics into a single object for better organization and easier processing. Currently, each node sends its metrics as a separate message object. Merging them into a single object streamlines data handling and reduces message overhead.

Import the following flow and deploy it in the device instance. While I am not covering the step-by-step process here, the explanation below covers what the flow includes and how it works.

Let's understand the flow.

In the flow above, four Change nodes are used, each connected to the output of the CPU, Memory, Uptime, and Loadavg nodes. As mentioned earlier, these nodes provide their data separately as msg.payload. We use Change nodes to modify the message structure before sending the data to ensure a more structured and organized format.

Next, a Join node merges the msg.data objects from all Change nodes into a single data object. After that, another Change node assigns this combined object to msg.payload.

The final combined object appears as shown in the image below:

Combined object containing system data such as CPU usage, memory usage, uptime, and load average.

To share this data with other Node-RED instances, we use the Project Out node, which is available exclusively on FlowFuse. It works similarly to the Node-RED Link nodes, but allows for communication between multiple Instances, and uses MQTT in the background, so also beenfits with topic hierarchies for any communications.

In this Project node, we broadcast the message across all instances in the team using ${FF_DEVICE_NAME} as the topic—an environment variable automatically created in all FlowFuse instances.

Image showing the environment variables of Raspberry Pi devices with their values.

Using environment variables as the topic enables the same flow to be used across multiple devices without modification, ensuring that each device utilizes its own environment variables (device name) and sends data under its respective topic.

Visualizing Data with the FlowFuse Dashboard

Now that the data is being broadcasted, it can be used to build a simple dashboard that visualizes it with different types of charts.

Dashboard monitoring device CPU usage, memory uptime, and load average

Ensure that a separate Hosted Instance has been created in the same Team where the hardware is registered. This instance will be used to deploy the dashboard.

Setting Up the Data Source

Drag the Project In node onto the canvas.
Double-click on it and select "Listen for broadcast messages from".
Choose "All instances and devices" from the "Source" dropdown menu.
Enter the device name in the topic field, ensuring it matches exactly with the ${FF_DEVICE_NAME} device environment variable.
Click Done.

Memory Usage Visualization

Drag two Change nodes onto the canvas.

Double-click on the first Change node. Set msg.payload to:

payload.MEMORY_USAGE.totalmem - payload.MEMORY_USAGE.freemem

Set msg.topic to "USED MEMORY" and click Done.
Double-click on the second Change node, Set msg.payload to:
```
msg.payload.MEMORY_USAGE.freemem
```
Set msg.topic to "Free Memory" and click Done.
Drag a ui-chart widget onto the canvas.
Double-click on the widget and create a new Group.
Set the chart type to "Pie" and action to "Append".
Set X to msg.topic and leave Y empty.
Click Done.
Connect the nodes as follows:

Project In node → Change nodes → ui-chart widget

CPU Usage Visualization

Drag a Change node onto the canvas.
Double-click on the node. Set msg.payload to:
```
$round(payload.CPU_USAGE, 2)
```
Click Done.
Drag a ui-gauge widget onto the canvas.
Double-click on the widget and create a new group.
Set the height and size.
Select "3/4 gauge" with a rounded style.
Set the range from 0 to 100.
Add three segments with colors: 0 (Green), 50 (Yellow), 80 (Red).
Set the label to "CPU" and unit to %.
Click Done.
Connect the nodes as follows:

Project In node → Change node → ui-gauge widget

System Uptime Visualization

Drag the Humanizer node onto the canvas.
Double-click on the node and enter "UPTIME" in the input variable field.
Click Done.
Drag a Change node onto the canvas.
Double-click on the node. Set msg.payload to:
```
msg.payload.humanized
```
Click Done.
Drag a ui-text widget onto the canvas.
Double-click on it and create a new group.
Select the correct layout.
Check the "Apply Styles" option and select the color, font, and size that best suits your needs.
Click Done.
Connect the nodes as follows:

Project In node → Humanizer node → Change node → ui-text widget

Below is the complete dashboard flow, which visualizes the system data we collected.

Scaling Device Monitoring with FlowFuse

Now that we have learned how to monitor a single device, built a flow to gather system data, and created a dashboard to visualize those metrics, the real challenge arises when scaling up to thousands or even tens of thousands of devices. Manually creating a system data-gathering flow for each device would be impractical. However, FlowFuse can automate this process in less than five minutes. Let's see how.

Creating Device Group

Navigate to the FlowFuse platform and go to the Application where your devices are and where you want to create a group. Ensure that all the devices you want to monitor are part of this application.

Showing the option to switch to "Device Groups" and the "Add Device Group" button.

Click on "Device Groups" from the top menu. Next, click on the "Add Device Group" button. In the newly opened window, enter a group name and description, then click "Create".

Form to Create a Device Group: Enter the group name and description

Click on the newly created group and then click the "Edit" button at the top-right.

Image showing the edit button to be clicked on.

Next, in the left-side container, you will see a list of all available devices in your application. Select the devices you want to add to the group (make sure to add only the devices that require the deployment of the flow built to gather system metrics). Click the "Add Devices" button at the top-right of that container, and then click "Save Changes". Once done, you will see all added devices in the right-side container, confirming that they have been successfully added to the group.

Interface to select the devices that must be added to the group, along with the 'Add Devices' button.

Showing the selected devices we chose to add, along with the 'Save Changes' button.

Creating Snapshot

Navigate to the Remote Instance on which we developed the flow to monitor performance. Switch to "Version History" by clicking on "Version History" from the top.
Go to the Snapshots tab and create a new snapshot by clicking the "Create Snapshot" button. Enter details such as the name and description. While making the snapshot, ensure the "Set as Target" option is checked before clicking "Create". Enabling this option sets the created snapshot as the device’s active snapshot. Later, this snapshot will be used for deployment on devices within the device group via the DevOps pipeline.

Showing the option to switch to "Version history" and the "Create Snapshot" button.

Showing the form to create a snapshot and the "Set as Target" option.

If you want to learn more about snapshots, you can read our article Using Snapshots for Version Control in Node-RED with FlowFuse.

Creating a DevOps Pipeline

Navigate to the application where the devices were added and the device group was created. Switch to the "Pipelines" tab at the top, then click "Add Pipeline". In the newly opened window, enter a pipeline name.

Image showing the 'Add Pipeline' button.

Image showing the form to create a pipeline by entering a name.

In the newly added pipeline, click "Add Stage".

Image showing the button to add a stage.

In the newly opened window, select "Remote Instance" as the stage type, enter a stage name, and select the device where the flow was previously built for a single device. Under "Action," select "Use active snapshot" and click "Add Stage".

Image showing the form to add a stage, where a stage is being added for a Raspberry Pi remote instance.

To add another stage, select "Device Group" as the stage type, enter a stage name, choose the previously created device group, and click "Add Stage."

Image showing the form to add a stage, where a stage is being added for a Device Group.

Before moving further, ensure all devices are in fleet mode.

Image showing the fleet mode status of the device (disabling the developer mode option will set the device to fleet mode).

Once both stages are added, click the 'Run Pipeline' button for the first stage. Running the pipeline will deploy the active snapshot to the devices in the device group, including all settings, environment variables, and flows of that instance. Whether the device group has two devices or thousands, the deployment will be completed efficiently and quickly.

To learn more about DevOps pipelines, read the article: Creating and Automating DevOps Pipelines for Node-RED in Industrial Environments.

Now, you have the system data of all devices broadcasted on the topic and the device name. To monitor each device, go to the dashboard instance, copy the flow, and create copies for each device. Ensure that you replace the topic with the corresponding device name. Additionally, create a separate page for each device, assign them to separate groups, and correctly move all copied widgets into the appropriate groups. Alternatively, follow these steps again for each device, and you will have a centralized dashboard monitoring thousands of devices live.

Conclusion

Building a monitoring flow in Node-RED is simple. It allows you to track key system metrics like CPU usage, memory, and uptime with minimal effort. Its low-code Interface makes it easy to create and deploy monitoring solutions quickly.

However, manually deploying this monitoring flow across 10,000 or even 100,000 devices can be a complex and time-consuming task. This is where FlowFuse makes a difference. With features like Device Groups and DevOps pipelines, you can deploy your application from a single device or hosted Node-RED instance to thousands of devices with just a single click. FlowFuse also provides powerful tools for scaling, managing, and monitoring industrial operations, making large-scale deployments more efficient and hassle-free.

Interacting with Arduino using Node-RED

2025-02-12T00:00:00Z

Arduino is a popular open-source platform that lets you build cool electronics projects. It’s affordable and flexible, with lots of different boards and sensors to choose from. However, unlike some other boards, Arduino doesn’t have built-in internet connectivity, which can make remote control a bit tricky. Plus, it usually requires some coding to make things work.

In this guide, I’ll show you how to control and automate your Arduino remotely using Node-RED and FlowFuse, all without writing any code. We’ll use the Firmata protocol to make it easy to send commands and get data from your Arduino. By the end of this tutorial, you’ll have a simple automation setup that you can control from anywhere. Just keep in mind, the Arduino will need to be connected to the device running Node-RED!

Prerequisites

To follow this tutorial, you'll need the following:

Arduino Board: The hardware you'll be using for this project.
USB cable: To connect the Arduino to your computer.
Arduino IDE: Installed and set up to program your Arduino. Download the Arduino IDE if you haven't already done so. we will be using this for initial firmata implementation, not for programming
FlowFuse Account: You will need a FlowFuse instance running on the device connected to the Arduino. FlowFuse allows you to access that remote instance, build flows, create remotely available dashboards, collaborate with your team on the instance, provide robust security, and much more.

Getting Started with Arduino and Node-RED

In this section, we’ll set up Node-RED on FlowFuse and download the Firmata protocol setup on the Arduino using Arduino IDE. We will also create a flow that will control an LED on the Arduino and read input data. We will later control the LED based on object detection using an object sensor to make it more interesting. If you don’t have the sensor, don't worry— you can still follow the article. The goal of this example is to demonstrate both reading and writing operations, as well as build an automation flow that reacts to input.

Step 1: Running Node-RED on the Device connected to Arduino

To begin, you need to run Node-RED on the device connected to your Arduino, whether it is a Raspberry Pi, Windows, or Linux system. However, simply running Node-RED locally is not sufficient if you require remote access. Setting up a server, securing it, and ensuring accessibility can be time-consuming and complex.

Using the FlowFuse device agent simplifies this process. It allows you to remotely access and manage your Node-RED instance without the need for extensive configuration or security management. This approach ensures a more efficient and secure deployment, enabling you to focus on building automation solutions.

For a step-by-step guide on installing and running the FlowFuse device agent, refer to the official documentation: FlowFuse Device Agent Quickstart. By the way, we also offer a free tier that lets you manage up to two edge devices for free. Sign up today!

Step 2: Downloading Firmata protocol setup to Arduino.

Firmata is a protocol for communicating between an Arduino (and other microcontrollers) and the host computer, providing direct access to the IO pins.

Now, let's download the setup to the Arduino. Before proceeding, ensure your Arduino is connected to your laptop or computer via the correct USB cable. The USB connection is essential for uploading the code (sketch) to the Arduino and will also be used by Firmata for communication later.

Setting up Arduino IDE and Download the setup from examples:

Open the Arduino IDE on your computer.
Ensure you have selected the correct board and port in the Tools menu. Since I am using an Arduino Uno 3 board, I’ve selected the Arduino Uno board.
Go to File → Examples → Firmata, and then click on StandardFirmata. This will open the Firmata setup code.
Click the Upload button in the Arduino IDE to upload the setup to your Arduino board.

Importing Standard Firmata setup sketch from examples in Arduino IDE

Once the upload is complete, the Arduino is ready to communicate via the Firmata protocol.

Step 3: Connecting Node-RED to Arduino via Serial Communication

As mentioned earlier, Firmata typically works over a serial connection (such as USB), enabling communication between the Arduino board and your Node-RED instance. The serial communication allows Node-RED to send commands to the Arduino and receive data from it.

First, we will need to install a node that will enable communication between Node-RED and the Arduino via Firmata.

Installing Arduino Node

Open the main menu by clicking the three horizontal lines in the top-right corner.
Click "Manage Palette" from the menu.
Switch to the "Install" tab and type "node-red-node-arduino" in the search field.
Click "Install" next to the node name.

After installing the required node for Arduino, we will set up the flow in Node-RED to establish a connection with the Arduino.

Establishing Connection with Arduino

Drag any Arduino node onto the canvas
Double-click the node to open its configuration window.
In the new window that opens, enter the port name for your Arduino (for example, COM5 on Windows or /dev/ttyUSB0 on Linux/macOS). You can find the correct port in the Arduino IDE or your system’s device manager.

Adding the port to the Arduino node

Click and deploy by clicking the top-right deploy button.

Once deployed, after a few seconds, the node will establish a connection with the Arduino board. You should see a green square below the node, indicating that the connection is successful and the status is "Connected."

Step 4: Sending Commands to Arduino

In this section, I'll show you how to send commands to your Arduino. For this practical demonstration, we will control the default Arduino LED, which is typically connected to pin 13.

Drag the Arduino-out node onto the canvas.
Double-click the node to open its configuration window.
Select the correct configuration (serial port) that you set up in Step 3.
Next, choose the type of pin you want to interact with (e.g., digital, analog, servo, etc.). Since in this example we will be interacting with an LED, which only requires on or off commands, I’ve selected Digital (0/1).

Based on the type of data you want to send, select the appropriate pin type:

Digital (0/1) – accepts 0, 1
Analog (0-255) (PWM) – accepts Integer values from 0 to 255
Servo (0-180) – accepts Integer values from 0 to 180
String – to send a string to the Arduino

Once you've configured the pin type, enter the pin number (e.g., 13 for the built-in LED).
Click Done.

Configuring Arduino-out node

Drag two Inject nodes onto the canvas. For one Inject node, set the payload to true (to turn the LED on), and for the other, set the payload to false (to turn the LED off).
Connect the output of each Inject node to the input of the Arduino-out node.
Deploy the flow.

Now, you can turn the LED on and off by clicking the inject buttons. Instead of using the inject node, you can also use the FlowFuse dashboard to build an interactive dashboard. The dashboard will allow you to control the LED directly from a web interface.

Below is the flow that allows you to control the LED connected to pin 13.

If you're interested in learning how to create a dashboard, you can refer to the Getting Started Guide. It will help clarify basic dashboard concepts and guide you through building a simple dashboard interface.

Step 5: Receiving Inputs from the Arduino

In this step, we’ll focus on receiving inputs from the Arduino to Node-RED. For this practical demonstration, we will use the input from the IR object detection sensor connected to the Arduino.

Drag the Arduino-in node onto the canvas.
Double-click the node to open its configuration window.
Select the serial port to which your Arduino is connected.
Based on the input type, choose the correct pin type (e.g., digital, analog). Since we are using an IR sensor, which typically provides a digital output, select the "Digital pin" type.
Enter the pin number (e.g., pin 9, if your sensor is connected to pin 9 on the Arduino).

Configuring Arduino-in node

Note: You cannot use the same pin for both output and input on the Arduino simultaneously. Ensure the pin you use for input (like the IR sensor) is separate from the pin you're using for output (like the LED).

Click Done.
Drag the Debug node onto the canvas and connect its input to the output of the Arduino-in node.
Deploy the flow.

Now, the Arduino will send the sensor input data to Node-RED. If a change is detected in the input, the Arduino will output that input, and you will see it in the debug panel.

Below, I have provided the flow that reads the IR object detection sensor data connected to pin 9, in case you need it.

Step 6: Creating an Automation Flow

Now that you've learned how to send commands and read inputs from the Arduino, let’s move on to creating an automation flow. This section aims to show you how to program the Arduino without writing a single line of code—using only Node-RED.

The idea is to trigger an action, such as turning on an LED, when the sensor detects an object.

Drag a Switch node onto the canvas.
Double-click on the Switch node to open its configuration window and add the following conditions:

msg.payload == 1
msg.payload == 0

Click Done to save the configuration.

Adding conditions in the Switch node to check if the object is detected or not.

Connect the Switch node's input to the Arduino-in node's output.
Next, drag two Change nodes onto the canvas. Set the payload to false for the first Change node and true for the second Change node.
Connect the first output of the Switch node to the input of the first Change node, and the second output of the Switch node to the input of the second Change node.

Since IR object detection sensors output a LOW (0) signal when an object is detected and a HIGH (1) signal when no object is detected, this flow will turn the LED on when an object is detected (when msg.payload is equal to 0) and turn the LED off object is not detected (when msg.payload is equal to 1).

Below, I have provided the complete flow of how we read the IR object detection sensor data and control the LED in response to the input. I have also included a video demo.

Conclusion

In this tutorial, you’ve learned how to connect your Arduino to Node-RED and control it using the Firmata protocol. We started by turning an LED on and off, reading sensor data, and building a flow to automate actions based on input from an IR sensor.

This approach is so powerful that you don’t need to write any code; FlowFuse lets you create automation flows with just a few clicks. You can quickly expand this setup to include more sensors, devices, and dashboards to build your IoT projects.

It’s a simple yet powerful way to interact with your Arduino, with endless possibilities. Enjoy exploring and building!

FlowFuse 2.14: Announcing Third-Party Broker Integration, UNS Schemas, Enhanced Auth on Remote Instances and more!

2025-02-11T00:00:00Z

This release is full of highlights, which we’ll break down into two key areas - the FlowFuse MQTT Experience and Remote Instances - so you can better digest all of the great new functionality introduced in FlowFuse 2.14.

MQTT Experience in FlowFuse

In October we announced the FlowFuse MQTT Broker, included in our Starter, Team, and Enterprise tiers. It lets you setup your own secure clients to begin publishing and subscribing to your own topics, and building out your full event-driven applications.

We see the MQTT experience and Node-RED experience regularly paired together, and so it's one of our missions at FlowFuse to provide the best developer experience for building out your event-driven applications when these two elements are in play.

Third Party Broker Integration

Whilst the Team Broker is a great addition, we are aware that many of our customers already have their own existing MQTT brokers and infrastructure, so what does FlowFuse bring to the table for them?

With this new release, it is now possible for you to connect your external brokers to FlowFuse. With that, you'll get access to the same great features to help you gain a clear understanding of the activity on your broker, and the structure of the data and topics that are being used.

Schema Generation

A pain point we've seen for many customers is collaboration around a single UNS, or MQTT Broker. There is limited (if any) documentation, and to create that, especially at industrial scale, would be a monstrous and time-consuming task. With that in mind, FlowFuse now offers automated schema generation.

FlowFuse now generates a schema for your MQTT Broker's topic hierarchy, whether you're using the in-built FlowFuse Team Broker, or integrating your own, without you needing to do anything. The schema is generated using the industry-standard, open-sourced, AsyncAPI, and is clearly presented to you in the FlowFuse UI in two formats.

Topic Hierarchy Editor

The first view lives within the FlowFuse UI that you're familiar with, will display your interactive topic hierarchy which you can explore, and is predominantly the "edit" and "review" view of your hierarchy.

Screenshot of the Topic Hierarchy view for a given Broker in FlowFuse

For each topic, you can define descriptions so that team members and anyone interacting with your broker can get a clear understanding of how to get the most out of the hierarchy and associated data.

We have also hopped the first piece of our Smart Suggestions, which is an agent that runs and works out the structure of the payloads to each of your topics. Right now, this is shown in the UI under "Detected Schema", but we have bigger plans here, that hopefully you'll be seeing more of in the very near future.

Personalized UNS Documentation

The second view is focussed on clarity, and collaboration.

Screenshot of the new "Schema Documentation" view provided for brokers on FlowFuse

A big challenge with the Unified Namespace, and wider MQTT too, can be the lack of centralized structure and information around the topics and payloads that are being used. This can make it difficult to understand what is being published and subscribed to, and can make it hard to onboard new projects, team members or partners.

That is why we have built in a new "Schema Documentation" view, available for both the in-built FlowFuse Broker, and any third-party broker that you choose to connect.

This view is built from the automated topic hierarchy, manually added topic descriptions and will soon feature payload schema information from our upcoming Smart Schemas.

Remote Instances

This release sees two new major features coming to Remote Instances (previously known as "Devices").

FlowFuse Authentication now Supported

You can now secure your Remote Instances with FlowFuse Authentication.

This means that you can now use the same credentials you use to log into FlowFuse, to authenticate any HTTP endpoints, such as the FlowFuse Dashboard, on your Remote Instances. This also unlocks features like Multi-Tenant Dashboards that can run on your own hardware at the Edge.

Please note that this does require that your hardware has a connection to FlowFuse.

Version History for Remote Instances

Screenshot of the new "Version History" timeline view available for Remote Instances

This release brings another great update for Remote Instances: the "Timeline" view has been rolled out to provide you a clear picture of everything that has been running on your Remote Instance.

Here you will be able to see every time flows were deployed (for example from within Developer Mode), when settings have updated, Snapshots have been created, or new flows have been deployed via a DevOps Pipeline.

What Else Is New?

For a full list of everything that went into our 2.13 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try FlowFuse

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is on our own hosted instance, FlowFuse Cloud.

Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

Announcing Node-RED Academy!

2025-02-05T00:00:00Z

The Node-RED Academy provides Node-RED courses both for experts, who want to grow their knowledge, and for beginners, who are just learning the ropes. Get formal certification in Node-RED by completing courses and share certificates on LinkedIn to demonstrate your Node-RED learning accomplishments.

What is Node-RED Academy?

Node-RED Academy is a brand new learning portal for Node-RED. Whether you’re a complete beginner to Node-RED or have been building applications for years, Node-RED Academy courses will take your expertise to the next level, and provide you with formal certification that are evidence of your Node-RED knowledge and skills.

Can I Earn a Credential?

All courses completed through Node-RED Academy provide a formal certification upon successful course completion. You can share this certificate on LinkedIn, add it to your CV or show it off anywhere else you like.

The credential will be evidence of your Node-RED knowledge and abilities, and will be a great way to demonstrate your expertise to potential employers or clients.

What Courses are Included?

Our first course, The Node-RED Fundamentals, takes about 90 minutes to complete, is free and available now. Check it out!.

Screenshot of the Node-RED Fundamentals course in progress

We also have plans for the following courses to follow in the future:

Node-RED Advanced
Building Applications with Node-RED
Node-RED for Industry
Node-RED for Teams
FlowFuse Fundamentals
FlowFuse for Teams
FlowFuse Advanced

This list will likely grow beyond this too. We will be evolving our courses based on feedback and ideas from the community too!

Who’s behind the Node-RED Academy?

There are many great resources for Node-RED education out there, but the Node-RED Academy has been curated by the authors and developers behind Node-RED and covers everything you'll need to know from building your first flow to integrating with industrial hardware.

FlowFuse is an enterprise-grade industrial data platform that enables engineers to build, manage, scale, and secure their Node-RED solutions for digitalizing processes and operations. You can sign up for free here to give it a go.

How Do I Get Started?

Head to Node-RED Academy and sign up for free.

Screenshot of the Node-RED Academy home page

The courses include everything you need to learn Node-RED, but you will also need access to an instance of Node-RED to follow along with exercises and apply your new knowledge. The easiest way to get access to Node-RED is with the FlowFuse Starter Plan.

Designing a Clear Topic Structure for Your UNS

2025-01-31T00:00:00Z

Topic structuring is not just a technical concern when building a high-performance Unified Namespace (UNS) for manufacturing environments; it's a strategic design choice that can determine the system's scalability, efficiency, and overall effectiveness.

A well-structured topic hierarchy is critical in manufacturing, where vast amounts of data flow from sensors, machines, and systems. By organizing your topics correctly, you can streamline data flow, simplify scaling, and make your system more manageable as your operations grow.

In this post, we'll explore the significance of topic structuring for your UNS, outline why it's essential for scalability and performance, and share best practices for designing a robust topic hierarchy that can evolve alongside your business.

Why Topic Structuring is Crucial for Your UNS

When building a UNS for manufacturing environments, MQTT is one of the most popular and preferred choices due to its lightweight, efficient, and scalable design. MQTT’s publish-subscribe model is perfect for handling the real-time, high-volume data flow in factories, where machines, sensors, and devices constantly generate information. However, while MQTT is a powerful tool, how you structure your topics plays a pivotal role in ensuring that your UNS is scalable and efficient.

Manufacturing operations often experience rapid growth. The sheer number of sensors, machines, and production lines increases over time, and so does the complexity of the data. MQTT topics are hierarchical, which means they follow a tree-like structure with levels separated by a forward slash (/). This hierarchical structure can mirror the physical layout of your factory floor, providing a logical, scalable framework for your data.

For example:

/factory/line1/machine1/temperature

This topic structure indicates that the data comes from machine1 on line1 of your factory, specifically from a temperature sensor. The structure is intuitive because it directly reflects the factory’s layout. Adding more machines, sensors, or production lines is straightforward as your factory grows.

For instance, as your factory adds a second production line, you can add topics like:

/factory/line2/machine1/temperature
/factory/line2/machine1/vibration
/factory/line2/machine2/temperature

This hierarchical system scales seamlessly as you add more machines, sensors, and production lines without creating unnecessary complexity.

A well-structured topic hierarchy improves the performance of both the network and edge devices. When monitoring or data analysis systems subscribe to topics, they can choose the data they need. This means they are not overwhelmed by unnecessary traffic, which could otherwise strain network bandwidth and device processing power.

For example, imagine a maintenance team only needs to monitor the temperature of machines in line 1. With a clean topic structure, they can subscribe to:

/factory/line1/machine1/temperature
/factory/line1/machine2/temperature

By filtering the data, they avoid receiving irrelevant data, such as vibration readings from other machines or temperatures from machines on different production lines. This reduces network load, ensures more responsive performance, and prevents overloads on edge devices.

A well-organized topic structure makes maintenance and troubleshooting much more efficient. When equipment malfunctions or a sensor starts reporting erroneous data in a smart factory, the ability to pinpoint the issue quickly is crucial. With a hierarchical topic system, you can easily trace the problem to a specific machine, sensor, or production line.

For instance, imagine a temperature sensor on machine 3 in line 2 reporting abnormal values. A topic like:

/factory/line2/machine3/temperature

Immediately indicates the affected machine and production line. This clarity lets your team act quickly, reducing downtime and improving system reliability.

Without a clear topic structure, identifying and diagnosing problems can become time-consuming, leading to extended downtime and inefficiencies.

As new equipment, sensors, or production lines are added to the factory, a well-structured topic system helps onboard new engineers, technicians, and operators easily. A clear hierarchy provides a visual map of the system, making it easier for new users to understand the architecture and begin working with it quickly.

Designing a Topic Structure for Your UNS

Before you start collecting data in your UNS, it’s essential to design your topic structure. While it might seem like a small step, it’s the foundation of your system. Taking the time to plan will save you significant time and effort down the road. More importantly, it gives you a clear, high-level view of your entire factory, which is crucial for scaling effectively.

First, think about the key components of your factory. For example, you might have different plants or production lines in a manufacturing setting. There will be machines or devices within each production line that produce data. Then, you’ll have various data points coming from sensors on these machines, such as temperature, humidity, or pressure.

By organizing your topics around these components, you’re setting up a structure that’s easy to scale.

Next, remember that MQTT topics are hierarchical, so think of them like a tree. At the top of the tree, you’ll have the broadest categories (like plants or regions). As you go down, you’ll get more specific, with production lines, machines, and then individual data points like sensor readings. The key is to keep things logical so that you can locate the data you need quickly. This organization lets you promptly expand your system later by adding new plants, lines, or machines without disrupting the entire structure.

The concept of structuring topics logically and hierarchically draws from a well-known framework in manufacturing: ISA-95. ISA-95 is a standard that defines a hierarchical model for organizing and managing manufacturing systems. It divides operations from the company level to individual machines, providing a clear structure for system management.

ISA-95 Equipment Hierarchy Model

Here’s a brief breakdown of the ISA-95 levels and how they can be translated to MQTT topics:

Level 0 – Physical Devices and Control

This is where the physical data originates: sensors, actuators, and devices directly interacting with machinery and production lines. These are typically represented as devices in your MQTT topic structure.

Example Topics:

/plantA/productionLine1/machineB/sensor/temperature
/plantA/productionLine1/machineB/sensor/pressure
/plantA/productionLine2/machineC/sensor/humidity

At this level, you're dealing with specific machines and sensors. The topic name clearly defines the device type (e.g., "sensor") and the type of data it generates (e.g., "temperature"). This structure makes tracking sensor data easy for each machine or production line.

Level 1 – Control Devices and Systems

This level represents the control systems that operate the machinery and manage the data flow. These systems include PLCs, SCADA systems, or other control devices that manage real-time operations.

Example Topics:

/plantA/productionLine1/machineB/PLC/status
/plantA/productionLine1/machineB/PLC/mode
/plantA/productionLine2/machineC/SCADA/alerts

Topics at this level might focus on the status and control functions of the machines. Separating control systems like PLCs or SCADA ensures that operational data (e.g., machine modes or alerts) is distinct from raw sensor data. This approach ensures that each system component can be monitored and managed independently.

Level 2 – Monitoring and Supervisory Control

At this level, systems monitor and manage operations. They might include higher-level systems that oversee the production lines, collect data from multiple PLCs, and trigger alerts or analyses based on predefined criteria.

Example Topics:

/plantA/productionLine1/supervisor/alerts
/plantA/productionLine1/supervisor/performance
/plantA/productionLine2/supervisor/utilization

Here, you might aggregate data from several control devices (like PLCs) and provide higher-level insight into the overall system. For example, a "performance" topic could aggregate sensor data to monitor the efficiency of a production line, while "alerts" might be used for system-wide warnings.

Level 3 – Manufacturing Operations Management

This level encompasses managing the overall production process, such as scheduling, production orders, and resource management. This is often where MES (Manufacturing Execution Systems) comes into play.

Example Topics:

/plantA/productionLine1/MES/productionOrder
/plantA/productionLine2/MES/scheduling
/plantB/productionLine1/MES/inventoryStatus

The data becomes more abstract at this level as you deal with business logic, production orders, and scheduling systems. For example, the "productionOrder" topic could track orders for specific products, while "inventoryStatus" could provide data on material availability for each production line.

Level 4 – Enterprise Resource Planning (ERP)

The highest level in the ISA-95 hierarchy is focused on enterprise-wide resource planning, financials, and decision-making processes. ERP systems integrate with manufacturing systems to provide broader business insights.

Example Topics:

/enterprise/ERP/inventory/overview
/enterprise/ERP/sales/orders
/enterprise/ERP/production/metrics

At the ERP level, topics reflect cross-plant business data like inventory, order management, or performance metrics. These are less granular than lower levels and provide decision-makers with high-level insights into the health of the overall business.

Best Practices for Managing Your Topic Structure

As your UNS scales, following some essential best practices will ensure your topic structure remains efficient, secure, and easy to manage.

Maintain Clear Documentation:

First and foremost, maintaining clear documentation is key. A well-documented topic hierarchy is a reference point for everyone involved in the system—from developers and engineers to system administrators. This documentation should outline the naming conventions, the purpose of each topic, and how new issues should be added. Without it, there's a risk of inconsistency creeping into your system, especially as new data streams and devices are introduced. An apparent, organized reference ensures your team can efficiently navigate and expand the system without confusion.

Ensuring Consistency in Naming and Structure:

Using clear, descriptive names for each topic and sticking to a consistent naming pattern across your system is essential for long-term success. A well-defined naming convention ensures that everyone involved—whether developers, engineers, or system administrators—can easily understand the purpose of each topic. Navigating your UNS becomes intuitive when topics are consistently named, and troubleshooting issues is much easier.

For instance, avoid vague or overly generic names like /sensor1/data, which don’t offer much context. Instead, adopt more descriptive, hierarchical names that reflect the actual source and nature of the data, such as /plantA/productionLine1/machineB/temperature. A consistent structure not only enhances system readability but also ensures scalability.

Keep Topic Names Simple and Avoid Special Characters:

While it’s essential to have descriptive topic names, they should also be simple and easy to use. Long topic names can make working with your UNS quickly and efficiently harder. Also, avoid using spaces or special characters, which might cause compatibility issues with some MQTT brokers or clients.

Perform Regular Topic Cleanup and Expiration:

Next, don’t overlook the importance of topic cleanup and expiration. Over time, unused or obsolete topics can accumulate, adding unnecessary complexity and overhead to the system. Left unchecked, these stale topics can lead to unwanted confusion. It’s important to regularly audit the issues in your UNS, archiving or removing those no longer needed. While some MQTT systems support automatic topic expiration, implementing manual checks as part of your routine system maintenance is still a good practice. You’ll also want to manage the use of retained messages carefully. While they can help provide the latest state to new subscribers, overuse or misuse can lead to outdated information circulating across the system. Be mindful about which topics should retain data and ensure they are updated or cleaned up regularly.

Implement Robust Access Control:

Access control is essential in managing a large-scale UNS. The hierarchical structure of MQTT topics naturally supports role-based access control (RBAC), allowing you to assign permissions based on topics. This ensures users and devices only access the data they need.

For example, engineers might only need access to machine-level sensor data, while plant managers require broader visibility into performance metrics across production lines. Additionally, you can restrict which devices can publish data on specific topics, ensuring only authorized systems send critical updates.

By defining clear access rules, you enhance security, maintain data integrity, and ensure that your UNS can scale efficiently as your organization grows.

Effortless MQTT and Topic Management with FlowFuse

FlowFuse is more than just a low-code platform; it’s a game-changer for building and scaling your UNS. By seamlessly integrating MQTT, FlowFuse empowers you to connect, manage, and scale your industrial data systems efficiently.

FlowFuse's built-in MQTT broker gives you high-performance data handling without additional infrastructure overhead. The platform also features an interface for managing MQTT clients with access control for topics and an intuitive Topic Hierarchy View, which provides a real-time, visual representation of your entire MQTT topic structure. This makes organizing, monitoring, and managing your topics easy, ensuring clarity and consistency as your system grows.

Image showing FlowFuse topic hierarchy interface for UNS

What truly stands out is FlowFuse's ability to handle both legacy and modern industrial protocols, effortlessly bridging the gap between old and new systems. Whether adding new devices, integrating data streams, or scaling to thousands of devices, FlowFuse gives you the flexibility, scalability, and security you need to optimize your UNS at every step.

FlowFuse doesn’t just help you manage topics—it streamlines collaboration, enhances system performance, and accelerates your journey toward a fully integrated, future-proof UNS.

Looking to simplify your UNS management? Unlock the full potential of your data architecture with FlowFuse.

How to Choose the Right IIoT Device Management Software for Your Business

2025-01-24T00:00:00Z

With more devices being connected across industrial environments, managing them can get pretty overwhelming. The right IIoT device management software can help you stay on top of things—keeping everything secure, up-to-date, and running smoothly. But with so many options out there, how do you figure out which one’s best for your business?

This guide will take you through the key features and considerations to keep in mind when choosing IIoT device management software. Whether you’re just starting out with IIoT or looking to improve your current setup, we’ve got some helpful insights to point you in the right direction.

1. Vendor Reputation and Support

When it comes to IIoT systems, the right vendor can make all the difference. After all, your device management platform will be at the heart of your manufacturing operations, and any hiccups can result in costly downtime. That's why choosing a vendor with a solid reputation is non-negotiable. Start by researching companies that have a proven track record in industrial environments. Look for vendors who not only understand the technical side of IIoT but also know how to support real-world use cases in manufacturing. Customer reviews and case studies can provide valuable insight into their reliability, service quality, and expertise.

One of the most important factors to consider is the availability of customer support. Your platform should be backed by a responsive, accessible support team, especially when things go wrong. In high-pressure situations, like production delays or equipment failures, 24/7 support can be a game-changer. You don’t want to be waiting hours for help when every minute counts. Look for vendors that offer clear, well-documented resources along with robust, round-the-clock support to guide you through troubleshooting and problem resolution.

2. Remote Access

The best device management software should make it easy to manage devices from anywhere. Remote access is crucial, especially for businesses with devices spread across different locations or those that operate 24/7. With remote access, your team can monitor device performance, troubleshoot issues, and push updates without needing to be on-site. This flexibility reduces downtime and ensures everything stays operational, no matter where you are.

For example, imagine you have a factory in a remote area and a critical device experiences a malfunction. Without remote access, you would need to send a technician on-site, which could involve travel time, accommodation, and delays in getting the machine back up and running. This can be costly—not just in terms of money but also in lost production time. With remote access, however, your team can instantly diagnose the issue, push an update, or even resolve the problem without the need for a costly site visit. This means less downtime, faster resolutions, and a more efficient operation overall.

3. Automated Monitoring and Alerts

In manufacturing, keeping a constant watch on device health is crucial to avoid unexpected failures that could lead to costly downtime. The ideal device management platform should automatically track key performance metrics—such as device crashes, CPU usage, and more. By continuously monitoring these metrics, the platform can quickly identify any abnormalities and alert your team before small issues escalate into major problems.

For example, imagine a device on the factory floor experiences high CPU usage and is about to crash. An automated alert would immediately notify your team, allowing them to take swift action and address the issue before it causes a disruption. This proactive approach helps keep production running smoothly and minimizes unnecessary downtime.

The platform should also allow you to set custom thresholds for specific performance metrics. This way, your team will only receive alerts for critical issues, reducing the noise from less important events. With this level of precision, responses become faster and more focused, ensuring that the most pressing concerns are addressed promptly.

Automated monitoring and alerts not only save time but also increase the reliability and productivity of your IIoT ecosystem. By catching potential failures early, you can prevent unplanned downtime and ensure that your operations remain efficient and uninterrupted.

4. Device Grouping and Scalability

As your IIoT network grows, managing each device individually can quickly become overwhelming. That's why it's essential to choose a platform that allows you to group devices by function, location, or type. For example, you could group all the devices in Production Line 1, making it easier to deploy workflows, software updates, or configurations with just a single click for all.

Device grouping simplifies the management process, enabling you to update settings, deploy updates, and troubleshoot multiple devices at once. Scalability is also crucial—your platform should seamlessly accommodate new devices as your operations expand, without adding unnecessary complexity or slowing down performance.

With the right platform, you can keep your IIoT network organized and scalable, ensuring that as your business grows, device management remains efficient and hassle-free.

5. Wide Range of Device Support

In a busy manufacturing environment, you're working with a mix of devices—some on Linux, some on Windows, and others with their own custom software. The last thing you want is to have to juggle multiple platforms to manage all your devices.

Find a device management system that works with all of them. A flexible platform will let you manage all your devices, regardless of their operating system, from one central dashboard. This makes your life a lot easier and keeps your operations running smoothly.

6. Built-in DevOps Toolset

Automation is essential for boosting manufacturing efficiency. device management platforms with built-in DevOps tools integrate easily with production systems. They automate tasks like device setup, configuration, and software updates, helping reduce downtime and speed up troubleshooting.

DevOps pipelines allow you to create workflows tailored to your needs, automating updates and maintenance for IIoT devices. This means your platform can push updates without interrupting production, reducing the need for manual work.

With the flexibility to create custom DevOps pipelines, you can manage devices more efficiently, save time, minimize errors, and keep everything aligned with production requirements.

7. Real-Time Collaboration

Managing IIoT devices often involves teams working together, sometimes from different locations. That’s why having a platform that supports real-time collaboration is so important. It allows your team to stay in sync, making it easier to troubleshoot issues or implement updates without delays.

Look for a platform that lets multiple team members access and manage devices at the same time. This way, everyone can contribute to resolving problems or pushing updates without stepping on each other’s toes. Real-time collaboration helps keep things running smoothly, especially when quick responses are needed.

8. Accidental Recovery or Rollback

Another essential feature to look for is the ability to recover from system failures or accidental misconfigurations. Accidents can happen at any time, and being able to revert to a previous stable state quickly can save you from costly downtime and operational disruptions.

The ideal IIoT device management platform should include a snapshot or rollback functionality. This allows you to take snapshots of your device configurations and system state at various points in time. In the event of an issue, you can simply roll back to a previous snapshot, restoring your devices to their last known good state.

This feature is especially critical in production environments where system stability is key to preventing operations interruptions. It minimizes downtime, ensures data integrity, and provides peace of mind, knowing that you can recover quickly from mistakes or technical failures.

9. System And Audit Log Management

When it comes to managing IIoT devices, keeping track of what’s happening in your system is essential. A good platform will automatically log everything—device activities, errors, and user actions—so you can stay on top of things.

Audit logs are especially helpful because they tell you who accessed the system, what actions were taken, and when they happened. This level of visibility makes it easier to spot any security risks or unauthorized changes early, helping you address them before they turn into bigger issues.

These logs are also crucial for compliance. By maintaining a clear record of all changes, you can easily demonstrate that your system meets industry regulations and standards. This adds an extra layer of security and peace of mind, knowing that everything is being properly documented and monitored.

10. Strong Security Features

When it comes to IIoT, security is a top priority, especially with sensitive production data involved. Look for a platform that offers end-to-end encryption to ensure your data stays protected as it moves between devices and the cloud.

Access control is also important. A good IIoT platform will limit device access based on user roles, so only authorized personnel can view or make changes to sensitive data. This helps keep things secure by preventing unauthorized access.

To stay ahead of potential security risks, the platform should include vulnerability scanning tools like SBOM (Software Bill of Materials). These tools help you track and manage any risks from third-party software, giving you peace of mind.

For added protection, choose a platform that supports multi-factor authentication (MFA). MFA provides an extra layer of security in case login credentials are compromised.

Finally, make sure the platform secures device-to-cloud for remote accesss connections with methods like SSH tunneling and VPNs. These help ensure that data is transmitted safely and only accessible by trusted users, no matter where your devices are located.

11. User-Friendly Interface

Your team shouldn’t waste time struggling with a complicated platform in a busy manufacturing environment. Choose a device management platform with a simple, intuitive interface that makes monitoring devices, adjusting settings, and resolving issues quick and easy.

A clean, easy-to-navigate UI allows your team to stay focused on key tasks like tracking device health and performance without unnecessary complexity. Simple controls for configuring devices, applying updates, and onboarding new devices will save time and reduce frustration.

12. Cost Considerations

When selecting a device management platform, it's crucial to look beyond just the initial cost. Consider the total cost of ownership, which includes licensing fees, ongoing maintenance, training, and technical support. These factors can add up over time, so it’s important to factor them into your decision-making process.

For example, a platform that charges based on the number of devices may seem affordable when you're just starting with a small network. However, as your operations scale, those costs can quickly increase. Take the time to compare different pricing models and choose the one that best fits your budget and future growth plans. This will ensure that your investment remains sustainable and supports your business over the long term.

13. Integration with Existing Systems

A good device management platform should make it easy for your devices to integrate with your existing systems—whether that’s your ERP, CRM, or maintenance software. This helps prevent data silos and ensures all your existing systems can work together and share data in real-time.

When your devices, machines, and software are connected, it keeps important information flowing freely across your operations. This makes it simpler to track inventory, monitor device health, or manage maintenance, and it helps you make more informed decisions.

The right platform should support a wide range of industrial protocols, from the latest to older systems, so everything can be included. By linking all your existing systems, you can create a single source of truth, keeping things running more smoothly and efficiently.

So, after all’s said and done, the secret to choosing the right IIoT device management software isn’t just about checking boxes on a list. It’s about finding a solution that keeps things simple, secure, and scalable for the long haul. Look for something that lets you stay in control, whether you're managing one device or a thousand, and make sure it’s backed by solid support when you need it most. In the end, the right platform should feel less like a tool and more like a partner that grows with you. Trust me, the right fit will make your life a whole lot easier.

FlowFuse – The Ultimate IIoT Device Management Solution

FlowFuse is an open-source industrial data platform that simplifies the management, scaling, and security of IIoT devices. Whether you're managing a handful of devices or overseeing thousands, FlowFuse consolidates everything into a single, intuitive interface. With seamless cross-platform support, you can control all your devices from one central hub, streamlining operations and enhancing efficiency.

Built on the flexible Node-RED framework, FlowFuse easily integrates with a wide range of hardware, services, and APIs with over 5000 community contributed nodes, allowing you to tailor and scale your IIoT network to meet evolving demands. The best part? You don’t need coding knowledge to get started—Node-RED’s visual programming interface makes it easy to create custom workflows with drag-and-drop functionality. With 24/7 expert support and an active community, you'll have access to the resources you need to resolve any challenges quickly.

Security is a top priority for FlowFuse. With features like SSH tunneling for secure remote device access, end-to-end encryption, and multi-factor authentication, your data is protected no matter where it’s being transferred. Role-Based Access Control (RBAC) ensures that only authorized users can make critical changes, while SOC 2 compliance provides an added layer of assurance for your sensitive operations.

Real-time collaboration is built into the platform, enabling your team to work together on projects, monitor devices remotely, and deploy updates simultaneously—all within a secure environment. Role-Based Access Control (RBAC) ensures that each team member has appropriate permissions based on their role. For example, admins can make critical changes, while operators can only monitor or update devices. This helps maintain control over sensitive functions while allowing your team to collaborate effectively. Together with RBAC, FlowFuse maximizes both security and productivity by ensuring the right people have access to the right tasks, at the right time.

If things go awry, FlowFuse’s snapshot feature lets you quickly revert to a previous stable state, minimizing downtime and keeping your systems running smoothly. Advanced monitoring tools continuously track device performance, sending alerts if issues like crashes or resource overloads arise, so your team can act before problems escalate. Detailed device logs and audit trails make troubleshooting straightforward, helping you quickly pinpoint issues and maintain a secure environment.

FlowFuse offers flexible pricing plans, including a free tier that allows you to manage up to two devices—so you can try the platform before making any commitment. Whether you’re just starting out or scaling your operations, FlowFuse provides the tools and support you need to efficiently manage your IIoT network.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

Let’s Walk You Through It – Book a Demo Today

Why FlowFuse is the Complete Toolkit For Building UNS?

2025-01-20T00:00:00Z

Unified Namespace (UNS) is changing the way data is managed in industrial environments. It’s becoming the key to more successful and productive operations. Many organizations have already implemented it, and others are still figuring out the best approach and platform to implement it. There are so many tools out there; how do you know which one is right for your UNS? It’s a big decision, and it can be overwhelming. The good news? FlowFuse is the toolkit you’ve been looking for! It’s an all-in-one platform to build your UNS—and it’s open-source!

At its core, a Unified Namespace (UNS) is a data architecture that centralizes all your data from devices, sensors, and systems into a single hub. It helps you make sense of everything by organizing, structuring, and standardizing your data for easy access and analysis. Instead of dealing with fragmented data silos, you get a unified, real-time view of your entire operation.

Think of it as the brain of your entire operation, connecting all your business events in one place. Whether you're tracking performance, optimizing workflows, or making real-time decisions, a well-designed UNS makes it all possible. For more details, check out our article: Introduction to the Unified Namespace.

Core Components of UNS and How FlowFuse Fits In

To truly understand why FlowFuse is the ultimate toolkit for building and managing UNS, we need to explore its core components and see how FlowFuse enhances each one to help create a successful Unified Namespace in industrial IoT environments.

Core Components of UNS: Key Elements to Consider When Building Your UNS

1. Connectivity Layer

The Connectivity Layer is the foundation of your UNS ecosystem. It’s what collects data from all your devices and systems—whether that’s sensors on the factory floor, PLCs, or IoT devices—and sends it to your UNS. Without a strong connectivity layer, your UNS won’t have the data it needs to create a complete view of your operations.

How FlowFuse Helps:

This is where FlowFuse comes in. Built on the powerful Node-RED platform, FlowFuse takes the complexity out of connecting devices. Whether you're dealing with legacy systems (think Modbus or OPC-UA) or the latest IoT devices (like MQTT or HTTP), FlowFuse ensures that everything can speak the same language. It connects your old and new technologies, effortlessly streaming data into your UNS.

With more than 5,000 available community contributed nodes, FlowFuse helps bridge the gap between old and new technologies. For example, if you have machines that use Modbus and new sensors using MQTT, FlowFuse can help them all send data into your UNS without any issues.

2. Data Transformation Layer

Once you’ve connected your devices and started collecting data, it’s time to send that data to your UNS. However, before that happens, there's an important step: data transformation. The data you collect often comes in different formats, units, or structures, which can create confusion and inefficiency when trying to use it across your system.

This is where the Data Transformation Layer plays a key role. It’s responsible for standardizing and enriching the data, ensuring it’s consistent, accurate, and ready to be used by your entire IIoT system. Without this layer, your data would remain fragmented and inconsistent—making integration difficult and analysis unreliable. Without proper transformation, your UNS wouldn’t be a true UNS; it would just be an data repository or dump.

How FlowFuse Fits In:

FlowFuse simplifies data transformation with its intuitive Node-RED interface. This allows engineers to set up complex data processing workflows with minimal effort. Whether you need to convert units of measurement, clean raw data, or reformat it, FlowFuse offers a low-code environment where you can drag and drop nodes to handle these tasks without needing to write custom code.

Beyond transforming data formats, FlowFuse also enables data contextualization. As raw data flows in, it can be enriched with important metadata—such as timestamps, equipment IDs, or sensor locations—that add context and make the data more meaningful. This is vital for accurate analysis and informed decision-making.

For instance, imagine temperature readings coming from multiple devices, with some sensors reporting in Celsius, others in Fahrenheit, and others in Kelvin. FlowFuse can automatically standardize all these readings to a single unit (like Celsius) and add contextual information, such as which machine the data came from and its current operating status. This makes the data easy to understand and act upon in your UNS.

3. Message Broker

In UNS), the Message Broker is the central hub where your data resides until it’s accessed or consumed by other systems. It ensures that data flows smoothly between devices and applications, using a publish-subscribe (pub-sub) model. Systems "subscribe" to topics and receive automatic updates whenever new data is published, keeping everything in sync and up to date.

The Message Broker must support the pub-sub model, which is a core requirement for the UNS. For more information on why this model is essential, please read our article on why UNS needs pub-sub. The pub-sub model decouples producers (publishers) from consumers (subscribers), meaning they don’t need to be directly connected or even aware of each other. This decoupling enhances flexibility and scalability. Additionally, it makes the UNS event-driven, eliminating the need for constant polling. Systems only receive data when it’s relevant, boosting efficiency and responsiveness.

MQTT is the ideal broker that supports the pub-sub model and popular choice for uns. It’s lightweight, efficient, and works well in environments with limited resources.

How FlowFuse Fits In:

With FlowFuse, you get a built-in MQTT Broker, which means there's no need to configure and maintain a separate system. This simplifies the connection of all your devices and systems, ensuring smooth data exchange within your UNS. FlowFuse makes it easy to manage connections, organize topics, and configure security features such as TLS encryption and username/password authentication—all within a single platform. This keeps your setup streamlined and secure.

The MQTT Broker supports hierarchical topic structuring, allowing you to efficiently organize and manage your data flows. In FlowFuse, you have an interface to monitor all your UNS topics in a tree view, as well as a secure interface to manage your MQTT clients.

Node-RED in FlowFuse comes with standard MQTT nodes, making it easy to set up secure connections to your broker. You can quickly configure security features like TLS encryption and username/password authentication or dynamically subscribe to topics

FlowFuse makes building and managing a Unified Namespace (UNS) easy. It connects devices, transforms data into a usable format, and ensures smooth communication using an MQTT broker. Powered by Node-RED, it works with old and new systems, helping you scale and adapt quickly.

What Makes FlowFuse Stand Out in Industrial IoT?

FlowFuse isn’t just another tool—it's a complete solution for building and managing a Unified Namespace (UNS). While other platforms may specialize in certain areas, FlowFuse brings everything together: connectivity, data transformation, and message brokering, all in one platform.

Many tools excel in one area but fall short in others. Some may connect devices well but struggle with legacy systems or data transformation. FlowFuse solves these challenges by offering an all-in-one solution that works seamlessly with both modern and legacy systems.

As an open-source platform, FlowFuse removes the worry of vendor lock-in. You have the flexibility to transition to other services if your needs evolve, without worrying about compatibility issues.

FlowFuse also includes powerful features tailored for industrial environments. One standout is real-time collaboration, which allows multiple engineers to work on Node-RED flows simultaneously—speeding up development and deployment. Additionally, you can remotely manage edge devices, reducing the need for costly on-site visits for troubleshooting or updates.

When it comes to scaling, FlowFuse is built to grow with you. It supports horizontal scaling to balance workloads across multiple instances and vertical scaling to add more resources as your needs increase. Whether you’re scaling up or dealing with high workloads, FlowFuse ensures your infrastructure remains stable and efficient.

Security is a major priority with FlowFuse. It includes features like role-based access control, encryption, multi-factory authentication, and detailed audit logs to keep your data secure and meet industry standards.

On top of that, FlowFuse provides features like DevOps pipeline management, snapshots for disaster recovery, and much more, ensuring your systems are always running smoothly and reliably.

Summary

FlowFuse is a complete platform for building and managing a Unified Namespace. It combines everything you need—connectivity, data transformation, and message brokering—into one easy-to-use solution. Open-source flexibility makes it simple to connect devices, scale your system, and keep data secure.

Want to learn more about how FlowFuse can help?

Let’s Walk You Through It – Book a Demo Today

Getting Started: Integrating Siemens S7 PLCs with Node-RED

2025-01-17T00:00:00Z

Siemens S7 PLCs are a staple in industrial automation, powering everything from basic control functions to complex, large-scale processes. However, integrating these PLCs with other systems for remote monitoring or data sharing can present challenges.

This is where Node-RED comes in, offering a user-friendly solution to seamlessly connect Siemens S7 PLCs with a variety of platforms. With its intuitive flow-based interface, Node-RED enables you to create custom workflows and dashboards—no deep technical expertise required.

Siemens S7 PLCs are typically programmed using TIA Portal, Siemens' integrated development environment, and communication with external systems usually relies on the S7 protocol (ISO over TCP/IP). In this article, we’ll walk you through how to use Node-RED to read from and write to Siemens S7 PLCs via the S7 protocol, unlocking new possibilities for remote control and system integration in your industrial automation setup.

Prerequisite

Before integrating your Siemens S7 PLC with Node-RED, make sure you have the following :

Before downloading the ladder program and all configurations and settings to your PLC, make sure you have the following settings:

Allow PUT/GET Communication from remote partners.

PUT/GET Communication from remote partners is Allowed

Provide full access to the PLC (no protection), allowing unrestricted access to data exchange.

Providing complete access to the PLC

Ensure that the appropriate ladder program (or any other logic) is written according to your requirements and successfully downloaded to the PLC. However, before downloading, make sure the 'Optimized Block Access' option is disabled for the data block that your ladder program using.

Untick 'Optimized Block Access.'

Install Node-RED on the device that will communicate with the S7 PLC. You cannot install Node-RED directly on the S7 PLC, as PLCs are typically controllers, not computers. For example, you can use a device like the Revolutionary Pi to connect and transfer data across systems. Use the FlowFuse Device Agent to install Node-RED on your device.

Why FlowFuse Device Agent? It allows you to manage Node-RED remotely, enabling control, monitoring, and flow creation without the need for on-site visits. FlowFuse also offers a suite of enterprise-grade features such as collaboration, device management, and DevOps pipelines, which are essential in industrial environments. These features help streamline operations and ensure scalability in complex automation systems. Sign up for free to get started.

Verify that the device running Node-RED is in the same network as the PLC and can successfully ping the PLC. Also, a firewall should not block the S7 port (typically port 102).

Integrating Siemens S7 PLCs with Node-RED

Now that everything is set up, let's integrate your Siemens S7 PLC with Node-RED. In this article, I’ll demonstrate the process using a Siemens S7-1212C PLC. I’ve connected it to a stack/tower light and will walk you through how to write data to the PLC to control this light. Later, I’ll show you how to read data and reflect the status of the light.

My program in TIA Portal is structured as shown below, utilizing DB (Data Blocks) and Q (physical outputs) to control devices. However, Node-RED can retrieve almost all types of data from the PLC. The process is similar for most data types.

Ladder Logic to Control Outputs for Managing Lights

Let’s break down what’s happening in the ladder logic above. First, we have open contacts, each with address variables defined in a separate Data Block. There are three open branches, each starting with an open contact. Each contact is connected to an output that alters the status of a Q physical address. Each Q corresponds to a physical output on the PLC, which is wired to the lights. When we change the status of a contact to "true," it activates the corresponding light by altering the state of the Q output, which reflects the change in the physical output.

Installing the S7 Node

To communicate from Node-RED to the PLC, we need to install the S7 node, which allows Node-RED to interface with Siemens S7 PLCs. In this article, we will be using node-red-contrib-s7, which is quite popular. If this particular node is not suitable for your workflow you can find alternatives in the Node-RED catalog.

Steps to Install the S7 Node:

Open your Node-RED editor in a web browser.
Open the main menu by clicking the three horizontal lines in the top-right corner.
Click "Manage Palette" from the menu.
Switch to the "Install" tab and type node-red-contrib-s7 in the search field.
Click "Install" next to the node name.

Once the installation is complete, the S7 nodes will be available in your Node-RED palette, and you can start using it to communicate with your Siemens S7 PLC.

Addressing Scheme for Variables in Node-RED with the S7 Node

Before we start, it's important to note that the variables and their addresses configured on the S7 endpoint follow a slightly different addressing scheme compared to those used in Step 7 or the TIA Portal. Therefore, when adding variables to the S7 node in Node-RED, you must ensure that you follow the correct addressing format outlined in the table below.

Node-RED Address	Step7 Equivalent	Data Type	Description
`DB5,X0.1`	`DB5.DBX0.1`	Boolean	Bit 1 of byte 0 in DB5
`DB23,BYTE1`	`DB23.DBB1`	Number (Byte)	Byte 1 (0-255) of DB23
`DB100,CHAR2`	`DB100.DBB2`	String	Byte 2 of DB100 as Char
`DB42,INT3`	`DB42.DBW3`	Number (16-bit)	Signed 16-bit number at byte 3 in DB42
`DB57,WORD4`	`DB57.DBW4`	Number (16-bit)	Unsigned 16-bit number at byte 4 in DB57
`DB13,DINT5`	`DB13.DBD5`	Number (32-bit)	Signed 32-bit number at byte 5 in DB13
`DB19,DWORD6`	`DB19.DBD6`	Number (32-bit)	Unsigned 32-bit number at byte 6 in DB19
`DB21,REAL7`	`DB21.DBD7`	Floating Point (32)	Floating point number at byte 7 in DB21
`DB2,S7.10*`	-	String	String (length 10) starting at byte 7 in DB2
`I1.0`	`I1.0`	Boolean	Bit 0 of byte 1 in input area
`Q2.1`	`Q2.1`	Boolean	Bit 1 of byte 2 in output area
`M3.2`	`M3.2`	Boolean	Bit 2 of byte 3 in memory area
`IB4`	`IB4`	Number (Byte)	Byte 4 (0-255) in input area
`QB5`	`QB5`	Number (Byte)	Byte 5 (0-255) in output area
`MB6`	`MB6`	Number (Byte)	Byte 6 (0-255) in memory area
`IC7`	`IB7`	String	Byte 7 of input area as Char
`QC8`	`QB8`	String	Byte 8 of output area as Char
`MC9`	`MB9`	String	Byte 9 of memory area as Char
`II10`	`IW10`	Number (16-bit)	Signed 16-bit number at byte 10 in input area
`QI12`	`QW12`	Number (16-bit)	Signed 16-bit number at byte 12 in output area
`MI14`	`MW14`	Number (16-bit)	Signed 16-bit number at byte 14 in memory area
`IW16`	`IW16`	Number (16-bit)	Unsigned 16-bit number at byte 16 in input area
`QW18`	`QW18`	Number (16-bit)	Unsigned 16-bit number at byte 18 in output area
`MW20`	`MW20`	Number (16-bit)	Unsigned 16-bit number at byte 20 in memory area
`IDI22`	`ID22`	Number (32-bit)	Signed 32-bit number at byte 22 in input area
`QDI24`	`QD24`	Number (32-bit)	Signed 32-bit number at byte 24 in output area
`MDI26`	`MD26`	Number (32-bit)	Signed 32-bit number at byte 26 in memory area
`ID28`	`ID28`	Number (32-bit)	Unsigned 32-bit number at byte 28 in input area
`QD30`	`QD30`	Number (32-bit)	Unsigned 32-bit number at byte 30 in output area
`MD32`	`MD32`	Number (32-bit)	Unsigned 32-bit number at byte 32 in memory area
`IR34`	`IR34`	Floating Point	Floating point number at byte 34 in input area
`QR36`	`QR36`	Floating Point	Floating point number at byte 36 in output area
`MR38`	`MR38`	Floating Point	Floating point number at byte 38 in memory area
`DB1,DT0`	-	Date	Timestamp in DATE_AND_TIME format
`DB1,DTZ10`	-	Date	Timestamp in DATE_AND_TIME format (UTC)
`DB2,DTL2`	-	Date	Timestamp in DTL format
`DB2,DTLZ12`	-	Date	Timestamp in DTL format (UTC)
`DB57,RWORD4`	`DB57.DBW4`	Number (16-bit)	Unsigned 16-bit number, Little-Endian at byte 4
`DB13,RDI5`	`DB13.DBD5`	Number (32-bit)	Signed 32-bit number, Little-Endian at byte 5
`MRW20`	`MW20`	Number (16-bit)	Unsigned 16-bit number, Little-Endian at byte 20

For example, consider that you have a ladder logic program in the TIA Portal with addresses like DB5.DBX0.0 and DB13.DBW4. You must adjust the address format slightly when you want to use these in the Node-RED S7 node. In Node-RED, DB5.DBX0.0 would be represented as DB5,X0.0 and DB13.DBW4 would be written as DB13,WORD4. Essentially, you look at the TIA Portal address, find the corresponding format in the Node-RED address column, and use that format in the S7 node configuration.

If you wanted integrate Siemens LOGO, please refer to the node's README, as the addressing differs.

Configuring the S7 Node to Connect to the PLC

Now that you have all the necessary knowledge and setup, let's start by establishing a connection between Node-RED and your Siemens S7 PLC. The S7 node in Node-RED simplifies the process, making it easy to configure communication. Follow the steps below to connect and start interacting with your PLC

Drag the S7 node onto the Node-RED canvas.
Double-click on the S7 node and click on the "+" icon to add a PLC configuration.
Select "Ethernet (ISO on TCP)" as the transport protocol, then enter your PLC's IP address. The default port (102) is used for S7 communication, so leave it unchanged.
Set the Mode to "Rack," then enter the Rack ID and Slot ID. These values can be found in the TIA Portal under the Device View tab on your configured device.

Image showing window from where you will get the Rack No and Slot No

Enter the Cycle Time (interval for communication with the PLC) and Timeout Duration (maximum time to wait for a response).
Once done, switch to the Variables tab and add all the variables with the correct address and name you want to read or write.

Adding Variables into s7 node

After adding the variables, click Add and then Done.
Deploy the flow by clicking the top-right Deploy button. Once deployed, the connection status will be displayed at the bottom of the node. If connected successfully, it will show a green squre with "online" status.

Configuring S7 node for connection

Writing Data to the PLC

Now that you’ve configured the connection, it’s time to use Node-RED to write data to the PLC to control light.

Drag the s7-out node onto the canvas.
Double-click on the node and select the variable to which you want to update or write a value.
Select the PLC configuration that we have added.
Click Done.

Configuring S7-out Node to write data to plc

The node is now ready to write data to the PLC. You can use standard Node-RED nodes like Inject, Change, or Function to create a workflow that sends the data. Ensure the data type matches the configuration set in the PLC program. For example, in my ladder logic, I need to modify the status of individual open contacts, each with its own address, such as DB1.DBX0.0, DB1.DBX0.1, and DB1.DBX0.2, to control the tower lights. Setting these contacts to TRUE will turn on the red, yellow, and green lights, respectively. You can send the data using the nodes I’ve mentioned, or you can build a custom dashboard with FlowFuse Dashboard for easier interaction.
Once your flow is set up and the s7-out node for each variable is configured, click Deploy in the top-right corner to activate the flow.

In the video above, the dashboard interface is built to control the stack light. At the end of this article, I will provide the complete flow for you to download.

If you're building a dashboard, keep in mind that while you can create it on Node-RED within the remote instance on FlowFuse Device Agent, you won’t be able to access it remotely across the editor tunnel. You can of course access it locally on the device or on the local LAN. For this demonstration, I wish to access the dashboard remotely across the internet and so I will create the dashboard in a hosted instance of Node-RED and use the FlowFuse Projects nodes to simply and securely pass the necessary values to and from the remote Node-RED instance. For more details on how to set this up, check out our article: Exploring FlowFuse Project Nodes.

Reading Data from the PLC

Now that we’ve covered how to write data to your Siemens S7 PLC, let's move on to reading data from it. Node-RED makes it easy to retrieve important information such as the status of inputs, outputs, or internal memory. By pulling this data into your workflows or visualizing it on a dashboard, you can monitor key parameters in real time and gain valuable insights.

However, before we dive in, it's important to consider that reading individual data points one by one in large-scale manufacturing systems can lead to delays. This approach may not be efficient, especially when dealing with a large number of data points. For more information on these challenges and potential solutions, you can refer to this article: Modernize Your Legacy Industrial Data - Part 2.

To address this issue, you can optimize data retrieval by storing output status values in a single word or double word within the PLC. For our example, I have created a custom function in my program that assigns the output values to individual bits of the word.

Custom ladder diagram function storing output statuses in a single word for optimized data retrieval.

There are several ways to implement this, and depending on your system’s needs, some methods may be more efficient than others. In this case, the output values are stored in a single word within the PLC, as shown in the ladder diagram above. This is not the only correct method—it's simply one approach that works for this particular scenario. Feel free to adapt or explore other methods that might better suit your setup.

Additionally, if the data you’re reading is mission-critical and you can't afford to lose any, consider using a FIFO stack or buffer in your PLC program. This method ensures that even if there is a network outage or computer problem, no data is lost as it will remain siting in the stack until your Node-RED is back on line and retrieves it. This ensures no gaps or interruptions in your data and guarantees data integrity.

Now, let’s begin reading the data from the PLC.

Drag the s7-in node onto the canvas.
Double-click on the node to open the configuration and select the appropriate PLC configuration from the list of available connections.
Choose the appropriate mode based on your requirements. If you want to read only one variable, select "Single Variable Mode". In this mode, the "Variable" dropdown will allow you to select only a single variable at a time. If you need to read multiple variables, you can select "All Variables" mode, but be aware that the node might still process each request sequentially, depending on its internal workings (which is not fully documented). This can be inefficient when dealing with hundreds of variables.
Choose the variable that corresponds to the word or double word containing all the data points you want to read. For example, if you’ve configured the word in the PLC as DB.DBW2, the format in the s7-in node will be DB,WORD2.
Enable the "Emit only when value changes (diff)" option to ensure that the node only triggers when the value of the variable changes, reducing unnecessary reads and improving efficiency.
Once your configuration is set, click "Done" and then deploy the flow to start reading data from the PLC.

Configuring S7-in Node to Read data from plc

You can add a "Debug" node to the s7-in node's output to verify that the data is being read correctly.

Once you see the printed data, you might be surprised, or perhaps you already expected this: since the word data type we're reading is not directly available in Node.js or Node-RED, we'll receive it as an integer. But don't worry—you can convert it into the format that suits your needs using node-red-contrib-buffer-parser. In this integer scenario, you'll need to shift the bits or extract individual values to match your desired output, such as isolating specific bits to represent different statuses or control points. The flow provided at the end demonstrates the implementation of this conversion.

Now that you have the desired format for your output data, you may want to build a dashboard interface with LEDs, gauges, or charts to monitor and visualize the data you've retrieved. You can use the FlowFuse Dashboard, as suggested earlier.

The video below shows the updated dashboard interface used to monitor the stack light LED status:

Here is the flow you can import into your FlowFuse remote instance and deploy. Ensure that you have installed node-red-contrib-s7 and node-red-contrib-buffer-parser. This flow includes S7 nodes for interacting with the S7 PLC and Project nodes for communicating with the FlowFuse hosted instance, where you will build the dashboard.

Below is the flow that you can import and deploy into the hosted instance created on FlowFuse. With this flow, you'll have a dashboard to control and monitor the tower lights. Just make sure you have installed @flowfuse/node-red-dashboard and @flowfuse/node-red-dashboard-2-ui-led, and ensure the hosted instance is in the same FlowFuse team as your remote instance.

Troubleshooting

When you try to establish a connection with the PLC, you may encounter the following error. This error occurs because your device has established the connection but is unable to communicate. To resolve this issue, ensure that you have configured all the settings mentioned in the prerequisites. If the problem persists, it could be because your PLC and the device running Node-RED are on different networks.

"Error: This service is not implemented on the modeul or frame error was reported"

Make sure the IP addresses of your device and PLC are in the same subnet. If the PLC is connected to the internet via a router, all devices (PLC, Node-RED device, and router) should have IP addresses within the same subnet. For example, if your PLC has the address 192.168.1.1, ensure that the other devices have IP addresses in the range 192.168.1.x.

Conclusion

Integrating Siemens S7 PLCs with Node-RED opens up powerful automation possibilities with minimal complexity. By following the steps outlined in this guide, you can easily connect your PLC to Node-RED, control devices, and visualize real-time data on dashboards. Whether you're writing data to control outputs or reading sensor values, Node-RED offers a flexible, user-friendly platform for industrial automation.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

Let’s Walk You Through It – Book a Demo Today

FlowFuse 2.13: Remote Instances, UNS Schemas & Improved Management at Scale

2025-01-16T00:00:00Z

Happy New Year everyone! We're back with another release of FlowFuse, and whilst it's been a shorter sprint for us this time round, with most of the team out for a well-earned break over Christmas and New Year, that hasn't stopped us packing in lot of great new value into FlowFuse nonetheless.

Hosted & Remote Instances

This release you'll notice that we've changed the terminology of two of our key concepts in FlowFuse:

Instances are now referred to as Hosted Instances
Devices are now referred to Remote Instances

We were finding that customers and prospects were getting confused over the term "Device", when in fact, it is a running Instance of Node-RED. You can have many Remote Instances running on the same piece of hardware, all using the FlowFuse Device Agent, and the term, "Device" made that misleading.

Remote Instances are just instances of Node-RED, deployed onto your own hardware and managed via FlowFuse and the FlowFuse Device Agent. We hope this change will make it clearer for everyone, and wanted to include this graphic which shows the updated terminology in the hierarchy of FlowFuse:

Diagram to show the hierarchy of different concepts in FlowFuse

Documenting Your UNS

Just under three months ago, we released our own MQTT Service, making it easy for your to configure MQTT clients through FlowFuse, and connect your hardware and applications. With the Unified Namespace (UNS) growing in popularity in Industry, we wanted to make sure that if you're using MQTT to run your UNS, then FlowFuse offers the best experience for managing it.

With this in mind, we're now generating a formal schema for your MQTT Broker's topic hierarchy automatically, and we've made it possible to access the underlying schema through the FlowFuse interface. The schema we generate is using the industry-standard, open-sourced, AsyncAPI.

If you're interested in learning more about UNS, then we recommend taking a look at some of the following resources:

Future Plans

This is very much a first iteration and we have work underway to improve it. Right now, the generated spec is pretty minimal - there is lots of scope to add more information and present it in a clearer and more interactive format. This will make it easy for your whole development team, and anyone else that needs to know, to get a clear picture of the topics and payloads that are being used in your MQTT Broker.

We're also looking at how this information can enhance the development experience within Node-RED itself.

Managing Groups of Instances

We've introduced a new view in FlowFuse which you can find in the "Operations" section of the side navigation. This new view is called "Groups" and it allows you to group your Remote Instances together, making it easier to manage and deploy to multiple instances at once.

This functionality has been in FlowFuse for a little while, but was buried down in the "Applications" view, and found users were missing it. We've now brought it to the forefront, and made it easier to use, and help you deploy out to thousands of Remote Instances with the single click of a button.

New Onboarding Tour

We have a new onboarding tour that will be shown to those users signing up to our new Free Tier on FlowFuse Cloud.

This tour is purpose built to help you get up and running with your first Remote Instance in FlowFuse, setting up the Device Agent on your own hardware, and accessing your Remote Instance via FlowFuse Cloud.

In Case You Missed It...

Last month we released a new Free Tier on FlowFuse Cloud, but announced it in the same article as our latest release and so a lot of the other new features we'd added to FlowFuse were lost in the weeds a little. We had a few self-hosted customers mention that they missed the updates for 2.12, so we also wanted to re-highlight some new features from that release too:

Pipelines - New view at the team-level to manage your DevOps Pipelines, making it easier to deploy between development, test and production environments. Pipelines can also be used to push updates out to thousands of Remote Instances at once using the new "Groups" feature.
Bill of Materials - New view at the team-level to get a clear picture of all dependencies that your Instances are using. Makes it easier to manage out-of-date packages, and help with auditing and compliance.
Device Agent Performance Improvements - For those running Node-RED 4.0.x and higher, the Device Agent has had some significant updates to performance, making the experience of remote editing much faster and smoother, especially when the device is on a slow network link.
Dashboards in iFrames - FlowFuse-hosted Dashboards can now be configured to run inside iFrames. You can find this option under the "Settings" of the Instance in question.

What Else Is New?

For a full list of everything that went into our 2.13 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try FlowFuse

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is on our own hosted instance, FlowFuse Cloud.

Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

MQTT: The Frontrunner for Your UNS Broker - Part 2

2025-01-13T00:00:00Z

In Part 1, we discussed the reasons behind MQTT's popularity as a choice for Unified Namespace (UNS) implementations; focusing on its lightweight design, low latency, and reliable message delivery. In this second part, we’ll explore additional factors that further establish MQTT as the leading protocol for UNS brokers, diving into its connectivity, scalability, structured topic management.

Wide Connectivity

For your UNS to be truly effective, it must be able to connect seamlessly with every part of your IIoT environment—whether it’s a device or the cloud. MQTT is an excellent protocol for this because it’s widely adopted in both cloud-based systems and industrial environments.

In a typical industrial data architecture, you typically have a mix of physical devices (like sensors and machines) and cloud systems. To make real-time decisions, data needs to flow seamlessly from the shop floor to the cloud. MQTT excels at connecting modern devices with the cloud. However, one challenge is that it doesn’t natively support older systems that typically use protocols like OPC UA or MODBUS.

This isn’t a major issue, though. You can bridge the gap using tools like FlowFuse and Node-RED, which allow MQTT to communicate with older systems.

Overall, MQTT has better compatibility than many other protocols. Some other protocols may offer better compatibility, but they can hardly surpass MQTT in meeting the core requirements of a UNS.

MQTT's Compatibility

Easily Scalable

A UNS broker needs to be able to grow as your factory or system expands. What starts with just a few sensors or devices might quickly scale up to hundreds or thousands over time. Can MQTT handle this growth? Absolutely.

MQTT's lightweight architecture, based on a simple publish-subscribe model, makes it easy to scale. Adding new devices doesn’t disrupt existing operations. The system can handle thousands of devices and connections without performance issues. As your network grows, new devices can easily connect to the broker and start exchanging data without major changes to the infrastructure.

MQTT brokers handle large volumes of data and can distribute messages to many clients at once. This ensures that as more devices are added, the system remains stable. The broker can also scale horizontally, meaning you can add more brokers or resources to handle the increased load, without affecting the performance or reliability of the system.

Semantic Hierarchy with Topics

When setting up a UNS, it’s not just about collecting all your data in one place—it’s about organizing it so that it’s easy to navigate. A semantic hierarchy helps do this by arranging data from broad categories down to more specific details. For example, in a factory, you might have levels like factory, area, line, and machine, with data points like temperature or humidity at the bottom. This is similar to how files are organized in folders, making it simple to find what you need.

MQTT works well for this kind of organization because its topics are already structured in a hierarchical way. Topics in MQTT are like paths that break down data into different levels, such as factory/area-2/line-1/machine-5/temperature. You can easily follow these paths to find the exact data you need. Furthermore, MQTT supports wildcard characters, which offer flexibility for subscriptions. The # wildcard matches all levels beneath a given level, so a subscription to factory/# will match any topic under the "factory" level, regardless of how deep the path goes. Similarly, the + wildcard matches only a single level, so factory/+/line-1/machine-5/temperature will match any topic that follows the same structure but with different areas.

While AMQP and Kafka also support topics and wildcards, they handle them differently. AMQP uses routing keys for message routing rather than a direct hierarchical topic structure like MQTT. Though AMQP has a topic exchange for routing based on patterns (similar to topics), it doesn’t provide the same natural hierarchical organization. Kafka, on the other hand, uses a flat topic model without a hierarchy, which can make it more difficult to maintain clarity and structure as the system grows in complexity. While both AMQP and Kafka can still be used in a UNS, their lack of a natural topic hierarchy makes them more challenging manage compared to MQTT, which provides a simpler, more intuitive way to organize and access data.

In conclusion, MQTT is an excellent choice for your UNS broker because it offers simplicity, scalability, and efficient data organization. Its lightweight design ensures smooth performance as your system grows, while the publish-subscribe model decouples producers and consumers, allowing them to operate independently. This reduces direct dependencies between devices and systems, making the overall architecture more flexible and easier to scale. MQTT’s hierarchical topic structure further simplifies data management and access. Compared to other options like AMQP and Kafka, MQTT provides a more intuitive, reliable, and scalable and most importantly simple solution for building a Unified Namespace that can adapt to future needs.

Build Your UNS with FlowFuse Now

Now that you understand why MQTT is the best choice for your UNS, it’s time to build it. FlowFuse is the ideal platform for implementing your UNS with MQTT.

Please read our article: Building Your UNS with FlowFuse where I show you how to build it quickly—just in 15 minutes!

Why choose FlowFuse?

FlowFuse is an industrial data platform that leverages the power of Node-RED, a popular open-source low-code platform for industrial automation. With over 5000 community-contributed nodes, it simplifies the process of collecting, transforming, and integrating data from a wide variety of industrial hardware and services, supporting nearly all industrial protocols. This means you have nearly everything you need to implement a UNS—all you need is the MQTT broker service.

Good news! Recently, FlowFuse has added a built-in MQTT broker service within the platform, making it even easier to manage your MQTT connections. This includes an interface for securely managing MQTT clients and, most importantly, a comprehensive topic hierarchy monitoring tool that’s ideal for managing your UNS.

FlowFuse not only allows you to build and manage your UNS, but also provides a collaborative environment where teams can work in real time. It offers scalability, security, and ease of use, making it simple to grow your system as your needs evolve.

With FlowFuse, you get everything you need to handle data pipelines, implement a UNS, and scale efficiently—all within a single platform.

Want to learn more about how FlowFuse can help?

Let’s Walk You Through It – Book a Demo Today

MQTT: The Frontrunner for Your UNS Broker - Part 1

2025-01-07T00:00:00Z

Choosing the right broker for your UNS is crucial. It must support real-time data, scale easily, and integrate seamlessly with devices and services. MQTT often comes out as the best choice for these needs.

In this first part of our series, we’ll explain why MQTT is the standout choice for UNS implementations. With its focus on lightweight, real-time messaging and robust reliability, MQTT delivers the performance IIoT environments demand, making it the perfect fit for a future-proof, scalable UNS.

The Unified Namespace (UNS) is a data architecture (not just a tool or new technology) that centralizes and organizes data from various sources into a single, unified structure. It eliminates data silos by providing a standardized way to represent, access, and share information across different devices, systems, and services. For more information on what is UNS, read our article: Introduction to the Unified Namespace.

When choosing a broker for your UNS, it's crucial to consider how well the selected broker fits the specific requirements of your IIoT environment, including the types of devices and systems involved, as well as factors like scalability, reliability, and ease of integration. Several options are available alongside MQTT, including AMQP, Kafka, and cloud message brokers like AWS Kinesis and GCP Pub/Sub. While these alternatives offer unique features, MQTT stands out, and we’ll explain why later in this article. But If you’re interested in a brief overview of why these alternatives are not the best fit for UNS, check out our article: Unified Namespace: What Broker to Use?

There is also an ongoing debate regarding the use of OPC-UA and other protocols for implementing UNS. While I won’t dive into this in detail here as i havent explored it much yet, I encourage you to start with the approach we call reverse engineering. First, understand why MQTT is the preferred choice for implementing UNS, and then explore how its features align with UNS needs. From there, you can evaluate whether other protocols offer similar capabilities. By following this process, you will find the right answer of your questions.

Background of MQTT

Before diving into its specific advantages for UNS, let’s take a brief look at the history of MQTT and how it became the backbone of modern IoT communication.

MQTT was developed in the late 1990s by Andy Stanford-Clark at IBM and Arlen Nipper at Eurotech to address communication challenges in low-bandwidth, unreliable networks. This early focus on lightweight messaging paved the way for MQTT to become a pioneering solution for the rapidly expanding IoT space.

Since then, MQTT has evolved significantly. The protocol has gone through several iterations, from MQTT 3.1.1 to the more feature-rich MQTT 5.0, each version enhancing the protocol's capabilities to meet the demands of an increasingly connected world. Today, more than 25 years later, MQTT remains the de facto protocol for IoT applications, and its simplicity, scalability, and reliability continue to make it an ideal choice for industrial systems.

But, what exactly makes MQTT the frontrunner for UNS implementations? Let's take a deeper look at some of its key features?

One of the standout features of MQTT is its publish-subscribe (Pub/Sub) model, which is the primary need of an UNS. In this model, data producers (such as sensors or devices) don’t need to know who is receiving the data or how many consumers are out there. Instead, they publish their data to a central broker, and any consumer (like a monitoring system, data warehouse, or analytics engine) that is interested simply subscribes to the relevant data stream.

This approach decouples producers and consumers, removing the need for direct, point-to-point connections between them. In traditional systems, every device would need to know about every other device it communicates with, leading to a messy, tightly coupled network. As your IIoT ecosystem grows, managing these connections becomes increasingly difficult and prone to error. But with MQTT’s Pub/Sub model, adding new devices or services is seamless and doesn’t disrupt existing data flows.

Beyond this, MQTT’s event-driven architecture takes the system to a whole new level of efficiency and responsiveness. Imagine a scenario where a machine detects an issue—rather than waiting for a periodic check-in, the event is immediately sent to the right consumer, triggering an alert in real time. This push mechanism is far more efficient than traditional polling, where systems continuously ask, “Is there new data yet?” and waste precious resources in the process.

With MQTT, data is pushed as soon as it’s available, enabling faster decision-making and real-time responses. This means events like machine faults or environmental changes are addressed immediately, making the Our UNS more agile, responsive, and capable of scaling as needed which is one of priamary need of IIoT environemnt.

If you’d like to understand the importance of Publish-Subscribe (Pub/Sub) architecture in detail for UNS, I highly recommend reading our article: Why UNS Needs Pub/Sub.

Low Latency and Lightweight Messaging

Downtime in industrial operations can be very costly—ranging from $15,000 to $20,000 per minute or more. For engineers and operators watching over machines, waiting for data can mean the difference between smooth operations and expensive disruptions, If you're interested in learning more about downtime, read this research by Siemens from 2022: True Cost of Downtime 2022. Low-latency messaging is key in these situations, which is why data architectures like UNS are being explored to make sure systems and devices in your IIoT setup communicate without delays. MQTT is the protocol that makes this possible.

As we explored, MQTT uses a publish-subscribe model, which is built for real-time communication with minimal delay. Unlike traditional request-response systems that can cause delays due to constant querying, MQTT keeps a persistent connection open. Once a device connects, it can immediately send data or receive updates on important topics, cutting out the need for repeated requests and making sure data flows instantly. This helps engineers make decisions and take action faster.

In addition to being fast, MQTT is very efficient. Its messages are small and use little bandwidth—important when working with low-bandwidth networks or many connected devices. Even with limited resources, MQTT allows devices to send data without overwhelming the system. The result? As soon as a sensor detects a change—like a temperature spike or a production issue—it can send the information right away to the right system, triggering immediate actions to avoid costly downtime.

MQTT Packet Structer

Reliability

When it comes to building a UNS, reliability is absolutely crucial. Missing or duplicate data can lead to poor decision-making, system malfunctions, or even costly downtime—things no one wants in their IIoT environment.

This is where MQTT truly shines. It’s built with a Quality of Service (QoS) mechanism that allows you to control how reliably your messages are delivered. Depending on the level you choose, you can ensure that data is delivered exactly as you need it, without compromising on system performance.

MQTT offers three levels of QoS to suit different use cases:

QoS 0 - "At most once": The message is delivered once and isn’t acknowledged. This is fine for non-critical data where the occasional loss of a message is acceptable.
QoS 1 - "At least once": The message is delivered at least once, with an acknowledgment to ensure it was received. This is ideal for most IIoT applications, where you need reliable delivery, but duplicate messages are not a major concern.
QoS 2 - "Exactly once": This guarantees the message is delivered exactly once—no duplicates, no omissions. It's the best choice for mission-critical applications where data integrity is paramount.

Now, some other protocols like AMQP or Kafka also provide reliability guarantees, but they tend to be more complex and come with heavier infrastructure requirements. MQTT, on the other hand, offers a simple and lightweight design while still giving you just the right level of reliability for most IIoT scenarios. You can scale your network with ease, all while maintaining a high standard of reliability in your data flows.

MQTT is the ideal broker for a UNS in IIoT environments, offering real-time, low-latency communication through its Publish-Subscribe model. With Quality of Service (QoS) options for reliable data delivery, it balances performance, scalability, and simplicity. MQTT’s lightweight design makes it perfect for handling large-scale, mission-critical data flows without the complexity of heavier protocols.

In Part 2, we will explore MQTT's scalability, topic organization, and wide connectivity providing even more compelling reasons why it is the ultimate choice for UNS brokers.

If you're looking to build your own UNS with MQTT, check out our step-by-step Article on Building UNS with FlowFuse. Plus, we've made it even easier by offering a built-in MQTT broker service within the FlowFuse Platform, allowing you to manage all your MQTT clients, devices, services, and data from a single, centralized interface. Check it out here!

FlowFuse Cloud now available for free!

2024-12-19T00:00:00Z

The new Free plan on FlowFuse Cloud will allow you to manage two remote instances using FlowFuse Device Agent, completely free of charge, forever! The new plan also provides Device Auto Snapshots, so any changes to your Node-RED flows running on your devices are backed up automatically.

FlowFuse is an industrial data platform that enables engineers to build, manage, scale, and secure their Node-RED solutions for digitalizing processes and operations. More fundamentally though, it's a great platform to manage multiple instances of Node-RED.

What's Included?

Whether you're running multiple Node-RED instances at home for Home Automation, or running thousands of Node-RED instances in your factory, FlowFuse provides an easy-to-use, centralised view of your Node-RED instances, making it easy to manage and monitor them in one place.

In our new free tier on FlowFuse Cloud you get:

2 x Remote Node-RED Instances, managed through the FlowFuse Device Agent
Version control for your Node-RED flows with FlowFuse's Snapshots
Remote access to your Node-RED instances through FlowFuse Cloud, utilizing the Device Agent's Developer Mode

Getting Started

Create Your Free Team

To create a free team, simply sign up to FlowFuse Cloud.

Once you've filled in your details, you'll be presented with the option to choose your team type. Select the "Free" option, and you're good to go.

Screenshot showing the UI for selecting your Team's type, when onboarding through on FlowFuse Cloud.

Remote Instances

When you create a Free team, an Application is created for you automatically. Applications in FlowFuse help you organise and group your resources, from Instances to DevOps Pipelines and Snapshots for Version Control. Within your new application, you can "register" your first Remote Instance.

A "Remote Instance" in FlowFuse is a just a term for an instance Node-RED, managed by FlowFuse, but running somewhere different from FlowFuse, e.g. on Edge hardware in a factory or your home. FlowFuse connects to these Remote Instances using the FlowFuse Device Agent, which is easy to setup and get running.

To get started with your Remote Instance, you need to complete two steps:

Install Device Agent: The FlowFuse Device Agent is installed onto the hardware where you want your Node-RED Instance to run.
Add Your Remote Instance: In the FlowFuse UI, add a new "Remote Instance", and connect to your hardware.

Install Device Agent

Firstly, wherever you want your Node-RED to run, e.g. on a Raspberry Pi or your own Laptop, install the flowfuse-device-agent package:

Linux/MacOS

sudo npm install -g @flowfuse/device-agent

Windows

Issue the below command in an elevated command prompt:

npm install -g @flowfuse/device-agent

For alternative installation options and more details, please refer to our documentation.

Connect Your Hardware to FlowFuse

To connect your Device Agent, in the FlowFuse Platform, click on the "Remote Instances" option in the left-hand menu, and then click the "Add Remote Instance" button.

Fill out the name, device type and select the application you've just created, and you'll be presented with the following:

Screenshot showing the dialog with the one-time-code to connect your remote Node_RED instance to FlowFuse

The command presented is used to connect your device to FlowFuse. Run this where you just installed the @flowfuse/device-agent package. This will connect your remote Node-RED instance to the FlowFuse platform.

The final step to take is to then start running the device agent, which you can do by simply calling:

flowfuse-device-agent

Developing on your Remote Instance

FlowFuse offers remote development capabilities, allowing you to edit your Node-RED flows directly, and securely, from the FlowFuse Cloud platform. This is done through "Developer Mode".

To get started with developing flows with your Remote Instance, simply select your newly created Instance in the FlowFuse UI, toggle on 'Developer Mode", and click "Open Editor"!

Version Control with Snapshots

FlowFuse makes version control easy with Snapshots. The new Free plan includes Device Auto Snapshots, which will automatically create a snapshot any time a flow is deployed to your device.

What Else is New?

In addition to the Free plan, we've also added two new views to the FlowFuse platform:

Pipelines: This view provides a way to manage all of your DevOps Pipelines, making it even easier to manage your development, testing, staging and production environments.
Bill of Materials: This view provides a way to manage all of your Node-RED dependencies, making it easy to see what versions of nodes are being used across all of your Node-RED instances.

For a full list of everything that went into our 2.12 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try FlowFuse

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is on our own hosted instance, FlowFuse Cloud.

Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

Data Modeling: The Key to a Successful Unified Namespace

2024-12-16T00:00:00Z

In manufacturing, data flows from various sources—machines, sensors, enterprise systems, and more. A Unified Namespace (UNS) brings all this data into a central hub. However, centralizing data isn't enough to truly call it a UNS. It's not just about aggregating information. A true UNS goes beyond being a data repository; it organizes, structures, and contextualizes that data, transforming it into something valuable and actionable for your business.

By applying a solid data model, you can turn scattered, unstructured data into a cohesive, meaningful system that supports better decision-making and drives operational improvements. Let's explore what data modeling is, why it is crucial for making your UNS function effectively, and how it turns scattered data into valuable insights.

At its core, data modeling is designing how data will be structured, organized, and stored within the UNS. It’s about creating a blueprint or framework that defines the relationships between different data points, ensuring they’re logically structured, easily accessible, and aligned with the business's needs.

A solid data model forms the foundation for understanding and using data effectively. It addresses essential questions like:

How should data be represented? – What formats, units, or categories should be used to express the data?
When is it captured, and what does it represent? – Is it sensor data, performance metrics, or supply chain information? When was it recorded, and what is its context?

The data model can vary significantly from business to business, depending on the use case. For example, in manufacturing, if a device is sending sensor metrics to a UNS, the data could look like this:

{
  "timestamp": "2024-09-19T12:33:46.6035772+02:00",
  "machineId": "press_001",
  "manufacturer": "XYZ Corp",
  "model": "MPX-5000",
  "sensors": [
    {
      "name": "vibration",
      "value": 1.5,
      "unit": "mm/s"
    },
    {
      "name": "temperature",
      "value": 72.4,
      "unit": "Celsius"
    },
    {
      "name": "pressure",
      "value": 3.8,
      "unit": "Bar"
    }
  ]
}

Alternatively, a simpler model might look like this:

{
  "timestamp": "2024-09-19T12:33:46+02:00",
  "machine": "press_001",
  "vibration": { "value": 1.5, "unit": "mm/s" },
  "temperature": { "value": 72.4, "unit": "Celsius" },
  "pressure": { "value": 3.8, "unit": "Bar" }
}

In both examples, the data is structured with critical elements like timestamps, machine identifiers, sensor readings, and units of measurement. The crucial difference between the two models lies in the level of detail, but both demonstrate how a well-defined data modeling adds immediate value. Organizing data clearly and consistently ensures its accuracy and enables it to be easily analyzed, integrated, and acted upon.

Now that you have a basic understanding of what data modeling is Let’s take a deep dive into why data modeling is essential to unlocking the full potential of your UNS:

1. Ensures Data Consistency and Standardization

As mentioned earlier, data is generated from various sources in manufacturing, including machines, sensors, ERP systems, and inventory management tools. Each source may provide data in different formats, units of measurement, or naming conventions.

For example, one machine might report temperature in Celsius, while another uses Fahrenheit. Some systems might track production rates in pieces per hour, while others use units per minute. These inconsistencies can create confusion and lead to errors in a computerized structure.

Data modeling addresses this issue by establishing clear standards for how data should be structured and labeled. It ensures uniform temperature, unit, and measurement formats across all systems. For example, a data model might require recording all temperature readings in Celsius and production rates in pieces per hour. This consistency simplifies data analysis from diverse sources and ensures that the system functions reliably and accurately.

2. Gives Data Meaning

Raw data on its own is just numbers—isolated and incomplete. For example, a temperature reading of 72.4°C or a vibration level of 1.5 mm/s doesn’t tell much without the proper context. This is where data modeling truly adds value. A data model turns simple measurements into meaningful insights by organizing data that includes critical details like timestamps, data sources, and relationships between data points.

Contextualizing data means understanding when it was captured, where it came from, and what it’s related to. A timestamp helps track trends over time, such as detecting a gradual temperature rise that could signal an issue before it becomes critical. Knowing the data source—whether it’s a specific machine or sensor—enables targeted troubleshooting and ensures that the right teams are working with the right data. Data modeling also links data points, like correlating vibration and temperature readings, to identify potential equipment failures. This structure makes data far more accessible and actionable, allowing teams to make informed, real-time decisions, prevent unplanned downtime, and drive process improvements.

In summary, data modeling transforms raw data into actionable insights, helping you understand what is happening in your operation, when it started, where it is occurring, and how to address it effectively.

3. Facilitates Data Interoperability and Integration

In manufacturing, various devices and systems generate data in different formats and use distinct communication protocols, making integrating and utilizing this data effectively challenging.

For example, PLCs may use one protocol, while SCADA systems or MES may rely on entirely different ones. This lack of consistency complicates consolidating data and extracting meaningful insights. Integrating other systems often requires addressing discrepancies in how data is structured and labeled. For instance, multiple sensors on a production line might send data in various formats or label the same metric differently. One sensor might label temperature as "temp," another as "temperature," and yet another as "T1." These inconsistencies can lead to errors or failures in integrated systems, such as monitoring tools that depend on consistent data labeling to function correctly.

This is where data modeling becomes essential. It creates a standard structure for organizing and labeling data, ensuring that different systems can "speak the same language" and integrate seamlessly.

For example, in a predictive maintenance system, sensor data such as temperature and vibration can be used to predict potential machine failures. With the right data model, this sensor data can be directly linked to your CMMS (Computerized Maintenance Management System), regardless of how many sensors are involved or added over time. Since engineers understand the standardized data structure, they can easily integrate the CMMS with minimal effort. This integration automatically triggers maintenance alerts and work orders, helping to prevent downtime without requiring manual intervention.

4. Enables Easy Access and Time Savings

Disorganized data wastes time and resources in manufacturing. A transparent data model makes essential information easy for troubleshooting, performance checks, and decision-making tasks.

With a standardized system, figuring out confusing labels or complex data is unnecessary. A consistent data model organizes information, helping operators respond faster, reduce downtime, and minimize errors.

Quick access to accurate data speeds up decision-making, cuts downtime, and improves efficiency, leading to cost savings.

5. Scalability and Continuous Improvement

A well-structured data model serves the needs of your current manufacturing operations and lays the groundwork for future growth and continuous improvement. As your production processes evolve or new technologies and data sources come online, a good data model allows your UNS to adapt without disrupting existing systems.

For example, as you add new machines, automated production lines, or advanced sensors to your operations, the data model ensures that these new elements integrate smoothly into the existing framework. It maintains consistency, enabling new data points to be mapped easily while keeping the system organized and efficient.

With all these benefits in mind, the next step is to consider how to implement data modeling effectively. Data modeling is a much deeper, more dynamic process that can reshape how you use data across your entire business. It's not only about structuring and integrating data but also about transforming your operations, unlocking new efficiencies, and driving growth. The right platform can help you go beyond essential organization and truly harness the power of your data.

Leverage FlowFuse for Effective Data Modeling in Your UNS

FlowFuse makes building and managing a Unified Namespace (UNS) simple and efficient. It connects IT and OT systems, streamlines workflows, and transforms raw data into meaningful insights. With FlowFuse, you can:

Connect: Integrate various services, hardware, and APIs effortlessly.
Collect: Aggregate data from machines, sensors, and other sources.
Transform: Easily standardize and add context to raw data, making it more meaningful and usable across your systems.
Visualize: Create dashboards with a low-code approach to monitor and analyze your operations.

Learn how to build your UNS in just 15 minutes with this article.

FlowFuse uses Node-RED, an open-source low-code platform, to turn unstructured data into organized, actionable models. Its ability to transform and contextualize data ensures consistency and clarity, helping you get the most value from your data.

With support for over 5,000 community nodes and protocols like MQTT, OPC-UA, and Modbus, FlowFuse simplifies connecting systems and unifying data.

Check out this article to see how FlowFuse makes data modeling easier.

FlowFuse also offers enterprise-grade features to manage edge devices and Node-RED instances, helping you scale, collaborate, and stay compliant.

Take Control of Your Data with FlowFuse

Want to make the most of your data? Our team is ready to help you set up a Unified Namespace (UNS) that fits your needs.

Let’s Walk You Through It – Book a Demo Today

Streamlining Node-RED Collaboration with FlowFuse

2024-12-09T00:00:00Z

A few weeks ago, we discussed how FlowFuse centralizes edge device and Node-RED management, as well as its security features. Now, we're focusing on another key benefit of FlowFuse—making collaboration easier for teams in industrial environments.

As more manufacturing companies use FlowFuse for edge device management, data pipelines, and bridging IT-OT systems, the platform is becoming a key tool for handling complex data operations. Collaboration is critical in manufacturing environments with thousands of devices and data flows. FlowFuse accelerates industrial data operations by simplifying real-time collaboration while ensuring security and scalability.

Now, let’s look at how FlowFuse makes collaboration effortless. With features like centralized management, real-time updates, and easy sharing, FlowFuse helps teams stay on the same page—whether working on the same flow or across multiple projects. The platform eliminates the usual pain points of collaboration, allowing teams to quickly deploy, modify, and scale Node-RED solutions confidently while maintaining control and security.

Laying the Foundation for Better Collaboration with Centralization

Effective collaboration starts with everyone having access to the same interface and information. When team members work with different versions of flows or data, things can easily get out of sync, making collaboration difficult.

This is exactly why centralized management is so crucial. With FlowFuse, everything—your Node-RED Instances, edge devices, settings, and data—is in one place. Everyone on your team sees the same interface, accesses the same up-to-date information, and works from the same set of resources. There’s no more hunting for the correct version or trying to sync up tools.

Everything in one place means fewer mistakes, fewer mix-ups, and much easier collaboration. Whether you're working in a single instance or managing a whole network of edge devices, FlowFuse makes it easy to stay aligned. You can move quickly and confidently without worrying about missing something important.

A centralized view of applications with Node-RED instances organized under each application for easier management.

A list of all Node-RED instances is displayed centrally, allowing team members to manage and access them easily.

A centralized view of edge devices, providing streamlined management for all devices within the platform.

In short, centralization makes everything simpler. It’s the backbone of effective teamwork, ensuring everyone works from the same starting point. With FlowFuse, you don't have to worry about syncing — everything's already in sync for you.

If you want to dive deeper into how FlowFuse centralizes things, check out this article: Managing Node-RED Instances in a Centralized Platform.

Creating and Managing Teams

Collaboration begins with the right team setup. In FlowFuse, you can quickly create a team and assign it a name. Once your team is set up, you can easily invite members to join. As mentioned earlier, all your Node-RED instances, edge devices, configurations, settings, and data are organized and centralized within that team.

However, simply creating a team and inviting members isn’t enough. Not all team members need access to all information, features, or controls. It’s essential to ensure that the right people have the right level of access to do their work effectively. Providing excessive access to members who don’t require it or who might lack the necessary expertise can lead to accidental changes or mistakes.

A centralized view of edge devices, providing streamlined management for all devices within the platform.

A comprehensive list of team members with assigned roles and permissions

This is where FlowFuse’s Role-Based Access Control (RBAC) comes in. When inviting new team members, you can assign them specific roles, each with different permissions and access scopes. This ensures that each team member has the appropriate level of access based on their role, reducing the risk of unintended changes or disruptions.

You can later update roles to adjust permissions as your team, and projects evolve if needed. FlowFuse’s RBAC helps maintain control and security while empowering each team member to contribute effectively to the project.

Real-Time Collaboration and Monitoring

Once team members have been invited, Node-RED instances have been created, and edge devices have been added by the team owner, FlowFuse's real-time collaboration capabilities come into play. Team members, whether they have owner or member roles, can work on the same project simultaneously. They can update flows, deploy them, and monitor real-time progress.

With FlowFuse, tracking who is working on which project and at what stage is easy. The platform lets you see who has opened the Node-RED editor you are working on, which flow they are working on, and even which specific node they are interacting with. This visibility ensures that team members are always aligned and that collaboration happens seamlessly without stepping on each other’s toes.

Multiple users collaborate on the same Node-RED flow in real-time within FlowFuse.

For instance, if two members modify different parts of the same flow, they can do so without interrupting each other’s work. They’ll both be able to see each other's updates in real-time, ensuring the project moves forward smoothly. This collaborative approach enhances teamwork and helps avoid mistakes, as everyone has the information they need when needed.

In addition, FlowFuse’s real-time monitoring features allow you to track the status of edge devices, Node-RED instances, and overall system health. You can also monitor Node-RED logs for troubleshooting, ensuring no issue slips through the cracks as your team works together efficiently.

Version Controlling

In any collaborative environment, accidental changes or conflicts are inevitable, especially when multiple team members are working on the same project. While collaboration is essential for progress, the ability to track changes, roll back versions, and understand who made what updates is critical for maintaining control and continuity.

FlowFuse provides robust version control features that make it easier to manage changes across your Node-RED flows. Whether you revert to a previous version of a flow, roll back accidental changes, or track updates over time, FlowFuse ensures that you never lose critical work.

To view the version history, navigate to your Node-RED Instance view and switch to the 'Version History' tab. Here, you’ll find two key sections:

Timeline: This section displays a timeline of who deployed, what is updated, and for which flow and when. Each deployment automatically creates a snapshot of your Node-RED instance. You can easily roll back to any previous version by clicking the three-dot icon on the right and selecting Restore Snapshot. You also have the option to compare the current version of your Node-RED instance with previous snapshots, download it, and more.

A version history timeline shows deployment and changes made in flows, making it easy to track updates and revert to previous versions.

Snapshots: The second tab, Snapshots, provides a clean, list-style interface that shows all available snapshots. Unlike the timeline view, this section focuses solely on snapshots without the detailed deployment history. You can upload or download snapshots and even create a snapshot of your instance at any time by clicking the Create Snapshot button.

The snapshots list interface in FlowFuse provides an organized view of all available snapshots for easy restoration or comparison.

This version control functionality allows you to manage and recover Node-RED instances seamlessly, ensuring that your team can collaborate effectively without the risk of losing or overwriting important work.

Shared Flow Library

When working on projects, it's common to develop reusable flows that can save time and effort for the entire team. For example, you might create a flow to calculate Overall Equipment Efficiency (OEE) or other valuable flows that can be reused across multiple projects.

FlowFuse makes this process easy with the Shared Flow Library. This feature allows owners and members to export significant flows and store them in a shared library, making them available to all team members. Once a flow is added to the library, anyone within the same team can import and use it in any Node-RED instance whenever needed.

Shared Flow Library in FlowFuse displays a list of reusable flows that team members can import and use across multiple Node-RED instances.

This shared approach streamlines development, eliminates redundant work, and ensures project consistency, ultimately saving time. Whether it’s a reusable function, a typical configuration, or a flow for recurring tasks, FlowFuse’s Shared Flow Library enables your team to easily access and integrate these resources, boosting productivity and fostering better collaboration.

Audit Logs

Accountability is essential when multiple team members collaborate on complex industrial projects. FlowFuse offers comprehensive Audit Logs to track every action taken within the platform. This feature provides a detailed record of who made which changes, when those changes were made, and the specifics of each action.

Audit logs in FlowFuse, tracking every action taken within the platform to ensure accountability and transparency among team members.

With Audit Logs, you can easily trace who deployed a flow, modified settings, or interacted with assets. This transparency ensures that all team members are accountable for their actions, enhancing security and reducing the risk of errors or unauthorized changes.

Audit Logs are especially valuable for troubleshooting. They allow you to pinpoint when issues arise and identify who made changes that could have contributed to the problem, providing crucial context for resolution.

For more information on using Audit Logs effectively, refer to our documentation on Audit Logs in FlowFuse.

These are just a few of the features we’ve covered. FlowFuse has many more tools and capabilities that can further enhance collaboration, streamline workflows, and optimize your industrial operations.

In summary, FlowFuse is a platform that streamlines collaboration on Node-RED projects. Centralizing your Node-RED instances, devices, and data ensures that everyone on your team is aligned and has access to the same resources. Features like real-time updates, role-based access, version control, and audit logs make collaborating easier, staying secure, and avoiding errors easier. Whether you're managing small flows or large-scale industrial systems, FlowFuse helps your team work together more efficiently and effectively.

With FlowFuse, factories can achieve faster, safer, and more scalable collaboration on data pipelines, edge device management, and IT-OT integration.

Ready to Improve Your Manufacturing Team’s Collaboration?

Want to learn more about how FlowFuse can enhance your industrial data operations and improve team collaboration?

Let’s Walk You Through It – Book a Demo Today

Up Next

Explore more resources and deepen your understanding of FlowFuse with these articles:

Managing Node-RED Instances in a Centralized Platform
Learn how to effectively manage Node-RED instances in a centralized environment with FlowFuse, simplifying deployment and ensuring scalability.
Exploring FlowFuse Security Features
Discover the security tools and features built into FlowFuse to help protect your industrial data and keep your systems secure.
Building on FlowFuse: Working with Devices
Dive into how FlowFuse supports device management, enabling you to build, deploy, and monitor edge devices more efficiently.

Publishing Modbus data to your UNS with FlowFuse

2024-12-04T00:00:00Z

As industries evolve towards Industry 4.0, integrating legacy systems like Modbus with modern cloud technologies becomes essential. While effective for local machine-to-machine communication, Modbus doesn't naturally connect with cloud platforms.

This article shows you how to bridge Modbus data to MQTT using FlowFuse and Node-RED. By publishing this data into a Unified Namespace (UNS), you can seamlessly integrate legacy systems with cloud services for real-time monitoring and analysis, unlocking the full potential of your industrial data.

If you haven’t built a Unified Namespace yet, please read our article on building a UNS with FlowFuse and create your own in just 15 minutes.

The Importance of Bridging Modbus Data to MQTT for Cloud Integration and UNS

Modbus has been a go-to protocol in industrial environments for a long time, providing reliable communication between devices like PLCs, sensors, and motors. It’s been essential for operational technology (OT) for decades. But as industries move towards Industry 4.0, there’s a growing need to connect older OT systems like Modbus with modern IT platforms, such as cloud systems and IoT applications. This is where the OT/IT gap becomes a challenge.

While Modbus does a great job at local control and data collection, it has some limitations when it comes to cloud integration and real-time IoT solutions. Without a centralized approach, data often remains locked in silos—isolated within different systems and devices. That’s where a Unified Namespace (UNS) comes in. A UNS acts as a bridge to break down these data silos. It’s a centralized architecture that allows different systems to communicate seamlessly, no matter the underlying technology. By setting up a UNS, you can easily bring in data from various systems, including Modbus, and consolidate it into one accessible point.

At FlowFuse, we support both Modbus and MQTT protocols, making it easy to integrate Modbus data into the UNS. We’ve chosen MQTT as the broker for our UNS because it’s lightweight, uses a pub-sub architecture, and is well-suited for real-time communication and cloud integration.

Once the Modbus data is in the UNS, it can be used for real-time monitoring, predictive maintenance, and analytics. For instance, in a factory still running Modbus with older systems, data from machines like motors, pumps, and conveyors can be sent to the UNS. This means stakeholders can access that data in real time, gaining insights into machine performance and system health. By consolidating data that was once trapped in silos into one place, the UNS helps organizations streamline operations, make better decisions, and boost efficiency.

How to Bridge Modbus to MQTT

Let's look at the steps to bridge Modbus data to MQTT using FlowFuse, leveraging Node-RED's capabilities. The process involves retrieving data from a Modbus device (For Practical example, we are using OpenSim to simulate Modbus data), transforming and processing the data (e.g., scaling raw sensor data into human-readable formats), and sending it to your Unified Namespace.

Bridging Modbus Data to MQTT using Node-RED

Prequsite

A Modbus data source, such as an actual Modbus device or a simulator like ModSim.
A FlowFuse account, which enables you to create and deploy Node-RED instances securely on the cloud with a single click, collaborate on projects with your team, manage and monitor edge devices centrally, handle data pipelines efficiently, and leverage its integrated MQTT broker service for seamless UNS management, with an intuitive interface for securely managing clients.

If you haven’t signed up for a FlowFuse account yet, do so now by clicking sign up.

Step 1: Collect Data from Modbus Devices

The first step is to collect data from your Modbus devices. To do this, you'll need to run Node-RED on your Device. If your Modbus device communicates via a serial port, Node-RED will need access to that port, which you can manage with the appropriate configuration. If you're using Modbus TCP and both Node-RED and your Modbus device are on the same network, the connection is straightforward.

Step 1.1: Running the FlowFuse device agent on your edge device

To run Node-RED on your edge device with just a few simple steps, you can use the FlowFuse Device Agent. This allows you to run Node-RED locally and also connect it to FlowFuse Cloud for remote monitoring and management, making it easier to keep track of your devices and workflows from anywhere.

Step 1.2: Install Modbus Nodes

While Node-RED doesn't include Modbus nodes by default, adding them to your palette is simple. Installing the necessary Modbus nodes from the Node-RED library will enable communication with your Modbus devices, whether they’re connected via serial or TCP. This step ensures you can start reading data from your Modbus devices and processing it for further integration.

Open the Palette Manager by clicking the menu icon in the top-right corner of Node-RED and selecting Palette Manager.
In the Palette Manager, search for node-red-contrib-modbus in the search bar.
Click Install to add the Modbus nodes to your Node-RED environment.
Once installed, the nodes appear in the left-side palette under the Modbus category. These nodes will allow you to interact with Modbus devices in your flow.

Step 1.3: Configure the Modbus Connection

Next, you'll need to configure the Modbus connection based on your device type. Modbus devices can communicate using two primary protocols: Modbus RTU (over serial) or Modbus TCP (over Ethernet/Wi-Fi). The specific choice depends on the type of Device you are working with.

Drag a Modbus Read node onto your Node-RED Canvas.
Double-click on the Modbus Read node to open its configuration.
In the configuration window:
- Enter the Unit ID (this is the device address, typically 1, but it may vary depending on your device).
- Choose the Function you need, such as Read Holding Registers, Read Input Registers, etc. (this depends on the type of data you want to read).
- Specify the Start Address (the address of the first register you want to start reading).
- Set the Quantity (the number of registers to read).
- Specify the Poll Rate (e.g., how often you want to collect data, such as every 1 second).
In the Server field, click the + button to add a new Modbus server, and select the type.
- For Modbus TCP: Enter the IP address and Port (the default Modbus TCP port is 502).
- For Modbus RTU: If you're using a serial connection, you'll need to specify the serial port (such as /dev/ttyUSB0 on Linux or COM1 on Windows), as well as the baud rate and other serial settings.
- Set the Unit ID (again, this should match the Unit ID you entered earlier).

Image showing Modbus node configuration for reading holding registers

Image showing Modbus client node configuration

Once the connection details are filled in, click Add to save the configuration, then click Done.

Step 1.4: Test the Modbus Connection

After configuring the connection, it's time to test the data collection.

Drag a Debug node onto the canvas.
Connect the Modbus Read node's output to to the input of Debug node.
Click Deploy in the top-right corner of Node-RED to deploy your flow.
Open the Debug Panel on the right side of the Node-RED interface. If the connection is successful, you should see the raw data from your Modbus device in the Debug Panel.

If no data appears, check the connection settings (IP address, Unit ID, port, etc.) and ensure your Modbus device is correctly configured and accessible. If you use a simulator like ModSim, ensure it’s running and properly configured to send data.

For more information on using Modbus with Node-RED, please read our tutorial on Using Modbus with Node-RED.

Step 2: Transforming Modbus Data for UNS

After collecting data from your Modbus device, the next step is transforming it into a usable format for cloud-based IoT applications. Modbus data typically comes in raw register values, and you may need to convert these values into human-readable formats like temperature, pressure, or other measurements.

Let's walk through the transformation process step by step.

Step 2.1: Parsing and Converting Raw Modbus Data

Modbus devices often return data in registers that need to be interpreted. For example, a temperature sensor might return a register value like 350, which represents 35.0°C if the sensor stores values in tenths of degrees.

The ModSim interface, generating simulated Modbus data

Here’s an example of the raw Modbus data I am receiving from ModSim: [225, 1013, 29, 50, 603]. These values represent the following:

225: Temperature (in tenths of degrees, which would be 22.5°C)
1013: Part 1 of the pressure value (higher register)
29: Part 2 of the pressure value (lower register)
50: Vibration (in tenths of degrees, which would be 5g)
603: Humidity (in tenths of degrees, which would be 60.3%)

We must convert these raw register values into human-readable formats for cloud integration. For instance, we divide the temperature and vibration by 10 to get the actual values in degrees Celsius and g, respectively, and similarly for other parameters like humidity. For pressure, the higher and lower register values are combined to compute the complete value accurately.

To determine how to process raw Modbus data, such as dividing by a specific value, concatenating, or applying other transformation formulas, refer to the manual of the sensor you use for specific instructions.

In Node-RED, you can use various nodes for transformation. You can choose the Function node for advanced processing, the Change node for simpler operations, or the Template node for defining schemas. In this article, I will demonstrate a low-code approach using the Change node to process the data cleanly.

Additionally, for better organization and accessibility, I will send each metric separately and include additional metadata such as the timestamp and unit.

For Temperature:

Drag a Change node onto the canvas.
Double-click the node to open its configuration panel.
Set the following in the Set rules:
- Set msg.data to msg.payload.
- Set msg.payload to {}.
- Set msg.payload.timestamp to the timestamp function of the Change node.
- Set msg.payload.value to data[0] / 10.
- Set msg.payload.unit to 'c'.

Image showing the Change node rules transforming temperature data

Click Done to save the configuration.
Connect the first output of the Modbus Read node to the input of this Change node.

For Pressure:

Drag another Change node onto the canvas.
Double-click the node to open its configuration panel.
Set the following in the Set rules:
- Set msg.data to msg.payload.
- Set msg.payload to {}.
- Set msg.payload.timestamp to the timestamp function of the Change node.
- Set msg.payload.value to $number($string(data[1]) & $string(data[2])) as a JSONata expression.
- Set msg.payload.unit to 'ppm'.

Image showing the Change node rules transforming pressure data

Click Done to save the configuration.
Connect the first output of the Modbus Read node to the input of this Change node.

For Vibration

Drag another Change node onto the canvas.
Double-click the node to open its configuration panel.
Set the following in the Set rules:
- Set msg.data to msg.payload.
- Set msg.payload to {}.
- Set msg.payload.timestamp to the timestamp function of the Change node.
- Set msg.payload.value to data[3] / 10 as a JSONata expression.
- Set msg.payload.unit to 'g'.

Image showing the Change node rules transforming vibration data

Click Done to save the configuration.
Connect the first output of the Modbus Read node to the input of this Change node.

For Humidity

Drag another Change node onto the canvas.
Double-click the node to open its configuration panel.
Set the following in the Set rules:
- Set msg.data to msg.payload.
- Set msg.payload to {}.
- Set msg.payload.timestamp to the timestamp function of the Change node.
- Set msg.payload.value to data[4] / 10 as a JSONata expression.
- Set msg.payload.unit to '%'.

Image showing the Change node rules transforming humidity data

Click Done to save the configuration.
Connect the first output of the Modbus Read node to the input of this Change node.

Once you have configured and connected all the Change nodes, add a Debug node to each Change node's output to verify that the transformed data appears as expected. Deploy the flow, then check the output in the Debug Panel to ensure that each metric is correctly formatted with the appropriate timestamp, value, and unit.

Step 3: Send Data to an UNS

After transforming the Modbus data into a human-readable format, the next step is to send it to a Unified Namespace (UNS). MQTT is one of the most popular choices for implementing a UNS because it is lightweight, efficient, and designed for real-time data transmission. Its low bandwidth requirements, message queuing capabilities, and secure and reliable communication support make it ideal for industrial IoT applications.

Step 3.1: Preparing MQTT Broker

FlowFuse simplifies the setup process by providing an integrated MQTT broker service for teams and enterprise users. This built-in service eliminates the need to set up an external broker. To use the FlowFuse MQTT broker, you need to create MQTT clients on the platform. These clients are secured with username and password authentication, ensuring only authorized devices can publish or subscribe to topics. For more details about the MQTT broker service provided by FlowFuse, refer to the MQTT Broker Service Announcement.

To create MQTT clients:

Navigate to the FlowFuse platform and click "Broker" in the left sidebar.
click the "Create Client" button in the newly opened interface.
Enter a username and password for the client.
Configure topic access control patterns if needed, specifying which topics the client can publish or subscribe to.
Click "Save" to create the client.
Once saved, copy the newly added client's Client ID from the list and save it for later use.

Step 3.2: Configure MQTT Nodes in Node-RED

In the Node-RED editor, drag the mqtt out node onto the canvas.
Double-click the node, then click the + icon next to the Server field to configure your broker details:
- For FlowFuse MQTT, use broker.flowfuse.cloud as the server address.
- Enter the Client ID, username, and password that you generated earlier.

Image mqtt broker node configuration

Click Add to save the configuration.
Select the appropriate QoS (Quality of Service) level based on your needs.
Enter the Topic for the MQTT message, such as plant2/Area4/Cell2/DeviceA/temperature. This naming convention organizes data by plant, area, cell, and Device, following the ISA-95 equipment hierarchy. It is widely used across industries because it makes managing, filtering, and scaling your system easier. Additionally, this approach simplifies data segmentation and provides straightforward access when other parts of the IoT ecosystem need it.

Image showing the MQTT Out node configuration

Note: For the configuration of MQTT nodes and Modbus, environment variables are used to prevent accidental exposure when sharing. For more information, refer to Using Environment Variables with Node-RED.

Click Done to save the node.
Connect the output of the Change node, which is transforming the metrics you are sending via MQTT, to the mqtt out node.

Repeat these steps for each metric (e.g., pressure, vibration, humidity), giving each one its own mqtt out node with a unique topic.

For more information on using MQTT with Node-RED, please read Using MQTT with Node-RED.

Once you’ve configured the MQTT nodes for all your metrics and deployed the flow, check the status at the bottom of each MQTT node. If it shows "connected," your Node-RED flow is successfully connected to the broker and publishes data to the UNS. From here, you can integrate the data with cloud-based analytics platforms. Build IoT dashboards with FlowFuse Dashboard, or other systems to enable real-time monitoring, predictive maintenance, and automated decision-making. This setup effectively bridges the gap between legacy Modbus devices and modern IoT infrastructure, empowering smarter, more efficient industrial operations.

To view the topic hierarchy in UNS, go to the FlowFuse platform, navigate to the Broker section, and click on the Hierarchy tab. The interface will look similar to the one shown below:

Image showing FlowFuse topic heirachy intergace for UNS

Final Thought

Bridging Modbus data to MQTT and publishing it to a Unified Namespace (UNS) is crucial in modernizing industrial systems. With FlowFuse, you can easily connect legacy Modbus devices to the cloud, enabling real-time monitoring, analytics, and predictive maintenance.

FlowFuse offers a complete toolkit for building and managing your UNS. It combines MQTT for real-time communication, a robust data orchestration layer, and a centralized management platform for enterprise-level control. This unified approach simplifies the integration of devices, applications, and legacy systems, ensuring smooth data flow and delivering real-time insights across your organization.

With FlowFuse, you can optimize industrial data workflows, improve decision-making, and unlock the full potential of your operational data, all while reducing complexity and enhancing system scalability.

Building a Unified Namespace (UNS) with FlowFuse

2024-11-28T00:00:00Z

As systems and devices become more connected, managing data from different sources can be tricky. A Unified Namespace (UNS) solves this by centralizing all your data in one place, making it easy to access and use.

FlowFuse makes building a UNS simple. It connects old and new systems, collects data from devices and applications, and streamlines workflows. With tools like Node-RED for data flow, MQTT for real-time updates, and a central management layer, FlowFuse helps you improve efficiency and make better decisions.

This article will show you how to build your UNS using FlowFuse, step by step.

Building a UNS with Real-Time Sensor Data

This section explains how to set up a Unified Namespace (UNS) using FlowFuse, a Raspberry Pi, and an ADXL345 sensor. The Raspberry Pi collects data from the sensor, which we collect and process in Node-RED, calculate vibration magnitude, format it, and send it to the UNS using standardized topic names.

Step 1: Collect Metrics from Devices

The first step in building your UNS is collecting data from your devices. The method you choose will depend on the type of device and the communication protocol it supports. For example, many devices use traditional communication standards like Modbus, while others, such as industrial controllers, might rely on OPC-UA.

Fortunately, Node-RED provides support for a wide range of industrial protocols, from legacy to modern ones. While older protocols like Modbus and OPC-UA were originally designed for machine-to-machine (M2M) communication and are not directly compatible with cloud systems, Node-RED acts as a bridge to overcome this limitation.

By leveraging Node-RED, you can collect data from these legacy systems, process and transform the data using low-code workflows, and then seamlessly send it to the cloud via modern protocols such as MQTT, Kafka, AMQP, and more.

In our example, Node-RED can directly collect metrics from sensor using I2C on the Raspberry Pi. This approach simplifies the process by eliminating the need for additional communication layers. To run Node-RED on the Raspberry Pi, we use FlowFuse Device Agent, This agent enables you to remotely monitor, manage, and build Node-RED flows securely through the FlowFuse platform remotely. See here for more details on how to set up and run FlowFuse Device Agent on different devices.

Step 2: Transform and Process the Collected metrics

Once you've collected data from your devices, the next step is to transform it using Node-RED. Industrial systems often use different protocols such as Modbus and OPC UA, and each might have its own data structure, which can create challenges for integration. For example, the ADXL345 sensor which we are uisng in our practile example outputs raw data as electrical signals (buffer data). We first need to format it into a human-readable format and then calculate the Magnitude, a standard vibration monitoring unit.

Why Data Transformation Matters:

Consistency: Ensures data from different sources follows the same structure.
Integration: It makes integrating data from various systems easier.
Speed: Simplifies data access for faster insights and decision-making.

Example: Transforming Data from ADXL345 Sensor (Raspberry Pi)

Raw data from the ADXL345 sensor might look like this:

[26,0,244,255,37,255]

Using a Function node in Node-RED, we can convert this into a human-readable format.

Function node: Transforming Raw Data into Readable Format

After transformation, the data will look as shown below.

{
    "x":0.09765625,
    "y":-0.046875,
    "z":-0.8828125
}

While this is more readable, it can still be challenging to monitor changes in vibration quickly or detect anomalies. To simplify monitoring, we can calculate the Magnitude, a single metric commonly used in vibration monitoring.

Change node: Calculating Magnitude

After calculating the Magnitude using a Change node, the data might look like this:

{
    "x":0.00390625,
    "y":-0.07421875,
    "z":-0.8515625,
    "magnitude":0.8547996098775871
}

Now, the data is easier to monitor with a single metric (Magnitude), but this structure is still not optimal for a UNS. We need to transform it further to provide more context.

Enhanced Data Structure for UNS:

To make the data more useful for integration and interpretation in a UNS, we can transform it to include additional context, such as units and timestamps, while removing unnecessary metrics like the three-axis components (x, y, z). The easiest and most low-code approach for achieving this in Node-RED is to use the Change node, which is specifically designed for formatting and structuring payloads.

Change Node: Formatting and structuring payload for UNS

After formatting, the data will look as shown below:

{
  "name": "vibration",
  "timestamp": "2024-11-13T10:00:00Z",
  "unit": "m/s²",
  "value": 0.8547996098775871
}

This format is more structured and consistent, with important labels like value, unit, and timestamp that provide meaningful context. It clarifies that the value represents the Magnitude of vibration in m/s² and provides the precise time when the data was collected.

Step 3: Setting Up Your UNS Broker

Now, it's time to configure your UNS broker. As mentioned, we’ll use the FlowFuse MQTT Broker. This broker is integrated within the FlowFuse platform to simplify your workflow by eliminating the need for multiple separate services. With FlowFuse, you can monitor and configure everything from a single, centralized platform. This ensures you can efficiently monitor, manage, and configure your UNS without juggling multiple tools or services.

Steps to Set Up the FlowFuse MQTT Broker:

Log in to the FlowFuse platform and navigate to "Broker" in the left sidebar.
Click the "Create Client" button at the top-right corner to add a new MQTT client.
Configure the client:
- Provide a Username and Password for secure access.
- Define an Access Pattern to manage client permissions.
Click "Create" to generate the client.

Note: Enterprise-level teams can register up to 20 clients, and teams-level teams can register up to 5 clients as part of their plan. The ability to purchase additional packs of clients will come in a near future release.

Copy the client ID you generated from the list and save it somewhere for later use.

FlowFuse Interface for creating MQTT Client

Step 4: Choosing Your Topic Naming Convention

The key to building a successful UNS is organizing your data with a clear and consistent naming convention. A well-designed convention ensures data is accessible and understandable across systems and users, simplifying communication and integration.

ISA-95 is a standard for industrial systems encompassing various manufacturing and communication aspects. However, when it comes to communication, ISA-95 often relies on point-to-point (P2P) connections between systems and devices. These connections can introduce complexity, delays, and other challenges.

While we are building a UNS to address the problems and limitations we observed with point-to-point communication, we can still leverage key elements of ISA-95 that remain valuable for improving production efficiency. One of the central aspects of ISA-95 is its equipment hierarchical model, which links various layers of a factory, from physical devices to enterprise systems. By adapting this model to your data architecture, you can simplify data access and management across the entire system.

ISA-95 : Equipment Hierarchical Model

For example, following an ISA-95-based equipment hierarchy to define your topic naming convention allows you to access data from devices, sensors, or any other source without knowing their specific addresses or tags—such as for a PLC. With clarity and ease, this logical structure enables you to retrieve relevant information from different system layers (e.g., from control systems to MES or ERP).

Example topic structure based on ISA-95 equipment model hierarchy:

Plant1/Area3/Line4/Cell2/DeviceA

Plant1/Area4/Line5/Cell6/DeviceB

You can also use the Sparkplug B naming convention for MQTT topics, which offers a structured hierarchy and standard. However, the Sparkplug B convention has some limitations in terms of flexibility. A typical Sparkplug B topic follows this structure:

spBv1.0/{groupID}/{edgeNodeID}/{deviceID}/{messageType}

While Sparkplug B provides a standardized topic model, its hierarchy may not always suit the specific needs of your architecture. Alternative methods, such as the Paris and Schultz models, help address these limitations with Sparkplug B topics. However, to keep things simple and avoid unnecessary complexity, we will use plain MQTT with the ISA-95 hierarchy.

Step 5: Sending Collected metrics to UNS

With your topic naming convention chosen, it’s time to send the data to the UNS. In Node-RED, we will use the MQTT Out node to send the transformed data to the broker.

Drag an MQTT out node into your flow.
Configure the node to connect to the FlowFuse MQTT Broker using the client credentials generated earlier.

Note: Use environment variables to secure configuration and prevent exposing credentials when sharing flows. This ensures that sensitive data remains secure and allows easy sharing without compromising security. For more details, refer to the Article: Using Environment Variables in Node-RED.

Configuring mqtt-broker-config node

![Configuring mqtt-broker-config node](./images/mqtt-broker-config-security .png){data-zoomable} Configuring mqtt-broker-config node

Set the topic using your predefined naming convention (e.g., Plant1/Area3/Line4/Cell2/RPI1).

Configuring mqtt-out node

Connect the input of the mqtt out node to your data transformation flow and deploy the flow.

For information on how to use MQTT with Node-RED, refer to Using MQTT with Node-RED

After deploying, you can monitor the topic hierarchy on the FlowFuse platform by switching to the "Hierarchy" tab in the Broker interface.

Monitoring your mqtt topic hierarchy within FlowFuse

Once your data is in the UNS, you have a centralized, real-time view of your operations. This unified structure enables easier access, sharing, and analysis of data across systems, helping you drive better decisions, improve efficiency, and gain valuable insights to optimize your processes.

With real-time data access, you can create monitoring dashboards using the FlowFuse Dashboard with a low-code approach, integrate with other cloud solutions, or leverage it further for enhanced analytics or automation.

FlowFuse Dashboard Monitoring Vibrations

Conclusion

FlowFuse makes building a Unified Namespace (UNS) easy by centralizing data from systems, devices, and sensors. With seamless integration of Node-RED, MQTT, and its enterprise layer, FlowFuse ensures smooth data flow, real-time insights, and efficient management. It simplifies operations, enhances productivity, and improves system interoperability, making it easy to adapt your UNS to specific needs and support real-time analytics and automation.

Curious about how FlowFuse can simplify building your Unified Namespace?

Let’s Walk You Through It – Book a Demo Today

The Death of Point-to-Point: Why You Need a Unified Namespace

2024-11-26T00:00:00Z

Manufacturing has changed significantly over the years, driven by new technology and the need for better communication between systems. In the past, point-to-point (P2P) connections, where devices communicate directly with each other, were the standard. However, as factories become more complex, P2P connections are no longer practical. This article explains why P2P connections are outdated and how a Unified Namespace (UNS) offers a better, more flexible solution.

What are Point-to-Point Connections?

Point-to-point connection

Point-to-point (P2P) connections are direct links between two systems or devices, allowing them to communicate with each other. They can be physical, like cables, or network-based (client-server), like a machine sending data to a server.

In a P2P setup, each connection links exactly two systems. These systems could be hardware, software, or even databases, exchanging data tailored to their needs.

For example, a machine might send performance data directly to a control system, or a sensor could send real-time measurements to a monitoring device. It’s a straightforward way to get systems talking, but as the number of devices grows, it becomes increasingly complex to manage.

Why Point-to-Point Connections No Longer Work

As manufacturing moves toward more modern, interconnected approaches like Industry 4.0, the limitations of point-to-point connections become more apparent. Here's why P2P connections are no longer sufficient for today’s manufacturing environments:

Point-to-point connections often lead to data silos, where devices or machines communicate only with their immediate hierarchy level. This isolation severely limits system-wide visibility, making it challenging to share critical data in real-time. Consequently, problems such as defective products, unexpected downtime, and the need for rework may go unnoticed until the damage is done.

In modern manufacturing, real-time data is indispensable for maintaining operational efficiency. However, point-to-point connections introduce significant delays, as data must traverse multiple layers—control systems (Level 1), supervisory control (Level 2), manufacturing execution systems (Level 3), and finally, higher-level management systems (Level 4) as outlined in the ISA-95 model. Each additional layer compounds latency, slowing response times and postponing the detection of issues, see also our post on Why the Automation Pyramid slows you down.

Without integrated, real-time data across teams, such as quality control, problems like defective parts may not be addressed promptly, leading to increased waste and customer dissatisfaction. The lack of seamless data sharing results in visibility gaps that impede decision-making, reducing the ability to act swiftly. In fast-paced environments, these delays not only hinder operational efficiency but also have a direct negative impact on profitability.

2. Inflexibility, Limiting Innovation, and Causing Downtime

Point-to-point connections create a rigid and inflexible network. When new technology or equipment is added, the entire system often requires reconfiguration, leading to significant downtime. For instance, if a new machine is introduced to the production line, many connections may need to be adjusted or re-established, which can temporarily halt production.

This downtime disrupts the flow of operations and makes it harder to implement new technologies quickly, slowing down innovation. As a result, manufacturers may struggle to stay competitive, as they can't integrate advancements like automation, real-time analytics, or AI without significant delays and costly interruptions.

3. High Costs Over Time and Maintenance Complexity

At first glance, point-to-point (P2P) connections may appear to be a cost-effective and straightforward solution. However, as systems expand, the true costs and complexities become increasingly apparent. In the automation pyramid (ISA-95 model), communication occurs across multiple hierarchical levels, with field devices interacting with controllers, controllers with SCADA, and SCADA with higher-level systems such as MES and ERP.

While this layered structure can keep connections orderly, it quickly becomes a logistical nightmare when scaling. Introducing new devices often triggers a cascade of necessary updates and reconfigurations across various levels. For example, adding a new field device typically requires adjustments to the controller, followed by updates to the SCADA system, creating a ripple effect that impacts the entire system.

This ongoing need for constant reconfiguration not only drives up costs but also introduces significant complexity in maintenance. As the system grows, so does the effort and resources required to manage it, making the P2P model inefficient and prohibitively expensive in environments that demand agility, scalability, and long-term sustainability. Ultimately, the simplicity of P2P connections gives way to an increasingly cumbersome and expensive maintenance burden, undermining its initial advantages.

4. Security Vulnerabilities

As the number of point-to-point connections increases, so does the risk of security breaches. Each connection represents a potential vulnerability, and if one connection in the network is compromised, the entire system becomes a target for attackers.

In large manufacturing environments, securing every individual connection becomes daunting. Any new device or system can introduce additional vulnerabilities, creating more opportunities for attackers to exploit. A compromised point-to-point connection could lead to production halts, loss of sensitive data, or even physical damage to machinery.

For example, imagine a situation where a hacker gains access to a machine’s control system through a compromised point-to-point connection. The attacker could intentionally cause a malfunction, halt production, or extract confidential information. The complexity of managing security for each connection makes it difficult to maintain a secure, reliable network.

5. Scalability Issues

One of the most significant drawbacks of P2P connections in manufacturing is their inability to scale efficiently. As production lines grow, so too do the number of devices, systems, and connections that must be managed. With a P2P architecture, each new device or system typically requires a direct, dedicated connection to each relevant part of the network. This creates a spaghetti network of interwoven links that becomes increasingly unwieldy and difficult to manage as the system expands.

In a traditional P2P setup, scaling the network means manually creating additional links, configuring them, and ensuring that the new connections fit seamlessly into the existing infrastructure. This process is time-consuming, error-prone, and highly resource-intensive, leading to increased complexity and longer downtimes as you scale.

When scaling a P2P network, changes made to one part of the system often trigger a ripple effect throughout the entire network. For instance, adding a new sensor may require updating the controller, the SCADA system, and even the Manufacturing Execution System (MES). This cascading need for updates across different layers of the network makes scaling more complicated and costly. Furthermore, the introduction of new devices means additional configuration and troubleshooting, often leading to disruptions in operations and extended downtimes while the new devices are integrated.

These issues compound when scaling across multiple production lines or sites, creating an increasingly complex web of p2p connections. As the number of devices grows, so does the risk of errors, network failures, and delays. This makes it difficult for manufacturers to respond to the growing demands of production while maintaining efficiency, reliability, and uptime.

Unified Namespace: The Modern Solution

Hub and Spoke Model

A Unified Namespace (UNS) is a more straightforward way to connect devices and systems in a factory. Instead of having separate connections between each device, everything is connected through one central hub, which we call the hub-and-spoke model. This means devices don’t need to be directly linked to each other, making the system easier to manage and maintain; for more information on Unified Namespace, read our article: Introduction to unified namespace.

With a UNS, adding new devices or systems becomes straightforward. Rather than setting up multiple direct connections—like in a point-to-point system—new devices (spokes) connect to the central hub. This reduces the complexity of growing your system and eliminates downtime. If equipment is replaced or updated, only that device needs to be reconnected to the hub rather than reconfiguring the entire network.

A UNS also improves data sharing. All data is collected in one place, so any system that needs it can access it in real time. This leads to quicker decisions and faster responses to problems. With fewer connections to manage, the costs of maintaining the system are lower. Plus, the central hub makes the whole system more secure, as fewer direct connections need to be protected.

Publish-Subscribe Archtecture

We use a publish-subscribe (pub/sub) architecture to implement a hub-and-spoke model in a UNS. In this architecture, devices, systems send data to a central broker, and other devices can subscribe to the data they need. This approach eliminates the need for a complex network of point-to-point connections, making it easier to scale, update, and maintain the system.

This model addresses all the significant problems of point-to-point connections. For more information on how pub/sub solves these problems or why UNS needs pub/sub, read the article: Why UNS Needs Pub/Sub.

MQTT is a widely used for implementing the publish-subscribe model. It is lightweight, efficient, and works well in manufacturing environments where network reliability can be inconsistent.

Unified Namespace

To simplify the creation of a UNS in your manufacturing environment, FlowFuse provides an integrated MQTT broker service. The platform makes building, scaling, and managing Node-RED solutions easy. It supports seamless connections between devices, services, and APIs using over 5,000 community-contributed nodes for data collection. FlowFuse also enables efficient data transformation and visualization with a low-code approach, remote management of edge devices, and team collaboration on projects. With everything centralized on one platform, FlowFuse offers high security, scalability, and availability to optimize and maintain your system effectively.

Get started with this article Building UNS with FlowFuse.

Summary

Due to complexity, high maintenance costs, and security risks, point-to-point (P2P) connections are becoming less effective in modern factories. A Unified Namespace (UNS) solves these problems by connecting devices through a central hub, making managing, scaling, and securing systems easier. UNS improves data sharing and reduces downtime. Tools like FlowFuse make it simple to set up and manage a UNS, offering a more efficient and flexible solution for manufacturing.

Start building your own Unified Namespace with FlowFuse and take the first step toward a more efficient and connected manufacturing system.

Introducing the Industrial Visionaries Podcast!

2024-11-26T00:00:00Z

Today, we’re excited to announce our new podcast: Industrial Visionaries!

This show is dedicated to exploring the transformative power of technology in the manufacturing sector.

In each episode, our host ZJ van de Weg, CEO of FlowFuse, brings you face-to-face with industry leaders who are pioneering digital solutions, sharing insights that will help you navigate the future of manufacturing.

Episode 1: FlowFuse’s Nick O’Leary on Low-Code Development and Its Impact on IoT

In our inaugural episode of Industrial Visionaries, our host ZJ van de Weg, chats with fellow FlowFuse exec, Nick O’Leary, CTO & Founder. Nick, who is also the creator of Node-RED, shares his extensive insights into the evolution of the Internet of Things (IoT). He discusses the early days of IoT and the transformative role of edge computing, highlighting how increased computing power has shifted data processing closer to devices.

Listen to the first episode on:

We look forward to bringing you more conversations with actionable insights that help in your pursuit to innovate in your industry.

For the latest episodes, search for “Industrial Visionaries” on Spotify, Apple, YouTube, or wherever you listen to podcasts!

Getting the Most Out of MQTT for Industrial IoT

2024-11-25T00:00:00Z

MQTT is a go-to protocol for industrial IoT, known for its efficiency, scalability, and ease of use. While it offers great flexibility in handling real-time data, there are key factors to consider in order to get the most out of it. From ensuring data consistency to addressing security and performance concerns, these factors can significantly enhance MQTT’s effectiveness in industrial settings.

This post dives into how to optimize MQTT for industrial IoT, covering best practices and key considerations. It also highlights how FlowFuse can help streamline MQTT communication, improving data reliability, security, and integration across devices and systems.

Standardizing Data Formats for Better Quality and Consistency

Industrial data is generated by a wide variety of devices, machines, and systems, making it highly valuable. However, to fully leverage this data, it needs to be standardized and formatted in a way that ensures seamless processing across different systems, especially since it can come in a variety of formats.

One of MQTT’s key strengths is its flexibility in handling various data formats. While this is an advantage, it can sometimes require additional effort to ensure that the data is structured consistently and in a way that’s easy to use. Standardizing data formats helps organizations streamline processes, making data easier to interpret, analyze, and act upon. Without a consistent approach, data inconsistencies may arise, slowing down insights or causing compatibility issues.

Frameworks like Sparkplug B are designed to help address this by providing a standardized way to handle MQTT payloads. By adopting such frameworks, companies can ensure that data is delivered in a consistent, well-structured format, improving compatibility and making it easier to analyze. This not only simplifies integration across diverse systems but also enables more reliable decision-making and efficient operations.

Optimizing Payloads and Bandwidth for Efficient MQTT Communication

MQTT is designed for lightweight, efficient messaging, which makes it ideal for many IIoT applications. However, in cases where large amounts of data or high-frequency messages need to be transmitted, bandwidth constraints can sometimes impact performance.

While the MQTT protocol supports large message payloads (up to 250 MB), transmitting large files such as high-resolution images or detailed sensor data can slow down communication. Fortunately, there are simple yet effective strategies to keep your MQTT network running smoothly, even when dealing with sizable payloads.

To optimize performance, consider compressing your data before sending it, which reduces the overall size of the payload and makes transmission faster and more efficient. For even larger files, such as video or binary data, a great approach is to store these files externally (e.g., in cloud storage like AWS S3) and send only a reference or pointer to the data. This avoids the need to transmit large files over MQTT while ensuring data accessibility.

By using these strategies, you can optimize MQTT performance and ensure that your system runs efficiently, even when handling large or high-frequency data. These techniques allow MQTT to continue providing fast, reliable, and scalable communication, regardless of the data size or frequency.

Ensuring Reliable Data Delivery with MQTT’s QoS Levels

In industrial environments, the accuracy and timeliness of data transmission are crucial for maintaining operational efficiency and safety. MQTT’s publish-subscribe model is designed for lightweight, real-time messaging, but it’s important to understand how to leverage its features to ensure the reliability and integrity of the data flow.

While the protocol is generally robust, in some cases, challenges such as network disruptions or temporary communication failures can occur. These can lead to issues such as message loss or delivery out of order. Fortunately, MQTT provides built-in mechanisms to address these challenges and ensure that messages reach their intended destination reliably.

One of the key feature for managing message delivery is Quality of Service (QoS), which defines how MQTT handles message delivery:

QoS 0: Messages are delivered at most once, with no guarantee of delivery or order. This level is ideal for scenarios where occasional message loss is acceptable and minimizing network overhead is critical.
QoS 1: Guarantees that messages are delivered at least once, although duplicates may occur. This is useful when data consistency is important, but some duplication can be handled by the system.
QoS 2: Ensures messages are delivered exactly once and in the correct order. This highest level of QoS is suitable for scenarios where data integrity and sequencing are paramount, such as in robotic control systems or safety-critical operations.

By choosing the right QoS level, you can align MQTT’s behavior with the operational needs of your system, balancing between performance, data reliability, and system resources. For real-time applications, a lower QoS level may be sufficient, while in more critical situations, the higher QoS levels offer a stronger guarantee of data delivery and integrity.

With these options, MQTT allows you to fine-tune message delivery to meet the specific requirements of your industrial IoT environment, ensuring that data flows smoothly and reliably, even in challenging network conditions.

Implementing Acknowledgment Mechanisms in MQTT

One important consideration when working with MQTT is the lack of built-in acknowledgment mechanisms. Unlike traditional request-response communication models, where the receiver explicitly confirms the receipt of a message, MQTT doesn't natively offer a direct way for the receiver to acknowledge successful message receipt.

This lack of visibility can pose challenges in scenarios where it’s crucial to ensure that data has been transmitted successfully and processed as expected. In some industrial systems, failure to confirm receipt of messages could lead to operational uncertainty or potential errors.

However, while MQTT does not provide this feature out-of-the-box, it is possible to implement acknowledgment mechanisms to enhance reliability. we can use a separate topic where the receiver sends a confirmation message (such as “ack” or “received”) back to the sender, indicating that the message was successfully processed.

This allow you to implement acknowledgment functionality, but they do require additional planning and development effort. Ensuring that these mechanisms are correctly designed and integrated can improve system reliability by providing the necessary feedback loop for confirming message receipt and processing.

By incorporating acknowledgment systems, you can enhance the visibility and confidence in data transmission, ensuring that your industrial IoT system operates smoothly and that no critical messages are missed or lost.

Optimizing MQTT for Resource-Constrained Environments

While MQTT’s use of TCP/IP ensures reliable message delivery, it can introduce challenges in environments where devices have limited resources. Maintaining persistent TCP connections can consume significant processing power and memory, which may be a concern for low-power or resource-constrained devices.

To address this, some IoT systems use MQTT-SN (MQTT for Sensor Networks), a variant that operates over UDP and is specifically designed for devices with limited resources. MQTT-SN reduces the overhead associated with maintaining a TCP connection, making it a better fit for battery-powered or embedded devices that need to conserve energy. However, it's important to note that MQTT-SN is distinct from the standard MQTT specification, as it involves different message formats and communication mechanisms.

By carefully selecting the appropriate protocol and architecture for your specific use case, you can continue to leverage MQTT-like messaging capabilities, while optimizing performance in environments with limited resources.

Ensuring Security in MQTT Deployments

Security is essential when using MQTT in industrial environments. While MQTT offers powerful features like encryption and authentication, it's crucial to configure these elements correctly to maximize security. A properly secured MQTT deployment ensures that your system remains protected from risks such as data interception, unauthorized access, or man-in-the-middle attacks, while ensuring that your communication remains secure and reliable.

To begin, implementing encryption (SSL/TLS) is an important step to protect the data transmitted between devices and brokers. This ensures that sensitive information is kept confidential and is shielded from unauthorized access. By enabling encryption, you create a secure communication pathway that prevents eavesdropping and data tampering.

Next, consider authentication for all devices and users. By using mechanisms such as usernames, passwords, or client certificates, you can ensure that only authorized devices and users can connect to your MQTT broker. This access control mechanism ensures that only the right people and devices have access to the network, safeguarding it from potential threats.

Topic-level access control is another key aspect of securing your MQTT deployment. By managing who can publish or subscribe to specific topics, you can prevent unauthorized access to sensitive data or critical commands. For example, you can restrict which devices or users are allowed to subscribe to specific topics that control industrial equipment or monitor sensitive processes. This level of control ensures that only trusted entities can interact with certain parts of your system, reducing the risk of malicious actions.

In addition to restricting access to topics, it's also important to regularly monitor your MQTT traffic for any unusual activity or anomalies. By staying vigilant and analyzing traffic patterns, you can identify potential security threats early and take action to prevent any disruptions.

By configuring your MQTT setup with encryption, authentication, topic-level access control, and ongoing monitoring, you can create a secure, reliable, and scalable IoT system. A well-secured MQTT deployment not only reduces risks but also enhances the efficiency and safety of industrial operations, providing peace of mind as your system grows.

Minimizing Risks of Single Point of Failure and Vendor Lock-In

When using MQTT for industrial operations, it’s important to address the potential risks associated with a single point of failure—specifically the central broker. While the broker is crucial for managing message delivery, its failure could disrupt the entire data flow, impacting operations. However, this challenge can be effectively managed with strategies like high availability, load balancing, and robust backup solutions. By implementing these best practices, you ensure that your system remains reliable and resilient, even in the event of a failure.

Another consideration is vendor lock-in, which can occur when businesses become reliant on a specific MQTT broker or service. While this may seem convenient at first, it can make future changes or migrations difficult due to proprietary features or configurations that aren't easily compatible with other systems. This is a scenario that can be easily avoided with careful planning.

Although MQTT is an open standard, some cloud services may not fully adhere to the MQTT 3.1.1 specification. This can sometimes lead companies to rely on proprietary software development kits (SDKs) for sending MQTT messages. While these tools can work well initially, they can limit your ability to switch vendors or integrate with other systems down the road.

To maintain flexibility and avoid vendor lock-in, it's crucial to choose an MQTT broker that fully supports MQTT's open standards. Brokers that follow standards like MQTT 3.1.1 or MQTT 5.0 ensure compatibility and interoperability, making it easier to switch providers or integrate new technologies as your needs evolve.

How FlowFuse Enhances Your Industrial IoT System

FlowFuse is an industrial data platform that streamlines the management, scaling, and security of IoT applications. Built on Node-RED at its core, FlowFuse offers seamless integration with various industrial protocols, including MQTT, ensuring reliable communication between devices. With its robust feature set, FlowFuse makes it easier to build secure, scalable, and efficient IoT solutions for industrial environments

A key strength of FlowFuse is its ability to standardize data before sending it to the MQTT broker. Using Node-RED’s intuitive low-code programming capabilities, you can define consistent data formats and topics across all connected devices. This ensures smooth integration between diverse systems and maintains data consistency, allowing everything to work together seamlessly. FlowFuse also supports frameworks like Sparkplug B, providing additional structure for more reliable communication with MQTT payloads.

Security is another area where FlowFuse excels. It allows you to configure MQTT nodes with SSL/TLS encryption, username/password authentication, and other security measures to ensure secure communication between devices. This protects sensitive data from unauthorized access and ensures that your system’s communications remain confidential.

FlowFuse also simplifies the creation of acknowledgment mechanisms. With Node-RED, you can design custom workflows to track message receipt and processing, ensuring data integrity and improving operational transparency. This level of control guarantees that your system operates smoothly and reliably.

Additionally, FlowFuse provides its own MQTT broker service that follows open standards, helping you avoid vendor lock-in and offering the flexibility to scale and adapt as your needs evolve. With built-in high availability, load balancing, and access control mechanisms, FlowFuse ensures continuous and reliable and secure data flow. And you can scale its capabilities by contacting FlowFuse support to meet the growing demands of your industrial IoT system.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

Conclusion

Getting the most out of MQTT for industrial IoT is all about smart strategies and the right tools. By focusing on data consistency, security, and performance, you can build a resilient and efficient IoT ecosystem. With FlowFuse, you get a powerful, flexible platform that not only streamlines MQTT communication but also helps you stay ahead of challenges like security risks and vendor lock-in. Whether you're optimizing payloads, enhancing security, or scaling your system, FlowFuse makes it easier to unlock the full potential of your industrial IoT operations.

FlowFuse 2.11: MQTT Topic Hierarchy, UI Revamp & Improved Logging

2024-11-21T00:00:00Z

The focus of the FlowFuse 2.11 release has all been about providing clarity for our users and reducing friction in our user experience.

Navigation in FlowFuse has been streamlined with a new sidebar and team-wide search feature. We've provided an interactive visualization for your MQTT topic hierarchy, ensuring you have a clear view of your own MQTT/UNS architecture, and, we've re-architected the audit logging to ensure you have an easy-to-understand and searchable view of everything going on in your FlowFuse Team and it's respective Applications, Instances and Devices.

If you're using FlowFuse Cloud, you'll have already noticed a big improvement to our navigation sidebar on the left of the user interface that was released a couple of weeks ago. This is now packaged up into FlowFuse 2.11 and available to our self-hosted customers too.

Screenshot of the improve left-side navigation in FlowFuse

This is the first stage of a navigation revamp we're working on, that will represent a big improvement for navigation around FlowFuse, and help make managing your applications easier.

You'll notice we've renamed "Devices" to "Edge Devices" to make it clearer that these are instances of Node-RED that are running on devices, rather than just a record of the device itself. We've also separated out many of the pages into sections, making it easier to find what you're looking for, and giving us scope to add in more in the coming weeks, which will make it easy to jump straight to the features you need.

Team-wide Search

A very popular feature in the "home" view of FlowFuse is the search bar that helps you find the relevant Application, Instance, or Device you're looking for. This has been moved into the top header and will be available on every page of FlowFuse, making it even easier to find what you're looking for, wherever you are.

Screenshot of the team-wide search

This will soon be followed by an update to our "Applications" view which is currently quite over-crowded. We're always looking to reduce friction for our users, and this is a big step in doing that.

MQTT Topic Hierarchy

We recently announced our very own MQTT Service, and we're following that up with an update that lets you see what topics are being used by your MQTT clients in the UI:

Screenshot of the UI to explore your MQTT topic hierarchy

This will make managing your event-driven applications even easier, giving you clarity on the structure of your topic-space, whether you're using the MQTT Broker for a unified namespace (UNS) or any other use case.

Audit Logging Improvements

We've improved the Audit Log views at the Team and Application levels to given you better visibility on the actions taken by users across your whole team in FlowFuse.

Previously, only events associated to that "level" (e.g. Team, Application, Instance) were shown in the respective log. However, now, when you view the "Team" Audit Log, it shows not just events on that team specifically, e.g. a settings change, but also all Audit events for it's "children", i.e. the Applications, Instances, Pipelines, etc. that are part of that team too.

New filters on the right-side also make it easy to explore everything taking place in your FlowFuse Team, allowing you to dive into a given Instance, all from the top-level "Team" view.

Screenshot of the improved audit log view

For a full list of everything that went into our 2.11 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try FlowFuse

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is on our own hosted instance, FlowFuse Cloud.

Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

Upgrading FlowFuse

If you're using FlowFuse Cloud, then there is nothing you need to do - it's already running 2.10, and you may have already been playing with the new features.

If you installed a previous version of FlowFuse and want to upgrade, our documentation provides a guide for upgrading your FlowFuse instance.

If you have an Enterprise license please make sure to review this changelog entry

Getting help

Please check FlowFuse's documentation as the answers to many questions are covered there. Additionally you can go to the community forum if you have any feedback or feature requests.

Why UNS needs Pub/Sub

2024-11-19T00:00:00Z

As the manufacturing industry evolves and becomes increasingly connected through the Industrial Internet of Things (IIoT), the concept of a Unified Namespace (UNS) has emerged as a critical architecture for centralizing and organizing data. UNS serves as a central reference point where all operational data, from machines to the enterprise, can be accessed in a consistent and structured way. Over time, more and more manufacturers have adopted UNS to simplify data integration and improve real-time visibility across systems.

If you're unfamiliar with UNS, please read our Introduction to Unified Namespace for a basic understanding of UNS.

If you're familiar with or already using a UNS, you might be asking: Why does a UNS need Pub/Sub? Here, we’ll explore how combining the Pub/Sub model with a Unified Namespace can help manufacturers streamline data flow, reduce latency, and enable more responsive and scalable operations.

What is Pub/Sub?

Before discussing why Publish/Subscribe (Pub/Sub) is essential for a UNS, let's first define the Pub/Sub model.

Publish Subscribe Model

The Pub/Sub model is a way for systems to communicate where one component, called the publisher, sends messages to a central system ( Broker such as MQTT, RabitMQ, and Kafka ), and other components, called subscribers, receive those messages. The publisher doesn’t need to know who the subscribers are, and the subscribers don’t know who the publishers are. The central system, or broker, ensures the right messages go to the right subscribers based on their interests.

Additionally, it’s important to note that the roles of publisher and subscriber are not mutually exclusive. A component can act as a publisher in one context, sending messages to the broker, and as a subscriber in another, receiving messages from the broker.

Why Does a UNS Need Pub/Sub?

Now that you have a basic understanding of Pub/Sub, let’s dive into why this architecture is essential for a Unified Namespace.

Decoupling Producers and Consumers with Flexible Communication

In traditional manufacturing setups, various systems and machines often operate in silos, requiring point-to-point connections for communication. This means each device or system must be directly linked to others, which quickly becomes complex and cumbersome as the number of systems grows. Point-to-point integrations are hard to scale because each new device needs a dedicated connection. This not only makes data harder to access but also blocks innovation by creating dependencies between systems.

To learn more about how point-to-point systems restrict innovation, please read the article: Why the Automation Pyramid Blocks Digital Transformation

The Pub/Sub model provides a more scalable solution. In this model, publishers (such as IoT devices or machines) generate data and send it to a central system. Subscribers (other systems, applications, or users) then receive only the data relevant to them. Crucially, the publishers and subscribers do not need to know about each other, relying instead on a central Namespace to distribute the data efficiently.

By using Pub/Sub in a UNS, industries can create a single reference point for all data, enabling systems to subscribe to the data streams they need, without direct connections to every other system. For example, a production line monitoring system can easily access data from temperature sensors, pressure gauges, and robotic arms without the need for complex point-to-point integrations.

Unlike point-to-point systems, the Pub/Sub model allows for flexible communication—whether one-to-one, one-to-many, or many-to-many—without the need for direct connections between each system. This flexibility ensures that as your factory evolves, new devices and applications can easily be integrated into the UNS, driving innovation.

Event-driven and Asynchronous Communication

The Pub/Sub model is particularly well-suited for event-driven architectures, where systems react to changes in data rather than periodically polling for updates. This is important in environments where responsiveness is key—such as in predictive maintenance, supply chain optimization, or automated decision-making.

For instance, a predictive maintenance system can subscribe to real-time sensor data from machines in a UNS. When the system detects an anomaly (e.g., a machine vibration out of normal parameters), it can immediately trigger an alert or maintenance action. This type of asynchronous communication is more efficient and scalable than synchronous polling or direct communication between producers and consumers.

Less Delay, More Efficiency

In industries where IIoT-enabled operations are prevalent, real-time data is essential for effective decision-making. Traditional systems often introduce delays due to multiple layers of data collection, storage, and processing. These delays can result in inefficiencies such as slow machine adjustments, missed production targets, or equipment failures.

The Pub/Sub model reduces latency by immediately pushing data to subscribers as soon as it’s available. There’s no need for systems to poll or wait for periodic updates. Instead, they can respond to real-time events as soon as they occur.

For instance, in a smart factory, if a machine’s temperature exceeds a threshold, a maintenance system could instantly react by scheduling a technician, triggering an alert, or even pausing operations. Without Pub/Sub, the system would have to rely on polling mechanisms, which are less efficient and often introduce unnecessary delays.

In real-time environments, these immediate actions can make the difference between preventing costly downtime or catching a problem too late.

Easy to Scale as You Grow

Manufacturers are always expanding—whether by adding more machines to the production line, introducing new automation systems, or scaling up to handle more products or more data. Scaling traditional systems to keep up with this growth can be complex and costly, especially when new devices or technologies need to be integrated.

The beauty of Pub/Sub is that it scales effortlessly. When new machines or sensors are introduced, they simply publish their data to the namespace. No complex reconfiguration or integration is required. Similarly, if a new application needs to access this data, it can simply subscribe to the relevant streams.

For example, consider a car manufacturer adding new robotic arms to the production line. These robots can publish real-time performance data, such as arm movement speeds, energy consumption, and fault alerts, directly into the UNS. The factory’s existing data systems can then subscribe to this new data without requiring changes to the entire system, making integration quick and cost-effective.

This level of scalability helps manufacturers keep up with growth without worrying about complex system upgrades or slowdowns.

Making Your Systems More Reliable

In manufacturing, system downtime is costly. However traditional, monolithic systems often rely on point-to-point connections, which can create vulnerabilities. If one part of the system goes down, it can bring down other systems or halt production entirely.

With a Pub/Sub architecture, this is less of a concern. If one publisher (like a sensor or machine) fails or goes offline, the rest of the systems can continue operating as normal. Other sensors or machines can continue to send their data, and subscribers can still receive real-time updates from other sources.

Consider a delivery system in a Point-to-Point setup, all vehicles send data directly to a central dispatch system. If the central dispatch system fails, data from all vehicles is lost. In a Pub/Sub setup, vehicles send their data to a central namespace instead of directly to the dispatch system. If the central dispatch system fails, it doesn’t result in data loss. Vehicles can still send their updates.

This decoupling of systems improves resilience, meaning that your factory can continue running smoothly even if individual components experience issues.

While the broker is a critical part of the Pub/Sub system and can also go down, this risk can be mitigated. Strategies such as high-availability brokers, failover mechanisms, and clustered deployments can be implemented to prevent downtime and ensure uninterrupted data flow.

Taking Action

As we've discussed, the Pub/Sub model is a game-changer for Unified Namespace architectures in the manufacturing industry. One of the most widely adopted protocols for implementing Pub/Sub is MQTT (Message Queuing Telemetry Transport). MQTT is known for its simplicity, efficiency, and low-bandwidth requirements, making it an ideal choice for Industrial applications.

To help you leverage the power of MQTT in your manufacturing operations along with Node-RED, Flowfuse offers a robust MQTT broker service. Now, Flowfuse will not only help you build, scale, and manage Node-RED solutions, collaborate across teams, and manage edge devices, but it will also simplify your integration of IIoT data streams into your Unified Namespace. For more information on how our FlowFuse MQTT broker Service, read our MQTT Broker Service Announcement.

Get started with this article Building UNS with FlowFuse.

Conclusion

Integrating Pub/Sub with a Unified Namespace enhances manufacturing operations by enabling real-time data flow, reducing latency, and improving scalability. This combination ensures efficient, resilient, and future-ready systems, empowering manufacturers to stay competitive in the IIoT era.

Curious about how FlowFuse can simplify building your Unified Namespace?

Interacting with ESP32 Using Node-RED and MQTT

2024-11-14T00:00:00Z

The ESP32 is an affordable and powerful microchip that combines Wi-Fi and Bluetooth in one small package. It's commonly used in smart devices like home automation systems, wearables, and other IoT projects. Despite its low cost (around $6), it offers strong performance, and low power consumption, and is compatible with popular platforms like Arduino. Whether you're a hobbyist or a business, the ESP32 provides great value, making it easy to create wireless devices without a big investment. This tutorial demonstrates how to set up communication between the ESP32 and Node-RED using MQTT, along with an interactive dashboard via FlowFuse for a user-friendly interface.

Prerequisites

To follow this tutorial, you'll need the following:

ESP32 microcontroller: The hardware you'll be using for this project.
USB cable: To connect the ESP32 to your computer.
Arduino IDE: Installed and set up to program your ESP32. Download the Arduino IDE if you haven't already done so.
- Additionally, if you haven't set up the Arduino IDE for the ESP32 board, please follow this tutorial: How to Set Up ESP32 with Arduino IDE
FlowFuse account: This will allow you to create and deploy Node-RED instances securely on the cloud with a single click, collaborate on your Node-RED projects with your team, manage and program your edge devices remotely, and provide an MQTT broker with an interface for securely managing clients.

If you haven’t signed up for a FlowFuse account yet, sign up now.

Getting Started with ESP32 and Node-RED

In this section, we’ll set up Node-RED on FlowFuse, create an MQTT connection, and configure everything to interact with your ESP32. This will lay the foundation for building your IoT flows and controlling devices.

Step 1: Creating Node-RED instance on FlowFuse Cloud

Start by logging into your FlowFuse account and creating a new Node-RED instance. For more information on creating a Node-RED instance, refer to the FlowFuse documentation.

Once the instance is created, open the Node-RED editor.

Step 2: Creating and Configuring MQTT Clients in FlowFuse

In this step, we’ll set up MQTT to enable communication between Node-RED and the ESP32. MQTT (Message Queuing Telemetry Transport) is a lightweight messaging protocol designed for reliable, low-bandwidth communication between devices in IoT applications.

We use MQTT because it allows devices to communicate over a network (like Wi-Fi) without the need for a direct physical connection. This makes it perfect for long-distance communication, where devices need to send and receive data efficiently, even when they are not physically connected or close to each other.

Diagram showing the flow of data and how commands are sent to the ESP32 using MQTT using Node-RED

In our setup, Node-RED will publish commands to the MQTT broker, and the ESP32 will subscribe to topics to receive responses. The ESP32 will then perform actions, such as controlling an LED. To facilitate this, we’ll create two MQTT clients in FlowFuse (since the MQTT broker is already set up and managed by FlowFuse, you don’t need to worry about its configuration or maintenance). One client will be for Node-RED, and the other will be for the ESP32. These clients will handle the secure and reliable exchange of messages, ensuring smooth communication between the two devices.

To Create MQTT Clients in FlowFuse:

Navigate to your FlowFuse platform and log in to your account.
In the left sidebar, click on "Broker".
In the newly opened interface, click the “Create Client” button.
Enter a username and password for your MQTT client. Confirm the password.
- You can leave the default pattern as # for access control, or set a custom pattern if needed.

Interface for setting MQTT client details and credentials

Click "Create" to generate the client.
Copy the client ID and save it somewhere secure for later use.
Repeat the same steps to create the second MQTT client for the ESP32.

Step 3: Building a Node-RED Dashboard to Send Commands Over MQTT

Now that we’ve created the MQTT clients, it’s time to build a Node-RED dashboard and create a flow that will publish commands to the FlowFuse MQTT broker. This will later allow you to interact with your ESP32 using a user-friendly interface.

Let's first create a flow to connect to the MQTT broker with the client config we have created:

Drag the mqtt out node onto the canvas in Node-RED.
Double-click the mqtt out node to open the settings.
Click the pencil icon next to the Server field to open the MQTT broker configuration.
In the configuration, enter the following details:
- Server: broker.flowfuse.cloud
- Client ID: The Client ID you created earlier.
- Username: The MQTT username (Client ID).
- Password: The MQTT password.
Click "Add" to save the configuration, then select the newly added configuration.
In the Topic field, enter a topic name, such as /LEDControl.
Click "Done" to close the settings.
Click "Deploy" in the top-right corner to deploy the flow.
Once deployed, check the MQTT out node for a Connected status, confirming the connection to the MQTT broker.

For this example, we will create a very simple dashboard. If you're not familiar with FlowFuse Dashboard, you can refer to the following blog to get started: FlowFuse Dashboard: Getting Started

Install the @flowfuse/node-red-dashboard from the Node-RED Palette Manager.
Drag two ui-button widgets onto the canvas.
Double-click on the first button and set the Label to "ON", the Background Color to Green, and the Payload to 1. Adjust the Width and Height as needed.
Double-click on the second button and set the Label to "OFF", the Background Color to Red, and the Payload to 2.
Connect the output of both buttons to the input of the mqtt out node.
Click "Deploy" to save the flow.

Now, when you click either the "ON" or "OFF" button on the dashboard, it will send either 1 or 2 as the payload. The ESP32 will use this payload in its code to turn the LED on or off. To view the dashboard, switch to the Dashboard 2.0 tab on the right side and click the Open Dashboard button. The dashboard will look similar to the image below.

FlowFuse Dashboard Build to control the ESP32 LED

Step 4: Programming ESP32 to receive commands from MQTT and Control LED

Now, let's move on to the final step. Before proceeding, make sure your ESP32 is connected to your laptop or computer via USB*. The USB connection is essential for uploading the code (sketch) to the ESP32, which will enable it to connect to the internet and communicate with the MQTT broker. The ESP32 will subscribe to the MQTT topic we configured earlier (e.g., /LEDControl). Based on the received payload (1 or 2), it will control the LED accordingly — turning it on or off.

Setting up Arduino IDE:

Open the Arduino IDE on your computer.
Ensure you have selected the correct board and port in the Tools menu.
Install the necessary library:
Go to Tools > "Manage Libraries".
Search for and install the "EspMQTTClient" library by Patrick Lapointe.
The library installation will prompt you to install its dependencies—ensure that you tick that option and proceed to install.

Code for ESP32:

Copy the following code into the Arduino IDE:

#if defined(ESP32)
#include <WiFi.h>
#elif defined(ESP8266)
#include <ESP8266WiFi.h>
#endif

#include <PubSubClient.h>

#define LedPin 2 // ESP32 built-in LED pin

// WiFi and MQTT settings
const char* ssid = ""; // Change this to your WiFi SSID
const char* password = ""; // Change this to your WiFi password
const char* mqtt_server = "broker.flowfuse.cloud"; // FlowFuse MQTT broker server

// MQTT client credentials
const char* mqtt_client_id = ""; // Replace with your MQTT client ID
const char* mqtt_username = ""; // Replace with your MQTT username
const char* mqtt_password = ""; // Replace with your MQTT password

WiFiClient espClient;
PubSubClient client(espClient);

// Function to connect to WiFi
void setup_wifi() {
    delay(10);
    Serial.println();
    Serial.print("Connecting to ");
    Serial.print(ssid);
    WiFi.begin(ssid, password);

    while(WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
 }

    Serial.println("\nWiFi connected");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
}

// Callback function to handle messages from subscribed topics
void callback(char* topic, byte* payload, unsigned int length) {

 String msg;
    for (int i = 0; i < length; i++) {
 msg += (char)payload[i];
 }

 // Control LED based on message
    if (msg == "1") {
        digitalWrite(LedPin, HIGH); // Turn LED on
 }
    else if (msg == "2") {
        digitalWrite(LedPin, LOW); // Turn LED off
 }
}

// Function to connect to MQTT broker
void reconnect() {
    while (!client.connected()) {
        Serial.println("Attempting MQTT connection...");

 // Connect to MQTT broker with the client ID, username, and password
        if (client.connect(mqtt_client_id, mqtt_username, mqtt_password)) {
            Serial.println("Connected to MQTT broker");
            client.subscribe("/LedControl");
 }
        else {
            Serial.print("Failed, rc=");
            Serial.print(client.state());
            Serial.println(" trying again in 5 seconds");
            delay(5000);
 }
 }
}

void setup() {
    Serial.begin(115200);
    pinMode(LedPin, OUTPUT);
    setup_wifi();
    client.setServer(mqtt_server, 1883);
    client.setCallback(callback);
}

void loop() {
    if (!client.connected()) {
        reconnect();
 }
    client.loop();
}

Replace the placeholder values in the code: SSID (your Wi-Fi network's SSID), Wi-Fi Password (your Wi-Fi network's password), MQTT Client ID (the MQTT client ID you generated for esp32), MQTT Username and Password (the MQTT credentials you created).
After you've made these changes, click "Upload" in the Arduino IDE to upload the code to your ESP32.
Once the upload is complete, open the Serial Monitor (set the baud rate to 115200) to monitor the output.

If everything is set up correctly, you should see the output in the Serial Monitor as shown in the image.

Serial monitor displays the result when everything is set up correctly.

Once you verify the setup, you can unplug the USB from the computer and connect the ESP32 to a power adapter. With this, your ESP32 is now powered and connected to Wi-Fi (make sure your device is on the same Wi-Fi network as the one configured in the code), allowing you to control the LED from anywhere in the world via the MQTT commands sent through Node-RED.

Troubleshooting

Can't Upload Code to ESP32
- Solution: Make sure the correct board and port are selected in the Arduino IDE. Check Tools > Board for the right ESP32 model and Tools > Port for the correct connection. If the port is missing, Download and reinstall the CP210x USB drivers.
ESP32 Keeps Disconnecting from MQTT

Solution: Make sure both the ESP32 and Node-RED have unique MQTT client IDs. If both devices share the same client ID, they will conflict and cause disconnections.

ESP32 Doesn’t Respond to Commands (LED Not Turning On/Off)
- Solution: Verify the topic in the ESP32 code matches the one in Node-RED (e.g., /LedControl). If it still doesn't work, try rebooting your ESP32.

Conclusion

In this tutorial, we successfully connected the ESP32 to Node-RED using MQTT, enabling remote control of an LED via a FlowFuse dashboard. This simple IoT setup demonstrates how easy it is to interact with devices using MQTT and Node-RED, offering a flexible and scalable solution for future projects. With the ESP32, Node-RED, and FlowFuse, you can easily expand and integrate more devices into your IoT system.

Migrating from Self-Managed Node-RED to FlowFuse-Managed Node-RED

2024-11-13T00:00:00Z

Migrating your Node-RED instance to FlowFuse centralizes management and simplifies deployment. Once migrated, FlowFuse takes care of the infrastructure, security, and scalability, making the process much easier. This allows you to focus on building solutions without worrying about the complexities of self-hosting. Whether you're working with edge devices or want to work on cloud instances, this migration streamlines the management of your IIoT workflows, improving efficiency and scalability.

Let's explore how to migrate from a self-managed and self-hosted Node-RED setup to a FlowFuse-managed environment. We'll look at how the migration works for both edge devices and cloud instances.

Why Switch from Self-Managed Node-RED to FlowFuse-Managed Node-RED?

Managing self-hosted Node-RED instances can introduce a range of challenges, especially as your Industrial Internet of Things (IIoT) environment scales. These challenges include:

Deployment Complexity: Installing and configuring Node-RED across multiple devices or environments requires technical expertise and attention to detail. For large-scale deployments, managing numerous instances across different devices or servers can become cumbersome and error-prone.
Security and Maintenance: Ensuring your Node-RED instances are secure and up-to-date requires continuous monitoring, timely security patches, and ongoing maintenance. Keeping instances stable and secure can be time-consuming and requires dedicated resources to avoid vulnerabilities.
Scalability: As your IIoT environment grows, scaling your Node-RED infrastructure to handle increased workloads can be challenging. Managing multiple distributed instances often leads to inconsistencies and difficulties in maintaining optimal performance across your entire system.
Edge Device Management: Managing Node-RED instances on edge devices introduces additional complexity. Remote access, secure monitoring, and seamless updates become more difficult as your network expands, especially when dealing with a large number of edge devices.

FlowFuse addresses these challenges by providing a fully managed, secure, and scalable environment for your Node-RED instances. With FlowFuse, you can focus on building and deploying your IIoT solutions, while FlowFuse handles the infrastructure, updates, and scalability. This reduces operational overhead and ensures your instances remain up-to-date and secure.

For more information, read the article: Transform Chaos into Control: Centralize Node-RED Management with FlowFuse.

Migrating from Node-RED to FlowFuse

Before you start, make sure you have a FlowFuse Account created. Next, consider how your Node-RED instance needs to be deployed. Decide whether it should run on the edge device or as a cloud instance.

Running Node-RED on an edge device is ideal when your application flow needs direct access to hardware components, such as reading sensors or controlling actuators. This setup allows immediate data processing and control, crucial for applications requiring low latency responses.

On the other hand, if your use case involves monitoring or collecting metrics—such as through MQTT—without needing direct hardware interaction, and you primarily need to transform, contextualize, visualize, or automate repetitive tasks that don't require hardware interaction, a Cloud Instance may be more suitable. This option allows you to centralize data collection and processing, making it easier to manage and analyze data from multiple devices.

Note: The instructions provided in this article also work for self-hosted FlowFuse environments. Just ensure that when following the steps, you're performing the actions within your self-hosted FlowFuse setup rather than the FlowFuse cloud platform.

Creating a Cloud Instance

The FlowFuse snapshot feature, available through the @flowfuse/nr-tools-plugin for self-managed Node-RED (a plugin that allows you to create snapshots from a self-managed Node-RED instance to the FlowFuse platform), However, it does not support direct device snapshots. Instead, you must first create a snapshot for the Cloud Instance and then assign it as the target for your device.

Navigate to the FlowFuse platform and log in to your account.
Select the application under which you want to manage your Node-RED instance. You can either choose the default application created with your account or click the "Create Application" button to create a new one.
Once inside the application, select "Add Instance."
Enter a name (or let the system generate one automatically), select the instance type, and choose the Node-RED version that matches your current setup.
Click "Create" to launch the instance.

Creating a Device Instance and Connecting It to FlowFuse

If you need to run Node-RED on the edge device itself but want to manage it remotely, follow the steps below. Skip this step if your Node-RED Application flow can run on the cloud.

Navigate to the cloud instance you created above.
Go to the "Devices" tab by clicking on top "Devices" option and select "Add Device".
Once you click "Add Device", a device configuration popup will appear. Copy the command provided and save it for later.
Follow the steps to install the FlowFuse Device Agent on your device as given in this documentation.
Execute the saved command on the device.
Start the FlowFuse device agent by executing the following command:

   flowfuse-device-agent --port=1881

Running on port 1881 ensures it doesn't conflict with your locally running Node-RED instance, allowing both to run without issues.

Creating Essential Backups Before Migration

Creating a cloud instance is essential for the migration process, regardless of whether your Node-RED instance will run on the device or on the cloud. As discussed earlier, the @flowfuse/nr-tools-plugin does not support creating direct snapshots for devices on the platform. Therefore, you must first create a snapshot for the cloud instance before deploying it to the device.

Follow these steps to create a cloud instance:

Install the @flowfuse/nr-tools-plugin into your Node-RED instance via the Palette Manager.
Once installed, open the "FlowFuse tools" tab in the sidebar.
Connect to your FlowFuse Cloud account by clicking the "Connect to FlowFuse" button.
(If you're migrating to a self-hosted FlowFuse instance, ensure you configure the plugin with the correct URL. For detailed steps, refer to the FlowFuse Node-RED Tools plugin Documentation).
A browser popup will appear, prompting you to log in to your FlowFuse account. Click "Allow" to grant permission.
After successful authorization, you'll be able to select your team and the associated instance from the "FlowFuse tools" tab.
Choose the team and FlowFuse instance you want to migrate to or the one you will use to take snapshots for your device.
Click the "+ Snapshot" button to create a snapshot. A popup will appear asking for a name and description. Enter the required details and click "Create".
Once the snapshot is created, it will be listed in the sidebar.
To verify, navigate to the FlowFuse platform, go to the FlowFuse Cloud instance you created earlier, and switch to the "Snapshots" tab. The snapshot you created should be visible there.

Backing Up System-level Environment Variables

While the snapshot captures flows, credentials, and environment variables at the flow and global level, it does not capture process environment variables—those set in the Node-RED settings.json file.

To get these variables, you can use the following flow to dump a list of all process environment variables into the debug window:

Import and deploy the flow into your self-managed Node-RED instance.
Click the Inject Node's button

Once clicked, the flow will print all environment variables in the debug window. Identify the environment variables required for your flow and save them in a notepad for later use.

Setting System-Level Environment Variables in FlowFuse

Now that you have created the snapshots and copied the process environment variables, you need to set these variables in the Node-RED instance to avoid errors during deployment and smooth application running.

Go to the your FlowFuse Cloud/Device instance.
Open the Settings tab by clicking the "Settings" option at the top of the page, then select the Environment tab.
Add the environment variables one by one by clicking the "+ Add" button in the bottom-left corner.
After adding all the environment variables, click "Save."

For more information refer to Using Environment Variables in Node-RED

Migrating Static Assets to FlowFuse Static Assets

When working with dashboards or files required in your Node-RED project, these files are typically stored locally and are always available, even if you restart or modify the flows. However, when migrating from Node-RED to a FlowFuse cloud environment, you'll need to manually migrate these files to the cloud-based Node-RED instances. To make this process easier, FlowFuse offers a static assets service feature at the instance level.

Here’s how you can migrate your assets:

Locate your static assets in your local system that are used in your Self-managed Node-RED instance from the snapshot we have taken.
Upload them one by one through the Instance "Static Assets" tab. For more information, refer to the Static Asset Service documentation.

Once you have migrated all your assets, you will be able to access them in the instance created in the FlowFuse cloud. Just ensure that after deploying the snapshot, the path set in the flow matches the static assets migrated to the FlowFuse instance.

Deploying Snapshot for the Cloud/Device instance

Once the system-level environment variables are set and all static assets have been migrated ( if your Node-RED application flow is using static assets), you can deploy the captured snapshot to either the Cloud or Device instance.

Navigate to the FlowFuse Cloud instance where you created the snapshot by clicking "Hosted Instance" in the left sidebar and selecting the instance from the list.
Switch to the "Snapshots" tab at the top to locate the snapshot you created from the list.
On the right side of the snapshot, click the three-dot icon:
- If you are migrating to the Cloud Instance, select "Restore Snapshot"
- If you are migrating to a Device Instance, select "Set as Device Target"

Setting a device target will ensure that the snapshot will be deployed on all of the devices associated with this instance.

Conclusion

Migrating from a self-managed Node-RED setup to FlowFuse is simple and offers significant benefits. By transitioning, you’ll reduce operational complexity, enhance security, and improve scalability. FlowFuse handles the infrastructure, so you can focus on building and optimizing your IIoT solutions—whether on edge devices or in the cloud.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

Run FlowFuse Device Agent as a service on MacOS using Docker

2024-11-12T00:00:00Z

The FlowFuse Device Agent is a tool that enables you to run Node-RED on various hardware devices, such as Raspberry Pi, Windows, MacOS, and PLCs. Running Node-RED directly on the device helps when your application flow needs direct access to sensors and actuators connected to the hardware, facilitating seamless integration with the FlowFuse platform. This integration enables secure management, monitoring, and remote editing of flows from a centralized platform, even at the edge.

In this article, we will explore how to run the FlowFuse Device Agent as a service on MacOS using Docker. This setup ensures that the Device Agent runs in the background, automatically starts on boot, and maintains a continuous connection the FlowFuse platform for remotely managing your Node-RED flows, even after a device restart. This eliminates the need to manually start the agent after each reboot, saving you time and effort.

Prerequisites

Before starting, ensure that you have the following set up:

FlowFuse Account: You need an active FlowFuse account to register your device and manage your flows remotely. If you don't have an account, you can sign up at FlowFuse.

NOTE: The instructions in this guide were tested on MacBook M1 & M4 MacBook Pro

Step 1: Install Homebrew

Homebrew is the MacOS package manager for installing packages and libraries. You can install it using the following command:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

This script will install the Homebrew package manager on your Mac. Once installed, you can easily install other packages like Docker and Colima.

Step 2: Install Docker

With Homebrew installed, you can now install Docker by running:

brew install docker-credential-helper docker

This will install Docker and its credential helper, which is useful for managing authentication with Docker registries.

Step 3: Install Colima

Colima is a free alternative to Docker Desktop, particularly useful for MacOS, and offers better compatibility with Apple Silicon hardware. We’ll need it to run the Flowfuse Device Agent container that we will create later. To install Colima, run:

brew install colima

Step 4: Start Colima

Once Colima is installed, start it with:

colima start

This command starts the Colima virtual machine, which Docker will then use to run containers. If Colima is not running, Docker won't have the necessary environment to create and run containers.

colima status

CLI: Showing the result of colima status

Step 5: Set Colima to Run as a Service

To ensure Colima starts automatically in the background, run the following:

brew services start colima

This will set Colima to run as a service, so it will start automatically every time your Mac boots up.

Step 6: Adding the Device to the FlowFuse Platform

Now, you'll need to add a new device to the FlowFuse platform and download the device configuration file. This configuration will allow to connect your MacOS device to your FlowFuse team. For more information on how to add a device and generate the configuration, refer to Generating "Device Configuration".

Step 7: Run the FlowFuse Device Agent Container

You can now run the FlowFuse Device Agent container using Docker. Replace /path/to/device.yml with the actual path to the device configuration file you have downloaded. The following command will launch the container:

docker run -d --restart unless-stopped \
 --mount type=bind,src=/path/to/device.yml,target=/opt/flowfuse-device/device.yml \
  -p 1880:1880 flowfuse/device-agent:latest

Explanation of the command:

-d: Run the container in detached mode (in the background).
--restart unless-stopped: Ensure the container restarts automatically unless explicitly stopped.
--mount type=bind,src=/path/to/device.yml,target=/opt/flowfuse-device/device.yml: Mounts your local device.yml file into the container so it can be accessed by the agent.
-p 1880:1880: Exposes port 1880 on your host machine, which is typically used for the Node-RED web interface.
flowfuse/device-agent:latest: The Docker image for the FlowFuse Device Agent.

Step 8: Verify the Device Agent is Running

To verify that the Device Agent is running correctly, you can use the following command:

docker ps

CLI: Showing the result of docker ps indicating the device agent is running correctly

This will list all running containers, and you should see the FlowFuse Device Agent listed there. If it's not running, you can check the logs to troubleshoot:

docker logs <container_id>

Additionally, you can confirm that the Device Agent is running and successfully connected to the FlowFuse platform by following these steps:

Navigate to the FlowFuse platform.
In the left sidebar, click on "Edge Devices".
Then, select the device you added for MacOS.

FlowFuse Platform: showing the status of your edge device

Now, you can start developing applications on the device remotely from any location and manage it efficiently.

Step 9: Ensure the Device Agent Restarts Automatically After a Reboot

The --restart unless-stopped flag in the Docker command ensures that your FlowFuse Device Agent container will automatically restart if your Mac reboots. However, it's always good to verify this by restarting your system:

Restart your Mac.
After rebooting, check the status of the FlowFuse Device Agent:

   docker ps

Conclusion

By following these steps, you've successfully set up the FlowFuse Device Agent on your macOS system using Docker and Colima. Now, the agent will run seamlessly in the background and restart automatically after a system reboot.

Visual Layout Editor - Now Available in Dashboard

2024-11-08T00:00:00Z

It has been one of the most requested features for FlowFuse Dashboard, and is now available in its first iteration. It is now possible to resize and move groups in the Dashboard itself using the new "Edit Layout" feature. That's not all though, we've added a new "Spacer" widget to assist with layouts, added improvements to the rendering of charts and plenty more.

Layout Editor - Quick Guide

For those transitioning over from the original Node-RED Dashboard 1.0, you'll notice some difference in how you can now edit the layout of your dashboard. Now, the editing is done directly in the Dashboard itself, rather than in the Node-RED editor.

To open the Dashboard in "Edit Mode", click the "Edit Layout" button for the relevant page in the Dashboard sidebar:

Screenshot to show the buttons available to "Edit Layout" for a given page

This will open the relevant page in "Edit Mode":

Short recording to show resizing and reordering in the visual layout editor

The three controls at the top of the page are:

Save Changes: Deploy any changes to the underlying Node-RED flow.
Discard Changes: Clear any in-browser changes that have not yet been saved.
Exit Edit Mode: Stop "Edit Mode" and interact with teh Dashboard as a standard end-user.

You can then use the handles on each group to resize them, or click and drag to re-position the groups on the page. How this re-positioning is done is controlled by the "Layout" property of the page. The Visual Editor is currently available for "Grid" and "Fixed" layouts only.

Once you're happy with your changes clicked the "Save Changes" button to deploy them to the underlying Node-RED flow. Note, you will then be made aware that "your flows have been updated" by Dashboard when you return to your Node-RED Editor.

Note that you can only enter "Edit Mode" via the Node-RED Editor, this is to ensure security and stability of your Dashboard, in cases where you may have users for your Dashboard that should not have access to modify your Dashboard's layout.

Layout Editor - Next Steps

We are very aware that is this is just the first iteration of the Layout Editor, and we have plenty of plans to improve it further. Here are some of the features we are considering for future releases:

Include widget resizing and ordering in the Layout Editor
Overhauling sizing options for groups and widgets #835

If there are any other key editor features you'd like to see, then please do reach out to us, open GitHub issues and help us shape the future of FlowFuse Dashboard.

In the Dashboard sidebar, you now have the option to add a "Spacer", this is just an empty widget that can be used to shift the position of other widgets. This can be useful for creating more complex layouts, or for adding space between widgets. For example, if you wanted to have some directional controls with up/down/left/right buttons, you could use a spacer to separate and align them:

(left) A d-pad controller layout using spacers, (right) the spacer's highlighted to demonstrate their positioning

Spacers can be any width and height, and will always render empty-space. To add a new spacer, you can click the "+" button in the Dashboard sidebar next to any Groups. You can then re-order the widgets there too (re-ordering of widgets in the visual layout editor will be coming soon).

What else is new?

You can find the full 1.19.0 Release Notes here.

Work has already begun on the next release, 1.20.0, you can see what items we have queued up here, if you've got any feedback or suggestions, please do let us know, and feel free to open new issues on our GitHub

We are Hiring!

You may have seen already that we are hiring for a full-time Front-End Engineer to join our team, and work on Dashboard, full-time. If you are interested in working with us, please do check out the job listing here.

MQTT Service Now Available on FlowFuse

2024-10-31T00:00:00Z

In our recent product update we have added our very own MQTT service, built-in and ready to use alongside your Node-RED applications. We are always engaging with users and prospective customers and this has been a highly requested feature, and so we are delighted to announce that this is now live on FlowFuse Cloud for our Team and Enterprise teams.

The MQTT Service is available now on FlowFuse Cloud. FlowFuse permits you to setup your own secure clients to begin publishing and subscribing to your own topics.

You can now use FlowFuse to manage your own MQTT Clients alongside your Node-RED instances, making it easier to build full-stack, event-driven applications within FlowFuse.

Use Cases

FlowFuse MQTT Service simplifies access to real-time data, an important element in optimizing industrial processes. With the power of FlowFuse, Node-RED and the MQTT service, your integrations are now even easier. Here are some typical uses cases:

Connect your MQTT enabled PLCs (like Omron N Series, Siemens S7, etc) to your Node-RED instance to open up such possibilities like:
- Data collection and analysis, Predictive Maintenance, OEE, Condition Based Monitoring.
- Triggering actions like sending Emails or alerting your engineers about an event.
- Realtime production monitoring of your facility.
Make use of modern IIoT devices on legacy systems by bridging the gap with MQTT.
Connect disparate systems together where Node-RED and FlowFuse act as the central hub for data processing and routing. This gives you the advantage of transforming data on the fly, applying extra contextual data from other systems, apply routing rules, and much more.

Pricing

If you're on the Team or Enterprise tiers of FlowFuse Cloud, then you don't have to pay any extra to get started with the MQTT Service.

Team Tier: Includes 5 clients for free as part of your existing plan
Enterprise Tier: Includes 20 clients for free as part of your existing plan

In the near future we'll be publishing extra packages of clients that you can add to your team, beyond the amounts included with the base tiers.

Getting Started

To get started with your own MQTT Clients, navigate to FlowFuse Cloud, and Sign In.

Click the new "Broker" option in the left navigation menu
Click "Create Client"

Screenshot of FlowFuse's "Create Client" interface

Fill out the client's credentials (Username + Password)
Define the "Access Control Rules" (see more below)
Click "Confirm"

With your client created, you can then, in Node-RED, use the MQTT nodes to connect to your new client.

Setting up a new broker in Node-RED, you can use your credentials accordingly:

Screenshot of the MQTT Config, "Connection" tab in the Node-RED Editor

And the respective "Security" tab:

Screenshot of the MQTT Config, "Security" tab in the Node-RED Editor

Access Control Rules

In MQTT, you can publish and subscribe to topics.

These topics are strings that you can use to organise your data. In the Access Control Rules, you can define which topics your client can publish and subscribe to.

For example, in a flow deployed to many PLCs on your factory floor, you might be publishing to the topics factory/body-shop/plc/1, factory/body-shop/plc/2, etc.

Simplified example of MQTT data flow for a Factory Floor

Then, in a Cloud-Hosted flow, you can subscribe to factory/body-shop/plc/# to receive all messages from all PLCs in the body shop, and display relevant data into a Dashboard.

Each client that you create can be constrained in two ways:

Action: You can limit clients to whether than can only subscribe, only publish, or conduct both actions.
Topic: You can control which topics a given client can interact with.

These constraints are particularly useful to ensure security throughout your MQTT network, and to ensure that data is only being sent and received by the correct components.

FlowFuse 2.10: MQTT Broker, Improved Version Control & More!

2024-10-24T00:00:00Z

With FlowFuse 2.10 we've added some new major features, as well as improvements across the board for FlowFuse users.

Most notably, FlowFuse now offers it's own MQTT service, with the option to create MQTT client credentials for your teams, making it even easier and quicker to build your full-stack Node-RED applications.

MQTT Broker

This is a significant milestone for FlowFuse, as we're now offering our own MQTT service. We have listened to a lot of feedback from users and prospective customers, and this has consistently been a regularly requested offering, and so we are delighted to announce that this is now live on FlowFuse Cloud for our Enterprise teams.

This feature allows you to run and manage your own MQTT Clients alongside your Node-RED instances, making it easier to build full-stack applications within FlowFuse.

Pricing

From today, Enterprise teams on FlowFuse Cloud will be able to create up to 20 clients on their accounts at no extra cost.

In the near future, users will then be able to purchase additional packs of clients to add to their team.

Self-hosted Enterprise customers will be able to make use of this feature in our next release.

Version History - Visual Timeline

Since early iterations of FlowFuse, Snapshots have played a key role in Version Control for your Node-RED flows, environment variables and settings. Whilst we still offer the same "Snapshots" view in the application, we've also added a new view to give a clearer picture of what flows are running on your Node-RED instances and when.

In this view, you can see every time a new set of flows were deployed to your Node-RED instance, no matter the source, whether that's from the Editor itself, via our DevOps Pipelines, or restoring a Snapshot.

Device Group Environment Variables

We've also added in the ability to define common environment variables in your Device Groups.

These will now be deployed to any devices contained within a given group, and can still be overridden by environment variables defined in the Device's settings directly.

See the Device Group documentation for more information on how to set environment variables for your device groups.

And Much More...

For a full list of everything that went into our 2.10 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try FlowFuse

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is on our own hosted instance, FlowFuse Cloud.

Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

Upgrading FlowFuse

If you're using FlowFuse Cloud, then there is nothing you need to do - it's already running 2.10, and you may have already been playing with the new features.

If you installed a previous version of FlowFuse and want to upgrade, our documentation provides a guide for upgrading your FlowFuse instance.

If you have an Enterprise license please make sure to review this changelog entry

Getting help

Please check FlowFuse's documentation as the answers to many questions are covered there. Additionally you can go to the community forum if you have any feedback or feature requests.

FlowFuse Security Features You Didn’t Know You Needed

2024-10-24T00:00:00Z

When it comes to securing Node-RED applications and its editor, ensuring that your flows and data are protected from unauthorized access can feel like a daunting task. Even after investing considerable time, achieving the right level of security often remains a complex challenge. For enterprises, this goes far beyond access control— security is a cornerstone of protecting sensitive data, maintaining operational continuity, and meeting strict regulatory requirements. A robust security framework not only prevents breaches but also safeguards intellectual property, preserves trust, and shields the organization from costly cyber threats.

Here are 9 ways FlowFuse simplifies and strengthens your Node-RED deployments, ensuring you’re fully protected without the hassle.

Default Security Measures to Keep Your Environment Safe

Securing your Node-RED applications is essential to protect sensitive data, proprietary business logic, and critical systems from unauthorized access or cyberattacks. Without proper safeguards, the risks of data loss, operational disruptions, and reputational damage are significant. FlowFuse implements robust security measures right from the start, ensuring your deployments remain safe. Data is encrypted during transmission, and rate limiting prevents traffic overloads, ensuring smooth operations. Additionally, secure tunnelling facilitates safe communication between your edge devices and the FlowFuse platform. To ensure that only authorized personnel have access to your FlowFuse team, we’ve implemented strong login authentication measures, which can be further enhanced with multi-factor authentication as needed.

Here’s the best part- we don’t just offer default protections; we empower you to fine-tune your security defences. FlowFuse features a user-friendly interface that allows you to customize your security settings and design a strategy tailored to your needs. Rest easy knowing that we've laid a solid security foundation while giving you the flexibility to enhance your defences.

If you're interested in learning more about how we safeguard your data privacy and security, we invite you to read our detailed security statement. Additionally, we are proud to announce that FlowFuse has achieved SOC 2 Type 1 compliance, demonstrating our commitment to maintaining the highest standards in security and data protection.

Single Sign-On (SSO) Integration

Every organization relies on various tools and platforms to enhance productivity and efficiency. Providing seamless access to these resources is vital for optimizing workflows. That’s where Single Sign-On (SSO) comes in, it simplifies the onboarding and offboarding processes.

With SSO, team members can log in using their existing credentials, eliminating the hassle of remembering multiple passwords. This streamlines their login experience and enables them to be productive from day one.

To implement SSO for your self-hosted FlowFuse, refer to the following resources:

If you are using FlowFuse Cloud, please get in touch with us for configuration assistance.

Two-Factor Authentication (2FA)

We've all been there, managing countless passwords, hoping they're strong enough to protect against security threats. But in today’s digital world, passwords alone aren’t sufficient. That’s why Two-Factor Authentication (2FA) has become essential.

FlowFuse understands this need. By enabling 2FA, even if someone gets hold of your password, they'll still require a second form of verification—like a code sent to your phone—to access your account. This simple yet powerful layer of security ensures your data is much safer from unauthorized access. However, when Single Sign-On (SSO) is enabled, 2FA will be replaced by SSO's authentication process.

To set up 2FA in FlowFuse, you’ll need to head over to User Settings > Security > Two-Factor Authentication. It’s as simple as clicking the "Enable Two-Factor Authentication" button, scanning the QR code displayed on the platform with your authenticator app, and then entering the code from your app back into FlowFuse. Once you've done that, 2FA will be up and running, adding that extra layer of security to your account!

Flowfuse: Two Factor Authentication

Granular Role-Based Access Management

With collaboration at its core, FlowFuse allows you to create teams and invite members to collaborate on projects. However, not all team members require access to every feature. Effective management is essential, as some members might feel overwhelmed by unnecessary options, and there's a risk of accidental changes being made by those who are unfamiliar with the configurations and settings.

To address this, FlowFuse offers Role-Based Access Control (RBAC). When inviting team members, you can assign specific roles that provide the appropriate level of access for their work:

Owner: Has full control over the team settings, applications, instances, and flows. Can invite users and change their roles.
Member: Can access applications and instances and modify flows, but with limited permissions compared to the Owner. Cannot manage team, application, or instance settings or invite users.
Viewer: Can view instances and flows but cannot make any changes. Ideal for users who need to monitor without editing capabilities.
Dashboard Only: Restricted to accessing the dashboard or HTTP endpoint. This role is for users who only need to monitor status without making any changes.

Flowfuse: Role Base Accesss control

Additionally, you can later change the roles of team members in the "members" page. This helps prevent unauthorized changes and ensures a more secure and efficient workflow.

Comprehensive Activity Audit Logs

Today, many organizations prioritize a culture of openness and transparency, but security remains a top concern. Our Audit Logs feature supports this dual focus by maintaining a comprehensive record of all actions in the platform. These logs detail who made changes, what was changed, and when it occurred, ensuring accountability and enabling teams to quickly identify any unauthorized access or mistakes that could jeopardize security.

We provide audit logs at three different levels: instance level, where all action logs related to a specific instance are recorded; application level, which groups logs from instances created within a particular application; and team level, where all platform activities are documented but visible only to admins. This layered approach helps organizations maintain secure workflows and demonstrates their commitment to transparency, ensuring that security concerns are effectively addressed without sacrificing openness.

To access the audit logs:

For instance-level logs, choose the specific instance you want to see and go to Audit Logs.

FlowFuse: Instance-level Audit Logs

For application-level logs, select the application you want to view and navigate to Audit Logs.

Flowfuse: Application-level Audit Logs

For team-level logs, there will be an option labeled "Audit Logs" in the left sidebar, accessible only to admins.

Flowfuse: Team-level Audit Logs

For more information refer to the Documentation

Instance Protection Mode

Imagine your Node-RED application running smoothly on the production line, seamlessly handling critical tasks and data flows. Now, picture the chaos that could ensue if someone from your team accidentally modified a flow. While we offer the snapshot feature to recover previous changes, accidental modifications may not be identified quickly. Even when they are discovered, and the snapshot is used to restore the previous state, it can still take seconds or even minutes to recover, resulting in costly downtime.

To prevent such scenarios, we provide a feature called Instance Protection Mode. This mode allows you to set flows within your Node-RED instances to read-only, ensuring that modifications can only occur through a DevOps pipeline. This process guarantees that even the most critical flows can only be altered with thorough testing and approval.

Flowfuse: Option to Enable the Instance Protection Mode

With Instance Protection Mode activated, team members can still view flows, but any attempts to modify them are blocked, providing an additional layer of security. This approach protects the integrity of your applications and fosters a controlled environment for making changes safely.

Secure HTTP Nodes Endpoints

HTTP is one of the most widely used protocols for enabling communication between different applications and services. In Node-RED, you can quickly create these APIs using HTTP-In nodes, which allow for communication. However, while this convenience is excellent, ensuring that only authorized users can access your APIs is essential.

FlowFuse provides robust options for securing all HTTP endpoints served by Flow and the Node-RED Dashboard. To manage this, each instance has a dedicated interface that you can access by navigating to your instance -> Settings -> Security. Here, you’ll find several options for securing your APIs:

Flowfuse: Options to enable authentication for the HTTP endpoints created in the Node-RED instance.

None (Default): No authentication is enabled by default, which means anyone can access your endpoints.
Basic Authentication: By selecting this option, two input fields will appear where you can enter a username and password. This ensures that only users with the correct credentials can access your APIs.
FlowFuse User Authentication: This option allows all team members to use their unique usernames and passwords when requesting API.
Bearer Tokens: For more advanced users, there’s an option to generate bearer tokens for secure API access without needing to send usernames and passwords. With this feature, you can also set expiration times for these tokens, ensuring that access is time-limited and reducing the risk of unauthorized use. To use bearer tokens, you must first enable FlowFuse User Authentication.

For more information, refer to HTTP Authentication in Node-RED with FlowFuse.

With these features, FlowFuse gives you complete control over who can access your APIs created in the Node-RED instance.

API Token Management for Secure Platform Interactions

We understand that organizations need to create integrations for automation, monitoring, and efficient workflows. FlowFuse provides REST APIs that allow easy interaction with various platform parts, including users, instances, teams, devices, and more. However, security settings are protected to ensure they can only be updated by admins or authorized team members directly on the platform, not via APIs.

FlowFuse: Interface for generating bearer tokens to ensure secure interactions with the platform APIs.

Protecting against unauthorized access is crucial, especially since you control and monitor your entire factory and production lines through this platform. To safeguard this, we offer an interface similar to the one used for bearer tokens. You can access this by navigating to User Settings > Security > Tokens.

For more information, refer to the FlowFuse Platform API docs.

Software Bills of Materials

Node-RED is an open-source platform maintained by dedicated community members who ensure it operates smoothly and remains free of security vulnerabilities. Similarly, there exists a vast ecosystem of open-source packages, nodes, and libraries that we frequently use in our projects. While these packages are often excellent and enhance our capabilities, some may need a regular team or individual to update and monitor them. This can lead to potential risks, as outdated or unmaintained packages can introduce vulnerabilities into our applications.

To address these concerns, we recently introduced the Software Bill of Materials (SBOM) feature, which adds an extra layer of security and compliance. An SBOM is a detailed list of all an application's components. It provides a comprehensive view of all third-party libraries used in each application instance and their latest versions. This allows teams to monitor dependencies and make informed decisions about upgrades, ensuring effective dependency management and enhanced resilience against security threats.

FlowFuse: Software Bills of Materials Inteface

For more information, refer to the Article on FlowFuse Software Bills of Materials.

In conclusion, FlowFuse offers a comprehensive suite of security features designed to empower you with the tools to protect your Node-RED applications effectively. Understanding and utilizing these security features will help you maintain a secure and efficient environment for your Node-RED applications. With FlowFuse, you can confidently safeguard your deployments, ensuring robust protection against unauthorized access while enhancing collaboration within your team.

Get Started with FlowFuse Today!

Ready to secure and scale your Node-RED applications?

Transform Chaos into Control: Centralize Node-RED Management with FlowFuse

2024-10-18T00:00:00Z

Managing a single Node-RED instance involves setting up and configuring a server, securely tunneling for remote access to edge devices, and ensuring proper networking and firewall configurations, all of which can be complex. The complexity increases when overseeing multiple Node-RED instances spread across various projects, edge devices, or environments.

This situation brings additional challenges that can make management a really difficult task, often leading to confusion and frustration as teams try to keep everything running smoothly, troubleshoot issues, and ensure clear communication between instances. Consolidating control into a single platform simplifies deployment, configuration, collaboration, and oversight, making it easier to manage multiple Node-RED instances. Let’s explore how FlowFuse can centralize this management.

What is a Node-RED Instance?

A Node-RED instance refers to a single, operational setup of the Node-RED application. Whether you start Node-RED on your computer, a cloud server, or an edge device, you create an instance. Each instance operates independently, allowing you to build and run automation flows or applications.

What are the Challenges of Managing Multiple Node-RED Instances?

Managing multiple Node-RED instances can quickly become complicated as operations grow. Each new instance adds complexity, from configuration issues to security concerns. These challenges highlight the need for a centralized solution to simplify management and improve efficiency.

Deployment and Configuration Management: Setting up Node-RED instances on a server requires technical knowledge and ongoing maintenance. As the number of instances grows, maintaining them can become time-consuming and resource-intensive.
Egde Node-RED Management: Managing Node-RED instances on edge devices introduces additional challenges, such as the need for on-site troubleshooting when issues arise.
Monitoring and Troubleshooting: Keeping track of the health and performance of multiple instances requires constant attention. Checking logs across different instances can become overwhelming.
Security Management: Each instance requires its own security settings. Ensuring that all instances are secure and up to date can be a difficult task, especially as the number of instances increases.
Backup and Recovery: Having a solid backup and recovery plan is critical. If a system crashes, you need a way to quickly restore it without losing important data.
Scaling: As applications grow in complexity, scaling Node-RED instances becomes necessary. This requires expertise in server management and the ability to handle multiple instances efficiently.
Ensuring High Availability: In production environments, keeping all Node-RED instances running smoothly and avoiding downtime is essential which also requires high technical exepertise

A centralized platform is essential to handle deployment, configuration, and management efficiently, providing a visual interface to maintain and update instances.

"As organizations navigate the complexities of the digital age, adopting a holistic approach that integrates technology, processes, and people is essential for reaping the full benefits of IoT."

FlowFuse: Centralize Your Node-RED and IoT Device Management

FlowFuse is a powerful platform designed to simplify the management of multiple Node-RED instances. By providing a centralized interface, FlowFuse enables users to manage, scale, secure, and collaborate on Node-RED solutions.

Image showing how multiple Node-RED instances are organized and managed under one roof.

With FlowFuse, you can organize your Node-RED instances into teams for improved collaboration, allowing seamless teamwork on projects without the need to navigate between different instance locations physically. You can create as many teams as needed, ensuring that instances are organized based on the team members assigned to them. Additionally, you can ensure that each member has the correct permissions they require through role-based access control (RBAC), providing precise management of access and responsibilities.

Image showing how FlowFuse's immersive editor simplifies managing settings and configuration within the Node-RED editor.

FlowFuse also simplifies the monitoring and controlling of edge devices through the FlowFuse Device Agent, which quickly connects your devices to the cloud platform and allows you to build and monitor applications remotely.

Image showing remote edge devices connected through the FlowFuse platform for remote monitoring and control.

Additionally, FlowFuse enables the creation of DevOps pipelines that ensure your application is well-tested and evaluated before deployment to production. Deploying the same flow to hundreds or thousands of devices becomes effortless with these pipelines.

Image showing feature to create the devops pipeline for Node-RED instances

You can efficiently monitor logs for each instance and receive instant email alerts if any crashes occur, facilitating quick troubleshooting.

Image showing the Node-RED instance logs.

FlowFuse also allows you to quickly add high availability features to your instances, ensuring smooth and efficient operation of your production applications. The platform includes an auto-snapshot feature that lets you recover from accidental changes to flows, ensuring you always have a backup of your application.

Image showing the feature that allows to enable high availability for instances

Image showing snapshots feature

We have highlighted just a few features of FlowFuse; there are many more—potentially three to four times what has been presented—and the team is continuously working to develop and introduce new functionalities to improve collaboration, scalability, security, and overall performance.

How FlowFuse Transforms Production Operations

In manufacturing, downtime is costly, and managing machines, sensors, and systems across multiple sites can be complex. FlowFuse simplifies this by centralizing management, giving you a single platform to oversee all your Node-RED instances efficiently.

With its intuitive interface, FlowFuse handles deployments, updates, and real-time monitoring, ensuring smooth production. It collects data from hardware, APIs, and services using a drag-and-drop interface, enabling teams to easily connect, transform, and analyze data. The high-availability feature ensures critical operations continue even during failures, minimizing downtime.

FlowFuse also enhances security with advanced settings, keeping your systems safe while boosting collaboration. As operations grow, FlowFuse scales seamlessly, integrating new devices and systems without added complexity.

By simplifying system management, FlowFuse cuts costs, keeps production running smoothly, and lets your team focus on growth and innovation.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

Conclusion

FlowFuse transforms how you manage Node-RED instances, turning chaos into clarity. With centralized control, teams can collaborate and reduce operational costs while ensuring critical applications remain available and secure. Automated backups and high availability translate to less downtime and more focus on innovation.

FlowFuse's Software bills of material helps enhance Application Security and Management

2024-10-14T00:00:00Z

FlowFuse recently launched Software Bill of Materials (SBoM) for enterprise customers. This powerful tool enhances security and management within projects, particularly in the Node-RED ecosystem. As open-source libraries and software continue to play a pivotal role in the industry, monitoring third-party components used in projects becomes essential. The SBoM enables organizations to track dependencies and identify vulnerabilities, ensuring compliance and mitigating risks.

What is an SBoM, and How Does It Enhance Security?

A Software Bill of Materials (SBoM) is a detailed list of all the components that make up a software application. Just as a bill of materials for a physical product lists every part used in its construction, an SBoM provides a breakdown of all the software libraries, packages, and dependencies in a project.

This transparency is crucial for security, allowing developers and organizations to track what’s inside their software. By knowing precisely what components are in use, you can quickly identify outdated or vulnerable dependencies that may pose security risks. An SBoM helps you monitor third-party nodes, ensuring that any related security issues can be addressed promptly and reducing the chance of vulnerabilities being exploited.

How You Can Use SBoM to Enhance Security in Your Node-RED Applications

Here are some effective strategies for leveraging SBoM in your Node-RED applications:

Regular Monitoring: Frequently review your SBoM to identify outdated or vulnerable packages. Proactive monitoring helps catch potential security threats early.
Timely Upgrades: When you spot vulnerabilities in your packages, prioritize upgrading them. Keeping dependencies up to date is crucial for maintaining security and performance.
Evaluate Third-Party Nodes: Assess the third-party nodes in your application. If any appear unmaintained or outdated, consider alternatives to ensure ongoing security.

By integrating these practices into your workflow, you can effectively manage dependencies and strengthen the security of your Node-RED solutions.

Exploring the FlowFuse SBoM Feature

To support the effective monitoring and assessment of your dependencies, FlowFuse provides a dedicated Software Bill of Materials (SBoM) interface in the platform. For those who may not be familiar, FlowFuse offers a comprehensive platform that enables engineers to effectively build, manage, and secure their applications. By integrating IT and operational technology (OT) environments, FlowFuse streamlines the process of connecting, collecting, transforming, and visualizing industrial data.

Accessing FlowFuse SBoM Interface

The Software Bill of Materials (SBoM) interface is available at the application level. For more information on the application, refer to the Documentation. To access it:

Navigate to your Node-RED application within the FlowFuse platform.

Image showing the 'Applications' option in the FlowFuse platform.

Click the Dependencies option at the top to switch to the SBoM interface.

Image showing the 'Dependencies' option in the FlowFuse platform for the SBoM interface.

Note: This feature is only available for FlowFuse Enterprise customers.

Understanding What the SBoM Interface Shows

Once you navigate the tab, you will see a list of all the packages installed within your Node-RED Cloud instances and devices associated with that application. This includes the package names and versions, the number of devices and instances using each version, and additional details such as the latest available version of each package and the time since its release.

Image showing the Dependencies tab along with the detailed notes of each item displayed.

Incorporating a Software Bill of Materials into your development process not only enhances security but also fosters a culture of accountability and transparency within your team. By understanding your dependencies, you can make informed decisions that protect your applications and ensure compliance with industry standards.

Try FlowFuse today with a free trial! Discover how you can enhance your Node-RED projects and accelerate your production processes.

Dialogs, Customizable Icons and Histograms Now Available in FlowFuse Dashboard

2024-10-11T00:00:00Z

This update introduces new ways to enhance data visualization and customization in your dashboards. With key improvements, including a new chart type, customizable app icon support and a dialog feature for groups, this release helps tailor dashboards for better user interaction and flexibility.

New Chart Type: Histogram

Histograms are an essential tool for data analysis, offering a clear way to visualize distributions. The latest Dashboard update introduces a fully customizable histogram chart type, allowing you to present frequency distributions for your data.

Whether analyzing performance metrics or user activity, histograms can give you a clear view of how data points are distributed across predefined ranges. You can now easily group data and control the range, providing deeper insights at a glance.

Screenshot showing the new Histogram chart type

The real advantage of this new Histogram chart type is that it simplifies the process for you. Just pass in the raw data, and the histogram will automatically organize it into meaningful ranges, then display how often each range occurs. This makes it incredibly easy to extract valuable insights without the need for manual data processing.

You can see an example flow for the Histogram chart type here in our documentation.

Customizable App Icon

Branding is an essential part of any user experience and with this new feature, you can customize your dashboard's app icon. The Node-RED Dashboard 2.0 now allows users to provide their own application icon, which appears in the browser tab and when the dashboard is installed as a Progressive Web App (PWA). This customization helps reinforce your brand, whether you’re developing IoT solutions, monitoring systems or creating dashboards for end-users.

Screenshot showing the customizable app icon in browser and as a PWA

You can configure the icon by navigating to the base UI settings (ui-base) and providing an icon URL.

You can read more about how to use this feature in the App Icon Documentation

Building Dialogs

Organizing data on dashboards has become more efficient with the new "Dialog/Modal" feature. Groups in Dashboard now have a new "Type" property, so they can be rendered inline as before, or instead rendered as a Dialog. The display of the dialog groups can be controlled (opened/closed) via the Control node.

This removes the need for building custom modals and dialogs in a Template node, and makes the entire experience of building your dialogs low-code.

Screenshot showing groups rendered as dialogs in the dashboard

By utilizing groups as dialogs, users can maintain a clean dashboard while still having quick access to detailed data when required.

You can read more about the new property, and see an example flow in the UI Group Documentation

What else is new?

You can find the full 1.18.0 Release Notes here.

Just to highlight a few, particularly valuable, updates and fixes:

UI Chart - Group tooltips for line chart.
UI Button Group
- Show node status
- Add pointerdown/pointerup event handling and fix button theming bug
UI Table - Support key type option for entering fixed strings as item labels
UI Switch - Layout Switching with Dynamic Configuration Support

What's Next?

Work has already begun on the next release, 1.19.0, you can see what items we have queued up here, if you've got any feedback or suggestions, please do let us know, and feel free to open new issues on our GitHub

Exploring Quick Ways to Write Complex Logic in Function Nodes in Node-RED

2024-10-09T00:00:00Z

Node-RED is a powerful tool for building automation flows through its visual interface and low-code nodes. However, there are times when this low-code approach falls short, particularly when you need to implement complex JavaScript logic. That’s where the Function Node comes into play. Many Node-RED developers excel in their domains—such as IoT integration and PLCs—but may lack a strong foundation in JavaScript.

In this guide, I will share strategies for making writing in Function Nodes straightforward and efficient. You’ll learn how to leverage JavaScript's capabilities without needing extensive knowledge, empowering you to handle more complex logic with confidence and ease.

Image showing the function node

What Are Function Nodes and Common Challenges?

Function Nodes in Node-RED allow you to write custom JavaScript for processing messages. While they provide flexibility, many users find it challenging to turn complex business rules into code and manage variables. For more details on the benefits and drawbacks of using Function Nodes, refer to this Article.

Before using Function Nodes, consider if existing low-code nodes can fulfill your needs. Using standard low-code nodes can simplify your approach and enhance collaboration and clarity. If you still feel the need to use Function Nodes, don’t worry, In the following section, we’ll explore straightforward strategies to make working with Function Nodes easier.

Quick Ways to Simplify Writing in Function Nodes

Using Blockly-Based Function Nodes

For users seeking to simplify the process of writing complex logic, Blockly-based Function Nodes serve as a valuable tool within Node-RED. Designed to facilitate JavaScript code generation, Blockly allows you to construct logic visually using a drag-and-drop interface with pre-defined blocks. This makes it easier to translate intricate business rules into functional code. As you build your logic, Blockly automatically generates the corresponding JavaScript.

Before proceeding, make sure you have installed the following Node-RED package via the palette manager:

node-red-contrib-blockly: This package adds the Blockly custom node in your Node-RED sidebar to use.

For the demonstration, let's consider we have an array of temperatures, and we wanted to calculate the Upper Control Limit (UCL) and Lower Control Limit (LCL) to send to different outputs.

Drag the Blockly node onto the canvas and double-click it to open the editor.
Once open, you will see the block categories on the left side, a plain canvas on the right side, and an option to set output and timeout at the bottom. Set the output to 2.
In the left sidebar, you’ll find different categories starting with Node-RED, each containing related operation blocks. For example, in Node-RED, you’ll find blocks to get the value of msg.payload, set msg.payload, and more. In the Math category, there are various blocks for different mathematical operations.
We must first calculate the mean to calculate UCL and LCL. Switch to the Math category and drag the block labeled "sum of the list." Click on the sum in the block to see other options; select "average" from it. Then, in the Node-RED category, find the block labeled "get the msg property from payload" and connect it to the end of the "sum of the list" block. Now, to create a variable to store the mean, switch to the Variables category, click "create variable," and name it mean. Once you make the variable, you’ll get different blocks related to its perform operations on that var, such as setting and changing its value. Drag the block labeled "set to mean" and place it at the start of the "average of list" block.
Next, we know the formulas to calculate UCL and LCL (where we pick z = 3):

UCL = mean + (stdDev * z)
LCL = mean - (stdDev * z)

To calculate the standard deviation, switch to the Math category and drag the "sum of the list" block again. Click on the sum and select the "standard deviation" option. Again, drag the block "get the msg property from payload" and connect it to the end of the standard deviation block. Create a variable called stdDev, drag the "set stdDev to" block, and place it at the start of the "standard deviation of the list" block.
Now, it’s time to calculate UCL and LCL. First, create a variable for UCL and then Drag the "set UCL to" block, then switch to the Math category and drag the "1 + 1" block. Place the mean variable in one of the positions for "1." Drag the same block again and place it in the second position of 1, then switch to Variables again and drag the stdDev variable to replace one of the "1s" in the second 1+1 block, and set the second "1" to 3.
Next, switch to Node-RED and drag the "set msg property payload to" block. Then, drag the UCL from the variable and place it in place of "to." s value, Drag the "send "msg block to output 1". Repeat the same steps for LCL, but make sure that you subtract from the mean (stdDev * z) and set LCL to the payload, returning it to output 2.
Finally, click Done to save it.
Drag the inject node, having set the payload to an array of simulated temperature data, and connect its output to the input of the blockly node,
Then, drag the two debug nodes onto the canvas. Connect one debug node to output 1 of the Blockly node (this will display the UCL) and the other debug node to output 2 (this will display the LCL).
Deploy the flow and click the inject button. You will see both UCL and LCL printed on the debug panel

The final blockly canvas should look like the below image:

Image showing collection of blockly blocks that are calculating UCL and LCL

Using Blockly-based Function Nodes simplifies the creation of complex logic in Node-RED. However, a basic understanding of JavaScript is still beneficial, especially as your logic becomes more complicated. While beginners may appreciate the visual interface initially, it can become confusing when trying to implement more advanced features. Additionally, the Blockly Function Node is a modified version of the original Function Node, which may lead to differences in behavior and functionality. Nevertheless, it remains a valuable node for users looking to simplify writing function logics in Node-RED.

Using FlowFuse Assistant

Image showing the quick function node generation with FlowFuse Assistant

The FlowFuse Assistant is an AI-based plugin integrated into the FlowFuse platform within the Node-RED editor, making it incredibly easy to generate complex functions using prompts.

For this example, let’s use the same logic we demonstrated with Blockly:

Before proceeding, ensure you have updated Node-RED to the latest version on the FlowFuse platform.

Open the Node-RED instance editor on the platform.
Click the magic button in the top right corner.
A popup prompt will appear, asking for your input to generate the function node.
Enter the prompt for your logic. For this example, you can use:

"Generate JavaScript code that takes an array of numbers, calculates the Upper Control Limit (UCL) and Lower Control Limit (LCL), then sends UCL to the first output of the function node and LCL to the second output."
Click "Generate." After 2-3 seconds, the Function Node with the requested JavaScript code will appear directly on your canvas.
To test it, connect an inject node containing an array of simulated temperature data, then drag two debug nodes onto the canvas. Connect one debug node to output 1 of the function node (this will display the UCL) and the other debug node to output 2 (this will display the LCL).
Deploy the flow and click the inject button; both UCL and LCL will be displayed on the debug panel.

Using the FlowFuse Assistant is significantly easier than Blockly, as it streamlines the process and saves you valuable time. You can articulate your goals in plain English or other languages, such as Spanish or Dutch, and the assistant generates your Function Node seamlessly. This allows you to focus more on your project objectives rather than getting bogged down in coding or block arrangements. Additionally, it provides you with the original Function Node, maintaining standard functionality.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

Conclusion

In summary, both Blockly and FlowFuse Assistant simplify writing complex logic in Node-RED, but FlowFuse is easier to use. Blockly’s visual approach can be confusing, while FlowFuse allows you to generate code by stating your goals in plain English or other languages. Although Blockly can be helpful, it often requires JavaScript knowledge. FlowFuse Assistant simplifies the process, allowing you to focus on your project.

Using FlowFuse Project Nodes for Faster and More Efficient Communication

2024-10-07T00:00:00Z

Node-RED is a powerful tool for IoT application development, connecting various services and devices. However, establishing communication between different Node-RED instances—whether for monitoring or control—can be complex. This often requires detailed configurations and protocols like MQTT, HTTP, or CoAP, despite its seamless integration with many protocols.

FlowFuse addresses this challenge with project nodes designed for easy and efficient communication between Node-RED instances. This guide will show you how to use FlowFuse project nodes to enhance communication and integration, complete with practical demonstrations.

What Are FlowFuse Project Nodes?

FlowFuse is a platform that helps manage multiple Node-RED instances in one place. This centralized management makes it easier for teams to collaborate and share resources while simplifying scaling and enhancing project security.

To facilitate communication between these centrally organized instances, FlowFuse introduces specific project nodes that enable easy and secure message exchange without complex setup. Behind the scenes, these project nodes utilize MQTT, ensuring that communication is lightweight and fast.

These project nodes include three main types:

Left :Project-in node, Middle: Project-out node, Right: Project-call node

Project In: Listens for messages being broadcast by other Node-RED instances or for messages sent directly to this instance.
Project Out: Sends messages to other Node-RED instances.
Project Call:Sends messages to other Node-RED instances to trigger specific flows and waits for a response that can be sent using the project out node.

Using FlowFuse Project nodes

In this section, we will explore how to use the FlowFuse project nodes. We’ll begin by explaining the Project In and Project Out nodes, followed by a detailed look at the Project Call node.

Using Project in and out nodes

To demostrate this nodes, we will use an example where a central instance monitors the CPU performance of multiple Node-RED instances every 10 seconds.

Before we start, let’s understand their configurations:

Project In Node

Name: A descriptive label for the node.
Source:
- Receive: Select this option to receive messages sent specifically to this instance.
- Receive Broadcast From: Choose this option to listen for messages broadcast from other instances. A dropdown will include the names of all instances within your team.
Topic: This field allows you to specify a topic, similar to MQTT, to categorize the messages.

Project Out Node

Name: A descriptive label for the node.
Mode:
- Send Specified Project Node: This option allows you to send a specific message or payload to the selected instance. Use this for one-way communication.
- Return Project Link Call: This option sends used to sent response back using a Project Out node project call node.
Target:
- Send Message To Instance: A dropdown to select the instance.
- Broadcast Messages: Option to send messages to all instances.
Topic: This field allows you to specify a topic, similar to MQTT, to categorize the messages.

Example: Monitoring CPU Performance Of Node-RED Instances

Prerequisites

Before we begin, ensure you have installed the following nodes via the Palette Manager:

node-red-contrib-cpu: This node is essential for monitoring CPU performance. Install it on the instances that you want to monitor.
@flowfuse/node-red-dashboard: This node is used for creating a dashboard interface. Install it on the central instance, as we will be visualizing the CPU performance data collected from the monitored instances.

Creating the Flow on the Instances to Monitor

In this section, we will learn how to create a flow that monitors CPU performance and sends data using Project out. We will also discuss how to make this flow reusable, allowing you to apply the same setup across multiple instances without editing the flow each time.

Drag the Inject node onto the canvas and set the repeat interval to "2 seconds". This will trigger the flow after every 2 seconds.
Drag the CPU node onto the canvas. Double-click it to configure, enable the option "Send message for overall usage," and click "Done".
Drag the Change node onto the canvas. Configure it to add metadata, including the instance name, instance ID, using default environment variablesand and the CPU data received from the CPU node.
Drag the Project Out node onto the canvas. Double-click it to set the Mode to "Send to specified project node." For the Target, select "Send message to instance" and choose the name of your centralized instance.
Next, Enter the topic as "cpu-performance".
Connect the output of the Inject node to the input of the CPU node, the output of the CPU node to the input of the Change node, and finally, connect the Change node to the Project Out node.

By utilizing environment variables, this flow becomes reusable, allowing you to copy and paste flow to monitor multple instances.

Receiving Data to Monitor and Visualize

Image: Line chart visualizing CPU performance of all instances.

To receive the CPU data from monitored instances, follow these steps in your centralized Node-RED instance:

Open the editor for your central instance.
Drag the Project In node onto the canvas.
Double-click the Project In node and set the Source to "Listen for broadcast messages from." Select the name of the instances you want to monitor from the dropdown. If you want data from all instances, select "All instances and devices."
Enter the Topic as "cpu-performance" (or the topic you configured in the Project Out nodes).
Drag a ui-chart widget onto the canvas. Set the chart type to "line" and configure the series to msg.payload.
Connect the output of the Project In node to the input of the ui-chart node.
Click the "deploy" button.

Once deployed, open the dashboard to view an interactive live line chart displaying the CPU performance of all monitored devices.

Visualizing Data for Specific Devices

Image: Gauges visualizing the CPU performance of different devices.

To visualize CPU data for specific devices separately, configure the Project In node to "Listen for broadcast messages from" and select the desired instance name that you want to monitor.

In the instance sending the CPU data for monitoring, set the Project Out node to "Broadcast messages." This will send CPU data to all instances within your team, allowing the centralized instance to capture and display the information.

If you prefer not to use broadcasting, configure the Project Out node with specific topics. This will ensure that receiving nodes capture only specific instance data based on the topic. You can then connect these nodes to gauge nodes to distinctly display the CPU performance for each instance.

This example showcases one of many powerful use cases for FlowFuse project nodes. By utilizing these capabilities, you can transform how your Node-RED instances communicate, enabling efficient workflows and innovative solutions.

Using Project Call Nodes

Project Call nodes are ideal for triggering flows deployed on another Node-RED instance and retrieving the final result as a response. While they function similarly to webhooks, they utilize MQTT as their underlying mechanism instead of HTTP. In this section, we will demonstrate the use of a Project Call node through an example of making an on-demand temperature request.

How Project Call Nodes Work

The Project Call node does not operate in isolation; it requires both Project In and Project Out nodes to function properly. The Project Call node triggers the Project In node deployed on the specified target instance, while the Project Out node handles the response. This means the flow that needs to be triggered should start with a Project In node and end with a Project Out node.

Example: On-Demand Temperature Request

In this example, we will trigger a flow on a Raspberry Pi instance that reads the temperature using a DHT11 sensor and sends the response back to the instance where we use the Project Call node.

Before we start, let’s review the configuration options for the Project Call node:

Project Call Node Configuration

Name: A descriptive label for the node.
Timeout: Set the duration to wait for a response before timing out.
Target: Specify the target instance where the flow is deployed.
Topic: This field allows you to specify a topic, similar to MQTT, to categorize the messages.

Prerequisites

Before we begin, ensure you have the following prepared:

node-red-contrib-dht-sensor: Install this node via the palette manager. This node is used to manage the connection to a DHT11 or DHT22 sensor on a Raspberry Pi.
FlowFuse Device Agent Setup: Ensure you have set up and are running the FlowFuse device agent on your Raspberry Pi, and it is connected to the platform.

Developing a Flow to Handle On-Demand Data Requests

Throughout this section, we will explore how to utilize the Project Call node along with Project In and Project Out nodes to trigger a flow that retrieves temperature readings from a Raspberry Pi on demand.

Note: Before proceeding, make sure your device is assigned to an instance. If the device is assigned to an application, you cannot use Project nodes, as they are designed to work with instances.

Copy/download the flow above and import/upload it into your Raspberry Pi Node-RED instance. Ensure you have correctly interfaced the DHT11 sensor with your Raspberry Pi. For more information, refer to our guide on Setting Up Node-RED on Raspberry Pi 4, which explains how to install the device agent on the Raspberry Pi and read temperature data from the DHT11 sensor.
Deploy the flow.

Once you deploy the flow, you will see the temperature data displayed on the Debug panel if everything was done correctly. Now, let’s add the project nodes to trigger the temperature reading flow on demand and retrieve the data accordingly.

Drag the Project In node onto the canvas, double-click on it, and set the source to "Receive messages sent to this instance." Next, enter the topic.
Replace the Inject node with the Project In node.
Next, you can add a Change node to format the data received by the DHT node.
Drag the Project Out node onto the canvas, double-click on it, and set the mode to "Return to project link call."

Once the flow is ready, deploy it. The final flow should look like the one below:

Now that we have added the Project In and Project Out nodes, the flow can be triggered to read the temperature from any Node-RED instance within your team using the Project Call node and receive the response.

Triggering the Flow and Receiving Temperature Data

In this section, we will explore how to trigger the flow we created in the previous step and receive the on-demand temperature data.

Navigate to the instance within your team where you want to receive the data.
Drag the Project Call node onto the canvas. Double-click it to set the timeout according to your preference, then set the target to the instance where your flow needs to be triggered. Next, enter the topic you configured in the Project In node previously.
Drag an Inject node onto the canvas and connect it to the input of the Project Call node. This will allow you to trigger the Project Call node manually.
Finally, drag a Debug node onto the canvas and connect it to the output of the Project Call node. This will help you view the response received from the triggered flow in the Debug panel.
Deploy the flow.

Now, once you click the Inject button, you will see the response that includes the temperature in the debug panel, which is read by the flow deployed on the Raspberry Pi.

Image showing the project call node triggering the flow deployed on the device to read the temperature data.

Now that you understand how to use FlowFuse project nodes, you can significantly improve the way your Node-RED instances communicate with one another.

Conclusion

FlowFuse project nodes streamline communication between Node-RED instances. By using these nodes, you can easily monitor performance, request data, and more. This makes your workflows smoother and more efficient.

Streamline communication between your Node-RED instances—manage, scale, and secure them with ease to enhance industrial efficiency.

Creating and Automating DevOps Pipelines for Node-RED in Industrial Environments

2024-10-03T00:00:00Z

When deploying any update in your manufacturing or automotive process, it is important to perform testing and validation. The smallest errors can lead to a production outage. In such cases, having a quick and reliable deployment process is essential for maximising uptime and minimising downtime.

For developers using Node-RED, setting up a comprehensive DevOps pipeline can make all the difference. In this blog, we’ll explore how to build and automate DevOps pipelines specifically for Node-RED deployments. You’ll discover practical tips and tools to streamline your process, ensuring your applications are always ready to support your operations.

What Exactly is a DevOps Pipeline?

The DevOps Lifecycle illustrating the stages of development through to production

A DevOps pipeline is an process that helps developers move their code from development to production smoothly. In a pipeline, each step depends on the one before it, ensuring every update is properly tested and ready for use. The most common stages of a pipeline are:

Development: This is where the application flows are created. A level of testing and checking is carried out as a natural step of the development.
Staging/Testing: In this stage, the code is deployed to a staging environment that closely mimics the live system. Here, the application goes through a level of QA and is tested in scenarios as close to real-world conditions as possible. This is stage designed to catch any issues that slipped through in the development stage.
Production: When the flows are tested and confirmed in staging and are ready to be deployed, this stage can be operated to promote the flows to production.

How to Create DevOps Pipelines for Node-RED Deployments

Creating DevOps pipelines manually for your Node-RED deployments can be time-consuming, expensive, and require considerable technical expertise. FlowFuse simplifies the creation of DevOps pipelines for Node-RED deployments.

FlowFuse enhances collaboration, security, and scalability for your Node-RED applications, making the deployment and management of edge devices seamless. With a centralized platform and an intuitive visual interface, FlowFuse allows you to connect, collect, transform, and visualize data effortlessly.

Steps to Create a DevOps Pipeline:

Go to the FlowFuse platform and navigate to the application where your Node-RED instances are located. Ensure you have instances set up for all stages, including production devices or instances.
Switch to the DevOps Pipelines option from the top menu.

Image showing option to switch to DevOps pipelines tab from top menu

Click the Add Pipeline button in the top right corner to create the pipeline.

Click the 'Add Pipeline' button to start creating your DevOps pipeline in FlowFuse

Enter the name for your pipeline and click Create Pipeline.

Fill out the form to give your pipeline a name

Next, you'll see an option to create stages by clicking Add Stage.

Add stages to your pipeline for different deployment environments, such as development, testing, and production

In the window that opens, select the stage type based on whether it's an instance, device, or device group.
Enter the name for the stage in the Stage Name field.
Choose an instance, device, or device group for the stage.
Next, configure which action should be performed when this stage is pushed to the next:
- Create New Snapshot: Generates a new Snapshot using the current flows and settings.
- Use Latest Instance Snapshot: Uses the most recent existing snapshot of the instance. The deployment will fail if no snapshot exists.
- Prompt to Select Snapshot: Prompts at deploy time to select which snapshot from the source stage should be copied to the next stage.
Check the option Deploy to Devices if you want changes to be deployed to all devices connected to this stage’s instance when the stage is deployed.

Configure each stage by selecting an instance, device, or device group, and define the deployment actions

Once you’ve created your initial stage, you can add more stages by following the same process. This flexibility allows you to tailor your DevOps pipeline to meet the specific needs of your Node-RED deployment.

For example, in development, you might have a Node-RED instance in the cloud to build your application. During staging, you could test the setup with a single device. Finally, in production, you can deploy the tested application to thousands of devices in a device group, saving time and ensuring smooth deployment at scale.

Image: DevOps animation demonstrating pipeline deployments.

Running a Pipeline Stage

Once your pipeline is set up, you can run it to deploy your changes across each stage. Here's how:

Click the 'Run Pipeline' button to initiate a pipeline deployment.

Click the "Run Pipeline" button for the current stage to start the deployment. This button is available for all stages except the last one.
After clicking, the deployment automatically progresses to the next stage on the right. Since each pair of stages operates independently, you need to click the "Run" button for each stage to continue the deployment.

Pressing the "Run Pipeline" button for the current stage creates a new snapshot that includes all settings, environment variables, and flows for that stage. This snapshot is then copied and deployed to the next stage, but any existing environment variable keys in the target stage will remain unchanged.

When creating a pipeline, you can include only one Device Group, and it must be in the final stage. This ensures all changes are fully tested and verified before reaching production, guaranteeing a safe and reliable deployment.

Conclusion

DevOps pipelines formalize deployment patterns, standardize testing, and streamline updates, minimizing errors and downtime. This clear process improves reliability and helps organizations adapt more easily thus ensuring smooth operation of critical applications in manufacturing and automotive environments.

Want to learn how FlowFuse can help you scale, manage, and optimize your industrial processes?

Let’s Walk You Through It – Book a Demo Today

Using Snapshots for Version Control in Node-RED with FlowFuse

2024-09-26T00:00:00Z

Version control is essential, especially when multiple people are working on the same Node-RED project. Without it, changes can easily overlap, or worse — accidental updates could break critical flows. FlowFuse solves this challenge with snapshots, allowing you to create backups of your flows, restore previous versions, and safeguard your project from unexpected issues.

Let's look at how to use snapshots in FlowFuse to manage your Node-RED projects with confidence and prevent costly mistakes.

What is Version Control and Snapshots

Using version control for Node-RED flows can introduce complexity and effort, as it often requires frequent pushes of changes to keep everything in sync. This is especially challenging in environments where modifications occur rapidly and continuously.

Snapshots simplify this process by providing point-in-time backups of your flows. In the context of Node-RED, snapshots automatically capture the state of your work, ensuring that you can quickly restore them if needed. It captures the following:

Flows: The flow, including all nodes and config nodes of your Node-RED flows.
Credentials: Any sensitive information used within flows using config nodes.
Environment Variables: Environment variables you have used or defined within that Node-RED instance.
Packages: The packages you have installed, including 3rd party contribution nodes and Node.js packages.
Runtime Settings: The configurations that govern the behavior of your Node-RED runtime.

With snapshots in FlowFuse, you can focus on developing your projects while having the confidence that your work is protected.

Managing Snapshots in FlowFuse

Creating snapshots in FlowFuse is straightforward and can be done in just a few steps.

Creating Snapshots for Cloud and Device Instances

Before we begin, it’s essential to understand the differences between a cloud instance and a device instance. For more information, refer to the Documentation.

Additionally, let’s discuss the two types of device assignments available in FlowFuse:

Application Device
- When a device is assigned to an instance, it can be considered as a mirror of the instance. In Fleet mode, it downloads and runs the target snapshot.
Instance Device
- When a device is assigned to an application, it can be considered as a standalone entity.

With that in mind, taking snapshots for an Application Device is a bit different from taking a snapshot for an Instance Device. For example, taking snapshots of an Application Device will have the same user experience as taking a snapshot of a cloud instance. However, since an Instance Device is typically closely coupled with the owner instance, there is a slightly different procedure. We will cover both below.

Creating Snapshots for Cloud Instance and Application Device

Image showing the "Instances" option in the sidebar

Image showing the "Devices" option in the sidebar

Log in to your FlowFuse account and navigate to the instances by clicking on "Instances" in the sidebar, or if you want to create a snapshot for an Application Device, click on "Devices."
Click on the instance or device you want to create a snapshot for. This will take you to the management interface, which includes different tabs for various settings.

Image showing the option to switch to the Snapshots tab in FlowFuse Cloud Instance.

Image showing the option to switch to the Snapshots tab in FlowFuse Application Device.

Switch to the “Snapshots” tab by selecting it from the instance management options. Here, you will find options to create a new snapshot called "Create Snapshot".

Image showing the button to create a snapshot in FlowFuse.

Click on the button to create snapshot. You will be prompted to enter a name and description for the snapshot, helping you identify it later. There’s also an option to set this snapshot as Device Target Snapshot — enable this checkbox if needed.

Image showing the form to provide a name and description for the snapshot.

After creating the snapshot, you will receive a confirmation message indicating that the snapshot has been successfully created.

Image showing a list of created snapshots with details in FlowFuse.

Once a snapshot is created, it will be visible in a list format. Each snapshot will display details such as the name, description, creator, and creation date, along with a three-dot icon.

Image showing available options for managing snapshots in FlowFuse.

Clicking on the icon will open different options to manage and operate the snapshot.

Creating Snapshot for Device Instances when assigned to Cloud Instance

If the device is in fleet mode, it will be running the flows specified by the target snapshot, and there is typically no need to create a snapshot directly from the device. However, if the device is in developer mode, it may have been modified and may have different flows than those in the instances. In this case, you can take a snapshot directly from the device using the Developer Mode tab. Here’s how to do it:

Go to Devices by clicking on the Devices option in the sidebar, and then click on the specific device.
Once clicked, a similar interface will open as with instances, allowing you to manage and monitor its settings and configuration. Ensure that the device has developer mode enabled.

Image showing the 'Create Snapshot' option in the Developer mode tab

Switch to the Developer Mode tab by clicking on the Developer Mode option at the top. In the Developer Mode section, you will see the Create Snapshot button. Click on it to create a snapshot, then enter the details such as the name and description. If needed, set it as the device target snapshot, and then click Create.

Viewing and Comparing Snapshots

In the Snapshots tab, you can view all snapshots associated with your instance. FlowFuse also allows you to compare two snapshots, enabling you to track changes between different versions of your flows. This is especially useful for identifying specific changes that may have caused issues or to review the progress over time.

Viewing a Snapshot:

Image showing the 'View Snapshot' option in the menu

Click on the three-dot icon next to the corresponding snapshot you want to view, then select View Snapshot from the menu.

Image showing the snapshot view window in FlowFuse.

After clicking, a new window will open displaying the entire flow for that snapshot. At the bottom right of this window, you'll find options to copy or download the flow.

Comparing Snapshots:

If you have multiple snapshots and want to compare them, follow these steps:

Image showing the 'Compare Snapshot' option in the menu

Click on the three-dot icon next to the snapshot you want to compare, then choose Compare Snapshot.

Image showing the comparison window in FlowFuse, featuring a dropdown to select the instance to compare and a compare button

In the newly opened window, select another snapshot from the dropdown to compare it with the one you chose.

Image showing the comparison window for snapshots in FlowFuse.

The flows of both snapshots will be displayed side by side. At the top-right corner of the window, you will see two buttons, Use according to your preference:
- Prev: Navigate to the previous difference between the two snapshots.
- Next: Navigate to the next difference.

This comparison feature helps you easily identify changes, making it simple to spot issues or track flow modifications between versions.

Downloading, Uploading, and Deploying Snapshots

Created snapshots can be downloaded locally, providing you with a backup of your Node-RED flows. This backup can be uploaded to another instance or restored in case of emergencies.

Downloading Snapshot:

Image showing the 'Download Snapshot' option in the menu

Click on the three-dot icon next to the corresponding snapshot, then select Download Snapshot from the menu.

Image showing the prompt to download a snapshot in FlowFuse, featuring a highlighted key and the download button

A Download Snapshot dialog will open. Note: If the flows contain sensitive values, an additional field for secret key will be displayed. This is used to encrypt the sensitive values in the snapshot. As a convenience, a random secret is auto generated however you should change this to something memorable as it will be needed when you later upload the snapshot.
Next, click the Download button located at the bottom right of the prompt to download the snapshot.

Uploading Snapshots:

Image showing the button to upload a snapshot in FlowFuse.

In the Snapshots tab, click the Upload Snapshot button at the top-right corner.

Image showing the prompt to upload a snapshot in FlowFuse.

Select the snapshot file from your local system. If a secret key was provided during the snapshot download, enter it. Otherwise, you will not be prompted for a key.
Click Upload to restore the snapshot to the desired instance.

With this process, you can easily manage your snapshots across different environments, ensuring the safety and portability of your Node-RED flows.

Deploying Snapshots

Once you have learned how to download and upload snapshots, deploying them is quite straightforward.

To deploy a snapshot:

Image showing the 'Deploy Snapshot' option in the menu

Click on the three-dot icon next to the corresponding snapshot and select Deploy Snapshot from the menu.
Next, you will be prompted to confirm the deployment. Review the details to ensure you are deploying the correct snapshot.
Click Confirm to proceed with the deployment.

Upon successful deployment, the instance will restart with the state captured in the snapshot. This includes all flows, credentials, environment variables, NPM packages, and runtime settings as they were at the time of the snapshot. This process allows you to quickly recover from issues or revert to a previously stable state in your Node-RED instance.

Introducing Auto Snapshot

Creating snapshots is crucial for documenting changes, and manually creating them gives users full control over when snapshots are taken. However, manually doing this can be time-consuming, and there is always the risk of forgetting to create one before making changes. To simplify this process, FlowFuse introduces the Auto Snapshot feature.

Auto Snapshots automatically create backups whenever you deploy changes, ensuring that your work is continuously backed up without requiring manual intervention. These snapshots are labeled as "Auto snapshot - yyyy-mm-dd hh:mm:ss" for easy identification.

This feature allows you to focus on developing your Node-RED flows with the assurance that your changes are securely saved. If necessary, you can disable Auto Snapshots for devices only from the Developer Mode tab. This can be helpful to avoid excessive data usage when a device is in the field or on a cellular connection, or to prevent reaching the limit of auto snapshots with unnecessary snapshots.

Disabling Auto Snapshots

Switch to the Developer Mode tab by clicking on the "Developer Mode" option at the top.

Image showing option to enable/disable auto-snapshots for devices

Once inside the Developer Mode tab, you will find the option to enable or disable the Auto Snapshot feature.

Note: A limit of 10 auto snapshots is maintained, with the oldest one being deleted when a new one is created. Also this feature is only available to Team and Enterprise users.

Setting a Device Target Snapshot

When you set a device target snapshot, all devices associated with the instance will be restarted and updated to run that specified snapshot. This gives you full control over when devices receive the latest changes from your development instance.

With this feature, you can continue developing and testing your flows in FlowFuse without immediately impacting your devices. Once you're confident the flow is ready, you can push the changes to the devices by setting the target snapshot.

Device target snapshots can be assigned either during the creation of a snapshot or at a later time.

To set the already creted Snapshot as a Device Target Snapshot:

Go to the Snapshots tab and click on the three-dot icon next to the desired snapshot.

Image showing the 'Set as Device Target' option in the menu

Select Set as Device Target from the menu, prompt will open to conform then click on to the "Set Target".

Image showing the green status indicating how many devices have deployed this snapshot option in the menu.

Once done you will be able to see the green mark in that snapshot showing on how much devices it is deployed on.

Common Mistakes to Avoid

Neglecting Regular Backups: Don’t skip those snapshots! Regularly create backups, especially before making significant changes, moving devices through instances or applications, or disabling developer mode. Think of it as your safety net—ensuring you can always bounce back to a stable state if unexpected issues pop up.
Overlooking Auto-Snapshot Limits: Did you know that your auto snapshots have limits? Be mindful of how many you can retain, as older auto snapshots will be automatically deleted. If you have important auto snapshots, either rename them to avoid automatic deletion or download and save them locally to keep them safe. Remember, manually created snapshots have no limits, so take advantage of that!
Secret Key: The secret key used to encrypt your snapshot is crucial for when you later need to upload that snapshot. When downloading snapshots locally, securely store that key. Losing it could mean losing access to your snapshot and your ability to recover your work. Treat it like a password—keep it safe!
Taking a Snapshots of the wrong thing: When a device is owned by an instance it typically runs the same flows however, if a device flows may have been modified directly in developer mode it will have different flows to the instance that owns it. In this case, before you move the device or switch it out of developer mode, it is recommended that you take a snapshot directly from the device itself. Direct device snapshots are performed on the Developer Mode tab of the device.
Deploying Unverified Snapshots: A little caution goes a long way! Always review and verify the details of a snapshot before deploying it. Jumping into deployment without checking can lead to unexpected behavior or the loss of critical configurations. Take the time to ensure everything is in order.

Conclusion

Using snapshots in FlowFuse is an effective way to manage your Node-RED projects with confidence. By regularly creating snapshots, you can ensure that you always have a backup of your work, allowing you to quickly recover from mistakes or accidental changes.

Never lose your work again—keep every flow protected, collaborate effortlessly, and scale your Node-RED projects with confidence.

FlowFuse 2.9: Software Bill of Materials & Public Static Assets

2024-09-26T00:00:00Z

FlowFuse 2.9 bring improvements in application maintenance with the new "Software Bill of Materials" and in building full stack applications, with an iteration on the "Static Asset Service", by providing the option to "share" your assets assets publicly, making them consumable by external services and your Dashboards.

Software Bill of Materials

This release sees the introduction of a new feature for our Enterprise customers, the Software Bill of Materials (SBOM).

This view is available for all of your Applications in FlowFuse, and provides a detailed breakdown of all packages running in your Node-RED instances within your applications, making it easier to trace down out of date packages and keep on top of the security and integrity of your applications.

In the above screenshot, we get a clear picture of the different versions of Node-RED that I'm running, as well as the different packages that are installed in each of my instances. Highlighting in particular that I have some out-of-date versions of @flowfuse/node-red-dashboard.

It's possible to expand the detail for each entry to see which instances are running the respective package, and consequently jump in to update them if appropriate.

Static Assets Service

Last release we published the new "Static Assets Service". This new feature provided an easy way to upload files alongside your Node-RED instances, and make them easily accessible in your Node-RED Editor.

In this new release we've expanded on that feature, now allowing you to make those files publicly accessible via a URL, making them available for consumption in your Dashboards, or wherever else you may want to consume that content.

Your browser does not support the video tag.

This unlocks a new set of possibilities for building full stack applications in FlowFuse, for examples, making it easy to customize branding in your Dashboard to match your company's branding, or to serve up images and other assets to your users.

And Much More...

For a full list of everything that went into our 2.9 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Coming Soon: MQTT Broker

FlowFuse already makes extensive use of MQTT under the covers. It provides the connection for our Project Nodes that make it very simple to move data between your Node-RED instances.

We're now working on opening up the broker to allow teams to connect their MQTT devices to the platform without having to manage their own broker infrastructure.

This feature will allow you to run and manage your own MQTT Clients alongside your Node-RED instances, making it easier to build full-stack IoT applications with FlowFuse.

We do not have a precise release date for this just yet, but we're hoping to having this in for 2.10 or 2.11. Keep an eye out for more information on this in the coming weeks. If this feature is of interest to you, please do reach out and help us shape it to make sure it meets your needs.

Try FlowFuse

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is on our own hosted instance, FlowFuse Cloud.

Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

Upgrading FlowFuse

If you're using FlowFuse Cloud, then there is nothing you need to do - it's already running 2.9, and you may have already been playing with the new features.

If you installed a previous version of FlowFuse and want to upgrade, our documentation provides a guide for upgrading your FlowFuse instance.

If you have an Enterprise license please make sure to review this changelog entry

Getting help

Please check FlowFuse's documentation as the answers to many questions are covered there. Additionally you can go to the community forum if you have any feedback or feature requests.

How to Scrape Data from Websites Using Node-RED

2024-09-16T00:00:00Z

Web scraping has become an indispensable tool for monitoring news, tracking competitors, and gathering insights. In this guide, you'll learn how to harness the power of Node-RED for efficient web scraping, allowing you to extract and manage data from various websites with ease that are not exposed through an API.

What is Web Scraping?

Web scraping is a technique for automatically extracting data from websites. Instead of manually copying information from web pages, web scraping uses tools or scripts to access and retrieve data from the Internet efficiently. This process allows you to quickly gather large volumes of information, which is helpful for tasks such as tracking market trends, aggregating news, or collecting product details. By automating data collection, web scraping helps save time and reduce human error. It enables users to extract and analyze structured data from various sources, making it easier to compile and utilize information for research, business intelligence, or other purposes.

Web scraping can be helpful when APIs are unavailable or do not meet your requirements. It allows you to collect data directly from web pages, which can be beneficial for tasks like competitive analysis, market research, or tracking specific online content.

How Does Web Scraping Works?

Web scraping involves systematically extracting data from websites using automated tools or scripts. The process begins with requesting a specific webpage. The response from the server is the HTML content of the page. This HTML code contains the structured information displayed on the webpage, organized in a format that describes the layout and content.

Once the HTML is received, the next step is parsing it. Parsing involves analyzing the HTML structure to identify and extract the data of interest. This may include navigating through nested elements, locating specific tags, and using selectors to target precise content such as text blocks, images, or links. The extracted data is then processed and stored in a format that suits the user's needs, whether a database, a CSV file, or another format suitable for analysis.

Web scrapping with Node-RED

In this section, we will guide you through the process of scraping data from publicly available websites using Node-RED and demonstrate how to extract data from a website specifically designed for scraping practice. For this example, we will scrape country data from the page at https://www.scrapethissite.com/pages/simple/.

Sending Requests to a Webpage

To start scraping data, follow these steps to send an HTTP GET request to the webpage:

Drag the inject node onto the canvas. This node allows you to manually trigger the HTTP request or set it to fire at specific intervals.
Drag the http request node onto the canvas. Double-click it to configure and set the Method to GET. Enter the webpage URL you want to scrape (e.g., https://www.scrapethissite.com/pages/simple/).
Drag the debug node onto the canvas.
Connect the inject node's output to the input of the http request node and the http request node's output to the input of the debug node.
Click Deploy to save and deploy your flow.

Once deployed, click the inject button. You will see the raw HTML printed in the debug panel.

Parsing and Extracting Data from HTML

Next, we need to process the raw HTML to extract meaningful data. This involves parsing the HTML content and identifying the specific information you want. To do this, first analyze the HTML structure of the webpage by opening the browser’s developer tools (press Ctrl + I or F12) and inspecting the elements to locate where the data is and in which HTML elements it resides.

Analyzing HTML Structure

Begin by analyzing the HTML structure of the webpage. Open your browser’s developer tools (press Ctrl + Shift + c ) and examine the elements to locate where the data resides and which HTML elements contain it. For example, on a page with a list of countries, each with its capital, population, and area, click on one of those countires elements to navigate to its HTML in the developer tools. Identify the selector that can be used to select those elements. On this webpage, the information about countries is contained within an element with the .countries class. You can use this class to extract all the data for the countries.

Image showing the structure of the page and the data which we needed to extract

Using Node-RED to extract data

Drag the html node onto the canvas.
Double-click the html node and enter the selector .countries into the "Selector" field.
Set the output to "only the text of element" and keep other settings default.
Drag the debug node onto the canvas.
Connect the output of the http request node to the input of the html node and the output of the html node to the input of the debug node.
Click Deploy to save and deploy your flow.

When you click the inject button, you will see the array containing the text content from each .countries div. While this data is a good starting point, it has yet to be in a format that is directly useful for analysis. To make the data more helpful, you'll need to transform it into objects with meaningful properties.

Transforming Data into Structured Objects

You can use JavaScript in a Node-RED function node to transform data into structured objects. If you are familiar with JavaScript, this process will be straightforward. However, if you are not, you can use FlowFuse Assistant to generate the necessary function. For more details, refer to our LinkedIn Post for a quick guide. However, in this section, we will use a low-code approach to transform the data.

Drag a Split node onto the canvas and connect it to the HTML node. This Split node will split the input array into individual string messages.
Drag a Change node onto the canvas and connect it to the Split node. Set msg.name to the following JSONata expression to extract the country name:
```
$trim($split(payload, "Capital: ")[0])
```
Set msg.payload to the following Jsonata expression that will extract the capital and population from the string:
```
$split($split(payload, "Capital: ")[1], "Population: ")
```
Drag another Change node onto the canvas and connect it to the previous Change node. Set msg.capital to the following Jsonata expression to trim and extract the value of the capital from the previously split data array:
```
$trim(payload[0])
```
Set msg.payload to the following Jsonata expression to split the remaining string for area extraction:
```
$split(payload[1], "Area (km2): ")
```
Drag another Change node onto the canvas and connect it to the Change node from the previous step. Set msg.population to the following Jsonata expression to trim and convert the population value to a number:
```
$number($trim(payload[0]))
```
Set msg.area to the following Jsonata expression to trim and convert the area value to a number:
```
$number($trim(payload[1]))
```
Drag another Change node onto the canvas and connect it to the last Change node. Set msg.payload to the following JSON object:
```
{
  "name": name,
  "capital": capital,
  "population": population,
  "area": area
}
```
Finally, drag a Join node onto the canvas and connect it to the previous Change node. This Join node will create an array of the objects we have created.

When you click the inject button again, you will see that the data is now structured and formatted. The output will contain objects with properties such as name, capital, population, and area. This data can now be displayed on the FlowFuse dashboard table. For more details, refer to the FlowFuse table widget.

Left side: Image showing the table we created on the FlowFuse dashboard. Right side: The original webpage with countries.

Legal and Ethical Considerations

Web scraping can be a valuable tool for gathering data, but it's crucial to navigate the legal and ethical landscape responsibly. Adhere to websites' terms of service, respect intellectual property and data privacy laws, and avoid actions that could disrupt a site's operation or misuse the scraped data. By staying informed and adhering to best practices, you can harness the power of web scraping tools like Node-RED while remaining ethically and legally compliant.

Conclusion

You’ve now learned to use Node-RED for web scraping, from sending requests and parsing HTML to transforming data into practical formats. This approach streamlines data collection from websites, making it easier to manage and analyze information efficiently.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

How to create and use Subflow in Node-RED

2024-09-13T00:00:00Z

In traditional programming, managing complex and repetitive tasks can quickly lead to a tangled mess of code that’s hard to maintain and update. To tackle this issue, developers use libraries or modules—reusable chunks of code that help organize functionality, minimize duplication, and keep codebases clean and manageable.

Node-RED brings a similar solution to its visual programming environment with Subflows. Imagine Subflows as the visual counterpart to libraries. In this guide, we will explore what Subflows are, how to create them, and how to use them effectively to enhance your Node-RED experience.

What Exactly Are Subflows?

Image showing a Node-RED flow at the top selected for creating a Subflow, and the resulting Subflow at the bottom.

Subflows in Node-RED are a way to group together a set of nodes and reusable flows into a single, reusable node. This helps you manage and organize complex workflows by encapsulating repetitive or complex logic into a modular unit. You can think of Subflows as custom nodes that you create and use within your flows to simplify your design and reduce redundancy.

Creating a Subflow in Node-RED

In this section, we will create a Subflow for a flow that sends requests to an API and returns results. If the request faces an issue, it retries until it reaches the maximum retry limit. Let's assume we need to use this flow in multiple places, for different APIs, each with different retry timeouts. To avoid duplicating the flow logic, we can create a Subflow.

To follow along, import the following flow into your Node-RED instance.

Creating subflow of selection

Image showing process of creating subflow from the selection

Select the flow you want to convert into a Subflow.
Open the main menu by clicking the top-right menu icon, and select "Selection to Subflow" under the Subflows option.

Image showing subflow node added in the node palette

Once selected, the Subflow will be added to the node palette like other nodes. The selected flow will also be converted into a single node representing the Subflow.

Adding Properties to the Subflow

Double-click on the Subflow, then click on "Edit Subflow template".

Editing the Subflow template by clicking on the 'Edit Subflow Template' option.

A new flow tab for the Subflow will open. Click on "Edit Properties" in the top-left corner.

The edit properties button for a Subflow

To add environment properties, click on the "+ add" button located at the bottom-left.

The 'Add' button for adding environment properties for subflow

In the field that opens, give the property a name and set its default value.
Once you have added all your properties, you can view a preview by switching to the "UI PREVIEW" tab.

A preview of the Subflow environment properties

Click "Done" to save.

Setting Added Environment Variables in the Nodes

Now that we have added properties for the Subflow (which are environment variables), we need to use them in the relevant nodes, such as the HTTP request node, which will require an API and the max-retry setting.

Double-click on the HTTP request node, set the environment variable as ${your_env_name} into the URL feild, and click Done to save.

The URL field of an HTTP request node in Node-RED with an environment variable added.

Next, double-click on the switch node named "if max retries," update the hardcoded max retry condition value to the environment variable you set for it, and click Done to save.

The switch node in Node-RED with a max retry condition set using an environment variable.

Managing Subflow Input and Output Ports

As we know, any node in Node-RED requires input and output ports to manage its data flow. Similarly, a Subflow node requires these ports to function correctly. In our Subflow example, it needs to be triggered and therefore requires at least one input port and one or more output ports. Specifically, our Subflow has two outputs: one for successfully fetched data and another to indicate when the maximum retry limit has been exceeded.

In the Subflow tab, at the top, you will see an option for inputs with values 0 and 1. Click on 1 to add an input port (as a any Node-RED node can have only one input port). Once set to 1, you will see an input port added in the Subflow tab. Connect it to the appropriate node; in our example, it should be connected to the first change node.

Option to add input port for subflow

Next, right after the inputs option, you will see an option for outputs. Unlike inputs, you can add as many outputs as you need. Once you've added the outputs, connect them to the appropriate nodes. In our example, the first output should be connected to the first input of both switch nodes.

Option to add output ports for subflow

Adding Status for Subflow Nodes

To effectively manage and monitor the execution of Subflows, you can add status indicators to your Subflow nodes. This allows you to see if the Subflow is functioning correctly and helps in debugging if something goes wrong. To add a status indicator:

In the Subflow flow tab at the top, click on the Status node option to add a status node. This status node can be connected to the Node-RED status node to capture and display all statuses, or you can configure it to use msg.payload.

Option to add status for subflow

In our example, we need two indicators: one to display when the flow is retrying to request and another to indicate that the fetch operation has successfully completed.

Drag two Change nodes onto the Canvas. Connect one Change node to the if success switch node's first output and set the msg.payload to "completed". Connect the other Change node to the if max retries switch node's first output and set its msg.payload to "retrying". Then, connect both Change nodes to the input of the Subflow status node.

Customizing the Appearance of a Subflow Node

Node-RED allows you to customize the appearance of Subflow nodes, including setting the color, icon, port labels, and selecting the category in which it will be visible in the node palette.

In the Subflow flow tab, click on the "Edit Properties" option in the top-left corner and switch to the "Appearance" tab.

Image showing the apperance tab of subflow

Select a category from the available categories or add a new one by clicking on "Add new".
Choose a color for the Subflow node and select an icon.
Provide labels for the ports so that when someone hovers over the Subflow input or output ports, they can quickly understand their purpose.

Adding Documentation for a Subflow Node

Node-RED allows you to add documentation for Subflow nodes, providing guidance on how to use them. This documentation will be rendered in the help sidebar, similar to other nodes.

In the Subflow flow tab, click on the "Edit Properties" option in the top-left corner and switch to the "Description" tab.

Image showing the apperance tab of subflow

Enter the documentation content in markdown format that provides guidance on how to use the Subflow node effectively.
Click Done to save.

Once saved, the documentation will be displayed in the help sidebar when users click on the Subflow node in the Node-RED palette or hover over and select the help option for that node.

Now, just like regular Node-RED nodes, you can effectively use this Subflow node in your projects. With its added documentation, customized appearance, and status indicators, it integrates seamlessly into your Node-RED environment, enhancing both usability and functionality.

Benefits of using subflows.

Modularity: Subflows allow you to group related nodes into a single, reusable unit, making complex flows easier to manage.
Code Reuse: They help avoid duplicating similar logic across different parts of your flow, saving time and effort.
Simplified Design: Subflows can simplify your main flow by hiding complexity within a single node.
Easier Maintenance: Updating a Subflow automatically updates all instances where it is used, making maintenance quicker.

Conclusion

In this guide, we explored the concept of subflows in Node-RED, including their definition and purpose. We walked through the steps to create and configure subflows, demonstrating how to integrate them into your main flow. Additionally, we discussed how to edit and update existing subflows, and provided best practices for managing and organizing them effectively.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

FlowFuse 2.8: Static File Service, LDAP Updates & More

2024-08-29T00:00:00Z

FlowFuse 2.8 sees a new major feature introduced to the platform. The first iteration of the "Static Assets Service" is now available, allowing you to host and serve static files from your FlowFuse instance, giving you easy access to file storage for your applications, and seamless integration of those assets and files within Node-RED.

Static Assets Service

The Static Assets Service allows you to host and serve static files from your FlowFuse instance. This feature is particularly useful for applications that require file storage, such as images, videos, or static data sets.

With the Static Assets Service, you can upload files directly to your FlowFuse instance and access them from your Node-RED flows, like so:

Your browser does not support the video tag.

This is the first step in this new feature set, with more enhancements planned for future releases, whereby you'll also be able to configure access control to public HTTP endpoints for easy access in your Dashboards.

LDAP Service Improvements

Team Membership in FlowFuse can now be automatically managed using LDAP groups. This means that you can now assign roles to LDAP groups, and when a user is added to that group in your LDAP server, they will automatically be assigned the respective role in FlowFuse.

This also extends to the management of FlowFuse Admin users, which was previously only supported for SAML SSO.

The Admin management feature is available for those running self-hosted FlowFuse.

Notifications Improvements

Last release we introduced the Notifications Inbox, and in this release we're starting to expand on the notifications that you wil receive in FlowFuse, starting with alerts when your Node-RED instances and devices crash unexpectedly, and when instances start in "Safe Mode".

Screenshot showing some example notifications to inform users of unexpected crashes

We're also added filters to show "Read" notifications, and grouping together similar notifications so that it's easy to parse if you have many notifications of the same type.

Managing Devices at Scale

As promised in the FlowFuse 2.7 Release, we've expanded the actions you can take when working with many Devices at once, which now includes the ability to move Devices between Applications and Instances.

Screenshot to show the new "Move to Instance" and "Move to Application" bulk actions

Stricter Approach to Expired Licenses

We've made some changes to how FlowFuse handles expired licenses for self-hosted users.

If your license has expired, you will now be unable to access your FlowFuse instance until you renew your license. This is to ensure that you are always using the latest version of FlowFuse and have access to the latest features and security updates.

If you are currently running an older version of FlowFuse with an expired license please contact the Sales team to discuss renewing your license before upgrading to FlowFuse 2.8. You can check your current license on the "Admin Settings" > "Overview" page.

And Much More...

For a full list of everything that went into our 2.8 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try it out

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install using Docker or Kubernetes.

FlowFuse Cloud

The quickest and easiest way to get started with FlowFuse is on our own hosted instance, FlowFuse Cloud: Get started for free now, and you'll have your own Node-RED instances running in the Cloud within minutes.

Upgrading FlowFuse

If you're using FlowFuse Cloud, then there is nothing you need to do - it's already running 2.8, and you may have already been playing with the new features.

If you installed a previous version of FlowFuse and want to upgrade, our documentation provides a guide for upgrading your FlowFuse instance.

If you have an Enterprise license please make sure to review this changelog entry

Getting help

Please check FlowFuse's documentation as the answers to many questions are covered there. Additionally you can go to the community forum if you have any feedback or feature requests.

New Layout, Widget and Gauges Now Available in FlowFuse Dashboard

2024-08-28T00:00:00Z

At FlowFuse, we're constantly evolving to make sure your dashboard experience is seamless and efficient. This month, we're excited to introduce several new features that enhance your interaction with the platform. From organizing your data with Tabs to visualizing critical information with new Gauges, we've got you covered.

New Layout: Tabs

We know that managing multiple data sources and visualizations can get overwhelming. To streamline your workflow, we've introduced a new layout: Tabs.

Tabs allow you to organize your widgets into separate, easily navigable sections, reducing clutter and making it easier to focus on specific datasets. Whether you're monitoring system performance, tracking KPIs, or managing IoT devices, Tabs will help you stay organized and efficient.

Screenshot showing a tab layout in Dashboard

Introducing the Number Input widget — a versatile addition that allows users to input numerical values directly into the dashboard. Whether you're setting thresholds, configuring parameters, or simply inputting data, this widget makes it easy to adjust values with precision. It’s ideal for use cases where user interaction with numerical data is required, such as controlling devices or updating settings in real time.

Screenshot showing a number input widget with Dashboard

You can try the Number Input now in our live Dashboard running on FlowFuse

New Gauges

Data visualization is a cornerstone of any effective dashboard. We’re excited to introduce two new gauges designed to provide at-a-glance insights into your key metrics.

Battery Charge

Monitoring battery levels is crucial for applications that rely on mobile or remote devices. Our new Battery Gauge provides a clear visual representation of battery status, allowing you to quickly assess power levels and take action if necessary. It’s perfect for IoT deployments, mobile sensors, or any system where battery life is a key consideration.

Screenshot showing a battery gauge with Dashboard

You can try the Tank Level now in our live Dashboard running on FlowFuse

Tank Level

Managing fluid levels in tanks is a common requirement across industries. The new Tank Level Gauge gives you a straightforward way to monitor liquid or gas levels in real time. Whether you're tracking water in a reservoir, fuel in a tank or any other fluid. this gauge provides the precision and clarity you need to maintain operational efficiency.

Screenshot showing a partially filled tank level gauge with Dashboard

You can try the Tank Level now in our live Dashboard running on FlowFuse

What else is new?

You can find the full 1.15.0 Release Notes here.

Just to highlight a few, particularly valuable, updates and fixes:

UI Switch - Introduced an "Indicator" mode and enhanced memory handling for better performance.
UI Table - Added a "Button" column type for improved interactivity.
UI Button - Color customisation now available, without needing to write overriding CSS.
Dynamic Properties - Added dynamic property support for UI-Text-Input widget.

What's Next?

Work has already begun on the next release, 1.16.0, you can see what items we have queued up here, if you've got any feedback or suggestions, please do let us know, and feel free to open new issues on our GitHub

Using MQTT Sparkplug B with Node-RED

2024-08-22T00:00:00Z

Connected devices can generate a lot of data, but without a standardized format, managing and consuming it can be tricky. MQTT certainly simplifies getting your messages delivered but it does not enforce any structure. This is where MQTT Sparkplug B helps by providing a clear, standardized format for data. In this guide, we’ll show you how to use MQTT Sparkplug B with Node-RED to make managing your device data easier and more organized.

What is MQTT Sparkplug?

Sparkplug B is an open-source specification governed by the Eclipse Foundation Specification Process (EFSP). Its aims include defining an MQTT Topic Namespace and payload format that can be applied generically to the overall IIoT market sector in particular meeting the requirements of real-time SCADA/Control HMI solutions.

Take for example a factory where every machine sends data using different formats and non-standardized topic structures. Parsing this data is certainly possible but it introduces complexity, increases the risk of errors, and complicates maintenance. A consistent format can greatly simplify integration and reduce these challenges.

Manufacturing dashboard monitoring non-standardized data

Sparkplug B simplifies things by standardizing the data format and structure, making it easier to integrate and manage data from different sources.

Manufacturing dashboard effectively monitoring data from devices using MQTT Sparkplug B's standardized data format

Understanding MQTT Sparkplug B Message Types, Payloads, and Topic Structures

Now that we have an overview of Sparkplug B and its role in standardizing data formats, it’s time to dive deeper into how this protocol structures its payloads and topics. Understanding these details will give you insight into how Sparkplug B efficiently manages data in complex industrial environments and will assist you in implementing it effectively in your own projects.

Sparkplug B utilizes Google Protocol Buffers (Protobufs) for encoding its messages. Protobufs offer a compact and fast way to serialize structured data, preserving MQTT's lightweight nature while introducing a robust framework for handling complex data.

Types of Sparkplug B Messages

Sparkplug B defines several message types to handle different aspects of communication:

NBIRTH: Sent by a node when it first connects to the system, announcing its presence and the metrics it will report. This type of message is published when an MQTT Sparkplug Out node or an EoN node connects to the broker.
NDATA: Periodically sent by a node to update the values of its metrics.
NDEATH: Indicates that an MQTT Sparkplug Out node or an EoN node has disconnected or is no longer available.
NCMD: Allows for sending commands to a device for remote control or configuration.
DBIRTH: Sent by a device upon connection to the MQTT broker, usually for initial setup or updates.
DDEATH: Indicates that a device has been removed or is no longer available, complementing NDEATH.

Key Components of a Sparkplug B Payload

When dealing with Sparkplug B messages, such as NBIRTH, NDATA, NDEATH, NCMD, DBIRTH, DDEATH the payloads include several key components.

Timestamp: Every Sparkplug B payload includes a timestamp to record the exact time the data was captured. This is essential for understanding the timing and relevance of the data.
Metrics: Metrics are data points within the payload, crucial for NBIRTH, NDATA, DBIRTH, and DDEATH, messages. Each metric includes:
- Name: The identifier for the metric (e.g., "Temperature").
- Alias: A shorthand identifier for metrics name to reduce the payload size.
- Timestamp: The time when the metric was sampled or updated.
- Datatype: The type of data (e.g., Integer, Float, String).
- Value: The actual data being communicated.
- Flags: Indicators such as is_historical, is_transient, and is_null.
Sequence Number: Each message includes a sequence number that increments with each new message. This helps detect any missing messages and ensures data consistency.

Topic Naming Conventions

To effectively manage and route messages in Sparkplug B, it uses a well-structured topic namespace. This structured approach ensures that messages are organized logically and can be easily identified and processed by different systems

The topic namespace in Sparkplug B follows a specific format:

spBv1.0/[Group ID]/[Message Type]/[EON Node ID]/[Device ID]

[Group ID]: Represents the group or application context.
[Message Type]: Specifies the type of message (e.g., NBIRTH, NDATA).
[EON Node ID]: Identifies the edge node or system.
[Device ID]: Identifies the specific device (if applicable).

Using MQTT Sparkplug with Node-RED

In this section, we'll explore an example where Machine1 on the factory floor sends temperature and humidity data to an MQTT broker. We’ll cover how to integrate MQTT Sparkplug B into Node-RED and demonstrate basic operations such as sending and receiving data using MQTT Sparkplug B and more.

Prerequisite

Before you begin, ensure you have the following:

FlowFuse Account: This will allow you to create and deploy Node-RED instances securely on the cloud with a single click, collaborate on your Node-RED projects with your team, manage and program your edge devices remotely, If you haven’t created an account yet, sign up now.
node-red-contrib-mqtt-sparkplug-plus: Install this Node-RED package for Sparkplug B support via palette manager.
MQTT Broker: An MQTT broker is required to send and receive data between clients. If you do not already have one, FlowFuse offers a built-in MQTT broker service that simplifies the process of using MQTT with Node-RED—no external setup required. To learn how to use the FlowFuse MQTT Broker and create and manage clients, refer to the FlowFuse MQTT documentation.

Configuring Node-RED for MQTT Sparkplug B

Drag any mqtt sparkplug node onto the canvas.
Double-click the mqtt sparkplug node to open the configuration panel.
Click the "+" icon next to the "Broker" field. Enter your MQTT broker's host address (e.g., broker.flowfuse.cloud), specify the port number (e.g., 1883 for unencrypted or 8883 for TLS), and configure the TLS settings if required. Enter the username and password, enter a Client ID, Set the "Keep Alive" interval (default is 60 seconds).
Switch to the Sparkplug tab by clicking the Sparkplug option in the top-right corner.
Enter a name in the "Name" field (this will be the Edge Node ID). Enter the group name in the "Group" field. Select "No" for the compression setting. Enable the "Use Alias for Metrics" option if you prefer not to send the full metric names every time and use aliases instead.
Click "Add" to save the configuration.

Screenshot showing the configuration of Sparkplug broker config node

Sending Data to MQTT with Sparkplug B

Drag the inject node onto the canvas. Set the msg.payload to the metrics you want to send and set the repeat interval according to your preference. This inject node could be any node that triggers the data sending. For testing purpose, you can use the following JSONata expression to simulate temperature and humidly metrics:
```
{
    "metrics": [
        {
            "name": "sensor/temperature",
            "value": $random() * 100
        },
        {
            "name": "sensor/humidity",
            "value": $random() * 100
        }
    ]
}
```
Drag the mqtt sparkplug device node onto the canvas.
Double-click the mqtt sparkplug device node to open the configuration panel. Add the metric names that you will be sending by clicking the bottom-left "Add" button. Ensure that the names match the metric names in the payload you are sending and specify the data types for each metric.

Screenshot showing the Sparkplug Device node configuration and the "Add" button for defining metrics

Switch to the Advanced tab by clicking the "Advanced" option at the top-right.
Enable the "Send Birth Immediately" option. This ensures that a Birth message (DBIRTH) is sent immediately upon deployment and connection to the MQTT broker. Note that enabling this option will send the DBIRTH message when the device node connects, but an NBIRTH message will be sent successful connection of mqtt sparkplug out node if you are using.

Screenshot showing the Sparkplug Device node configuration and the "Add" button for defining metrics

Optionally, enable Store and Forward when not connected to ensure that messages are stored and sent once the connection is re-established. To use this option, make sure you have enabled it in the mqtt sparkplug broker config node and specified the destination.
Connect the inject node's output to the mqtt sparkplug device node's input.
Deploy the flow by clicking the top-right "Deploy" button.

Once you deploy the flow and all devices connect to the MQTT broker, the system automatically send a DBIRTH message as soon as each device within the node connects, signalling that the device is ready for data transmission.

Receiving Data from MQTT with Sparkplug B

Drag the mqtt sparkplug in node onto the canvas.
Double-click the node and configure the broker settings.
Enter the topic in the "Topic" field in the format namespace/group_id/message_type/edge_node_id/[device_id]. Use DDATA for receiving metrics you are sending using device node or a wildcard like spBv1.0/group_id/+/+/[device_id] to listen to all message types from a specific device.
Select the desired "QoS" level.
Drag a debug node onto the canvas.
Connect the mqtt sparkplug in node’s output to the debug node’s input.
Click "Deploy" to save and run the flow.

Now you will be able to see the DBIRTH, and DDATA messages printed on the debug panel.

Sending Commands for devices and EoN nodes

Beyond data exchange, MQTT Sparkplug B allows you to send commands for managing devices and Edge of Network (EoN) nodes, such as initiating a device's rebirth or signalling its death.

Drag inject node onto the canvas.
Set the msg.command in the inject node to the desired command. For instance, you can use the following JSON object to send a command that triggers a device's death:

    {
        "device" : {
            "death" : true
        }
    }

Alternatively, to send a command that triggers a device's rebirth, use:

    {
        "device" : {
            "rebirth" : true
        }
    }

Connect the output of the inject node to the input of the relevant mqtt sparkplug device node.
Deploy the flow by clicking the Deploy button at the top-right of the Node-RED interface.
Click the inject node’s button to send the command.

In this example, we've used an inject node to manually send commands, but you can also trigger these commands based on other inputs or conditions within your flow, such as device status or sensor data. For more information on available commands and advanced configurations, refer to the MQTT Sparkplug nodes documentation.

If you need more flexibility in defining topic names when sending data, you can use the mqtt sparkplug out node. It’s quite similar to the standard mqtt out node but is designed to handle Sparkplug-encoded messages. Below is an example showing how to use the mqtt sparkplug out node with in nodes.

Images of some Sparkplug messages printed on debug panel

Up Next

Using MQTT With Node-RED: This guide provides a basic overview of how to integrate MQTT with Node-RED, offering a foundational understanding for beginners who are just starting with this protocol.
How to Use MQTT With Node-RED: This comprehensive guide delves into the detailed steps and advanced techniques for effectively using MQTT within Node-RED, including practical examples to help you apply these concepts in real-world scenarios.

Enhance your Node-RED experience with FlowFuse! Gain better scalability, streamlined deployments, and improved team collaboration—all while optimizing MQTT Sparkplug B integration for efficient data exchange.

Monitoring and Optimizing Node-RED Flows with Open Telemetry.

2024-08-15T00:00:00Z

Have you ever found yourself frustrated by unexpected delays in your Node-RED flows, wondering where the bottlenecks are hiding? Even small latency issues can have a big impact on your system's performance. That's where Open Telemetry comes in. With its powerful distributed tracing capabilities, you can finally take control and get a clear view of how your flows are performing in real time.

Integrating Open Telemetry with Node-RED allows you to monitor latency across your flows. By implementing distributed tracing, you’ll gain the ability to see exactly where delays occur, helping you optimize performance and ensure your IoT applications run efficiently.

What is Distributed Tracing and How Does Open Telemetry Help?

Distributed tracing is a method used to track and observe the flow of requests through different services within a distributed system. It provides insights into how requests are handled, where delays occur, and how different components interact. By visualizing the path of a request across your system, distributed tracing helps you identify performance bottlenecks and optimize the overall efficiency of your applications.

What is OpenTelemetry?

Open Telemetry is an open-source framework designed to help you monitor and understand your software systems. It collects and organizes data on how your applications perform and behave, allowing you to track requests as they move through various services. Open Telemetry provides a standardized way to gather and analyze telemetry data, including traces, metrics, and logs, to give you a comprehensive view of your system’s performance.

In Node-RED The Open Telemetry module helps track messages by creating "spans" that record details about each message's journey. Every time a message moves from one node to another, a span is created to capture where it came from, where it’s going, and how long it took. These spans are linked together, showing the entire path of the message through the system. This makes it easier to spot slowdowns, fix problems, and improve how data moves through Node-RED. The module also makes sure this tracking information follows the message as it moves across different nodes and external services.

Tracing in Node-RED Flows using Opentelemetry

In a manufacturing plant, Node-RED manages different machines and sensors. Suppose there's a problem with the production line, such as a delay in processing or a GPIO node experiencing issues reading data. With Open Telemetry integrated, you can trace the data flow through the system to see exactly where the issue is happening. This helps you quickly identify whether the problem is with a specific node that is reading the machine data or a delay in data processing, allowing you to fix the issue faster and keep the production line running smoothly.

For demonstration purposes, we will use a flow that simulates sensor reading and data processing. We will monitor this flow using Open Telemetry to track data across the system, identify bottlenecks, and optimize performance.

Deploy the flow above, and you might see a delay in the data shown on the debug panel. For this example, we added a Delay node before the Change node that converts temperature data from Kelvin to Celsius. While this delay is visible here, finding such delays in larger flows with many nodes can be difficult and time-consuming. Open Telemetry makes this easier by giving you detailed traces that show where delays or issues are happening

Prerequisite

Before you start, ensure you have the following:

node-red-contrib-opentelemetry : Install this Node-RED module via the Node-RED Palette Manager.
Open Telemetry exporter: Set up an Open Telemetry exporter to send trace data to a backend. For details on available exporters, visit Open Telemetry Exporters. For this guide, I have set up the Jaeger.

Setting Open Telemetry in Node-RED

Screenshot showing the configuration of opentelmetry node

Drag an OTEL node onto the canvas.
Double-click on the node and set the URL to your exporter endpoint (e.g., http://localhost:4318/v1/traces for a locally running Jaeger exporter). Provide a name for the service according to your preference, and set the Prefix, which will be added to the root Node-RED span name before the initial node name (you can keep it as "Message" if preferred).
In the Ignore field, add the names of nodes you want to exclude from Open Telemetry tracing.
In the Propagate field, add the names of nodes if you want them to forward trace headers to external systems or other nodes in the flow. This ensures that these nodes participate in the distributed trace, allowing the trace context to be maintained across different components.
Set the Timeout to define how long (in seconds) the OTEL node should wait before ending and discarding a message that has not been modified.
Now deploy the flow by clicking on the top-right deploy button.

Once the flow is deployed, Open Telemetry will start collecting and sending trace data to your specified exporter.

Monitoring Performance Using the Exporter Web UI

Now, let's monitor the performance and latency between each node to identify delays. For this section, I am assuming you have Jaeger running as your exporter.

Open the Jaeger web UI in your browser. By default, it will be available at http://localhost:16686/.
Navigate to the "Search" by clicking on the "Search" option at the top.
Select the service name that you configured in the OTEL node from the service field. Once selected, you will see all the traces for each interaction in the flow. You can filter the traces by specific nodes using the operation field.
To monitor and find issues, select the desired trace and click on the "Find Trace" button. Click on the first trace to examine it.

Once the trace opens, you will see the duration taken by each node to process and pass data. Notice the time taken by the delay node, which is 2 seconds, indicating the problem. By clicking on the green line corresponding to this delay node, you can view more detailed information about the trace.

Image showing the tototal duration taken by the flow

Since the issue was identified with the delay node, let's remove that delay node.

After updating the flow, redeploy the flow and check the traces again. You should see that the total time has been reduced significantly, with the overall flow now taking around 8 milliseconds instead of the previous 2 seconds. This demonstrates how Open Telemetry helps in identifying and resolving performance issues in your Node-RED flows.

Image showing the total duration taken by the flow after fixing the issue

Throughout this guide, we’ve interacted with an exporter which is running locally. However, by deploying and setting up your exporter on a server, you can remotely monitor the performance of your Node-RED flows. This setup enables you to oversee your system's performance from anywhere, making it easier to detect and address issues promptly.

Enhancing Monitoring and Optimization with FlowFuse

While OpenTelemetry excels at tracing and optimizing Node-RED flows, FlowFuse offers a powerful solution for managing and monitoring Node-RED instances. It streamlines the creation, deployment, and management of instances, allowing you to deploy your applications with a single click and minimizing deployment complexity and errors.

FlowFuse also boosts collaboration and security through features like team management, role-based access control, multi-factor authentication, and snapshot recovery. These capabilities ensure effective management, secure access, and easy recovery from changes, making FlowFuse an essential tool for optimizing and overseeing your Node-RED deployments.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

Conclusion

Integrating OpenTelemetry with Node-RED enables you to efficiently trace and resolve delays in your flows, ensuring smoother and more efficient operation of your IoT applications. By following the steps outlined in this guide, you can leverage distributed tracing to identify performance bottlenecks and optimize your flows effectively. With OpenTelemetry's detailed insights and FlowFuse's robust features, you'll be well-equipped to maintain peak performance and manage your Node-RED environment seamlessly.

Bridging OPC UA Data to MQTT with Node-RED

2024-08-13T00:00:00Z

Have you ever found yourself trying to connect old industrial systems with new IoT tools? This is a common scenario when trying to digitally transform while setting up your Unified Name Space. Maybe you have machinery that uses OPC UA, but your data is sent through MQTT. How do you make these systems work together smoothly?

In this guide, we'll demonstrate how to use Node-RED to bridge OPC UA data to MQTT. This integration will streamline your data flow and enhance real-time monitoring, helping you modernize your setup and improve communication between systems.

Why Bridge OPC UA to MQTT

Diagram showing the data flow when bridging OPC UA to MQTT to enable communication between non-OPC UA compatible systems and devices.

In modern industrial environments, integrating systems with different communication protocols can be a significant challenge. For example, a CNC machine on the factory floor might use OPC UA, while some cloud solutions, edge devices, and other systems, such as custom ERP solutions and IoT applications, might rely on MQTT protocol. This is where bridging OPC UA to MQTT becomes highly beneficial.

By converting OPC UA data into MQTT messages, you make the data from the CNC machine accessible to a broader range of systems that use MQTT, which is a more universally supported messaging protocol. This bridging solution simplifies the integration process, allowing diverse systems to communicate effectively without needing direct OPC UA support.

Node-RED is perfect for this job. It can connect both OPC UA and MQTT, making it easy to transform and route data between different systems. Its flexibility and support for many protocols make it great for integrating various industrial hardware and software. For more on how Node-RED can improve industrial operations, check out Building on FlowFuse: Remote Device Monitoring.

Bridging OPC UA Data to MQTT with Node-RED

In this section, I'll demonstrate how to bridge OPC UA data to MQTT using Node-RED. We will use simulated OPC UA server data from a CNC machine as an example. The goal is to show how you can efficiently transfer this data to an MQTT broker, making it accessible to various applications and systems.

Prerequisite

OPC UA Server: Make sure you have an OPC UA server configured and running with the necessary data. For this blog, we'll use the Prosys OPC UA Simulation Server, which simulates data from CNC machines designed for testing OPC UA client applications and learning the technology. You can download it from here.
FlowFuse Account: A FlowFuse account lets you quickly create, deploy, and manage Node-RED instances in the cloud. sign up now.
node-red-contrib-opcua: install the node-red contrib package that will enable integration of opcua in Node-RED.
MQTT Broker: We’ll need an MQTT broker for data communication. FlowFuse offers an integrated MQTT Broker Service within Platform for easy setup. For more details, check out FlowFuse's MQTT Broker Announcement.

Retrieving Data from the OPC UA Server

To begin retrieving data from your OPC UA server using Node-RED, follow these steps:

Drag the inject node onto the canvas.
Drag the change node onto the canvas and double-click on the node to open its configuration settings. Set the msg.topic to the node ID and datatype of the property you wish to read.

(Left) Image of the Change node setting the 'msg.topic' to retrieve the cycle time data and (Right) the OPC UA Prosys interface.

Drag the OpcUa-Client node onto the canvas. Double-click on it to open its configuration settings. Click the "+" icon next to the Endpoint field and enter the URL of your running OPC UA server. Configure the security policy and mode according to your server setup. If you use the Prosys OPC UA Simulation Server and have not enabled any security features, you can leave the security policy and mode as "None."

Configuring opc-ua node with the opc ua server endpoint

In the OpcUa-Client node settings, select the action type as "READ." This instructs Node-RED to read data from the OPC UA server.

Configuring OpcUa-Client node to select the read operation

If your OPC UA server uses security features, specify the path to your certificate files in the relevant fields. If no security is configured, this step can be skipped.
Drag the debug node onto the canvas. The output will help you verify the data retrieved from the OPC UA server.
Connect the output of the inject node to the input of the change node and the output of the change node to the input of the OpcUa-Client node. Then, connect the output of the OpcUa-Client node to the input of the debug node. This setup ensures that when the inject node triggers, it sends data to the OpcUa-Client node, and the results are displayed in the Debug node.
Deploy the flow by clicking the "Deploy" button in the top right corner. To test the setup, press the Inject button.

You can follow the same steps to retrieve other property values from the OPC UA server. In this example, we are retrieving four simulated data properties: the cycle time, temperature, and spindle speed of the simulated CNC machine. Your setup might differ depending on the properties and data available on your OPC UA server.

Transforming and Aggregating Data

Once you have successfully retrieved data from your OPC UA server, the next step is to transform and aggregate this data to make it suitable for publishing to an MQTT broker. This demonstration, we will aggregate the retrieved individual property values into a single object. Depending on your specific needs, you might choose to split the object properties and send them separately or perform various calculations and transformations on the data.

Drag the change node onto the canvas.
Double-click on the node and set msg.topic to the name of the property you want to set for the retrieved data. In this context, set msg.topic to 'cycle-time', which will be the key in the object that we will create.

Setting the msg.topic with the change node to retrieve data from the OPC UA server.

Drag the join node onto the canvas. Set the mode to manual, with the option to create msg.payload using the values of msg.topic as keys. Set the count to 3 and ensure that the interval for all of the inject nodes triggering data retrieval is the same. This ensures that the data is collected and aggregated correctly at the same time.
Connect the output of the OpcUa-Client node (which retrieves the data) to the input of the change node. For example, if I have set the change node for the 'cycle-time' data property, connect it to the OpcUa-Client node that retrieves this data.
Connect the output of the change node to the input of the join node.
Repeat this process for all of your data properties.

Sending Data to the MQTT Broker

Now, in this section, we will show you how to send the collected data to an MQTT broker:

Drag the mqtt out node onto the canvas.
Double-click on it and configure it with your MQTT broker details.

Configuring the mqtt out node with broker information

Set the topic for your data in the mqtt out node.
Connect the output of the join node to the input of the mqtt out node.
Deploy the flow. After deploying, you will see the status "connected" with a green dot at the bottom of each node, indicating that you have successfully connected to your MQTT broker.

Image showing the successful bridging of OPC UA data to MQTT

Bridging MQTT Data to OPC UA

In addition to bridging data from OPC UA to MQTT, you might also need to send data from MQTT back to an OPC UA server. This is often required in scenarios where external systems, such as Manufacturing Execution Systems (MES), need to update or control machinery settings.

For example, an MES can send commands or configuration changes via MQTT, which then need to be applied to an OPC UA-controlled machine.

Drag an mqtt in node onto the Node-RED canvas and configure it with your MQTT broker details and the appropriate topic where the MES publishes commands.
Drag the change node onto the canvas, Set the msg.topic to the node ID and datatype of the property you wish to update.
Add an OpcUa-Client node to the canvas and configure it with your OPC UA server. Set the action type to "WRITE" to send the received data.
Connect the output of the mqtt in node to the input of the change node, and the output of the change node to the input of the OpcUa-Client node.

Image showing the successful bridging of OPC UA data to MQTT

Up Next

Using MQTT with Node-RED Learn how to integrate MQTT with Node-RED to enhance your IoT solutions with real-time data messaging.
How to Build an OPC UA Client Dashboard in Node-RED Follow a step-by-step guide to create a comprehensive OPC UA client dashboard in Node-RED for effective monitoring and control.
Building a Secure OPC UA Server in Node-RED Explore best practices for configuring a secure OPC UA server in Node-RED to ensure safe and reliable data exchange.
How to Deploy a Basic OPC UA Server in Node-RED Learn how to quickly deploy a basic OPC UA server in Node-RED for testing and development purposes.
Node-RED as a No-Code EtherNet/IP to S7 Protocol Converter Discover how to use Node-RED to seamlessly convert EtherNet/IP to S7 protocols with Node-RED.

Customise theming in your FlowFuse Dashboard

2024-08-07T00:00:00Z

A recent release of FlowFuse Dashboard (Dashboard 2.0) has taken customization to the next level.

Previously, users enjoyed the flexibility of tweaking navigation sidebars, themes, and group and page padding. With the new update, you can fully personalize the header too, adding unique elements to enhance your dashboard experience and customize your application to your own branding.

In this article, we'll delve into these exciting new features, including theme adjustments, custom styling, and layout modifications, that empower you to tailor your Node-RED Dashboard like never before.

Adding Elements in the Header

To add elements to the header, we can use Teleports within the ui-template node. This allows elements to be seamlessly rendered in specific areas of the dashboard. This method simplifies the process compared to manually positioning items with CSS, which can be complex, time-consuming, and potentially disruptive to other dashboard elements.

Left Side of the Header

To render content on the left side of the header, we can teleport content into the #app-bar-title element, where our page name is displayed.

Image of Dashboard showing the #app-bar-title container

Hiding the Page Name in the Header

Before proceeding, you should hide the page name on the left side of the header by default. This will ensure that when you add elements to the header, they do not clash with the page name.

To hide the page name:

Go to the FlowFuse Dashboard sidebar
Click on to the "Edit settings" option located at the top of the FlowFuse Dashboard sidebar.

Screenshot showing the 'edit setting' option in the dashboard sidebar

Untick the option "Show page name in the header bar". Screenshot showing the 'Show page name in the header bar' option in the dashboard settings

Example: Adding Buttons

Drag a ui-template node onto the Node-RED Editor canvas.
Double-click on it and select the scope to either ui-scope or page-scope. Selecting ui-scope will render this content on all pages. page-scope will just render to a specified page.
Choose the page on which you want to render the buttons if you selected page-scope, or choose correct ui if ui-scope is selected.
Paste the following Vue snippet into the template widget. In this snippet, note how we specify the "to" attribute targeting the #app-bar-title ID in the teleport tag:

<template>
    <!-- Teleport the button to the #app-bar-actions area when mounted -->
    <Teleport v-if="mounted" to="#app-bar-title">
        <v-btn>Button 1</v-btn>
        <v-btn>Button 2</v-btn>
        <v-btn>Button 3</v-btn>
    </Teleport>
</template>

<script>
    export default {
        data() {
            return {
                mounted: false
            }
        },
        mounted() {
            // Set mounted to true when the component is mounted
            this.mounted = true
        }
    }
</script>

Next, you can customize further by adding more buttons or different elements inside the <Teleport> element.

Screenshot of Dashboard showing the added buttons in the header

Example: Adding Logo

If you want to add your brand's logo, you can replace the element inside with an tag. You can do this in the same ui-template widget or in a different ui-template widget:

Drag the ui-template node onto the canvas.
Select the correct scope for that widget to render.
Select the correct page or UI in which you want to render the element.
Paste the same Vue snippet given in the above section into the ui-template widget and replace the code inside with the following element:

<img height="32px" src="https://app.flowfuse.com/ff-logo--wordmark-caps--dark.png"></img>

You can replace the URL with your logo's URL or set it using the msg.payload as shown in examples given documentation.

Screenshot of the Dashboard displaying the added logo in the header

Right Side of the Header

To render elements on the right side of the header, you can use the empty div element having the #app-bar-actions ID, in which we can add elements.

Screenshot of Dashboard showing the #app-bar-actions container

Example: Adding logged in user profile

Screenshot of Dashboard displaying the logged in user profile at the right side of header

In this section, we will add the user profile of the currently logged-in user to the right side of the header. Make sure you have installed "@flowfuse/node-red-dashboard-2-user-addon" via the palette manager and enabled FlowFuse User Authentication. Each message emitted by the FlowFuse Dashboard widget will include the logged-in user information under msg._client.user. Additionally the setup object will also contain this information under setup.socketio.auth.user.

Drag the ui-template widget onto the canvas.
Select the correct scope for that widget to render.
Select the correct page or UI in which you want to render the element.
Paste the same Vue snippet given below into the ui-template widget:

<template>
    <!-- Teleporting user info to #app-bar-actions, which is the ID of the action bars' right corners area -->
    <Teleport v-if="loaded" to="#app-bar-actions">
        <div class="user-info">
            <!-- Displaying user image -->
            <img :src="setup.socketio.auth.user.image" />
            <!-- Greeting the user -->
            <span>Hi, </span>
        </div>
    </Teleport>
</template>

<script>
export default {
    data() {
        return {
            // Flag to indicate if the component is loaded
            loaded: false
        };
    },
    mounted() {
        // This function is called when the component is inserted into the DOM.
        // Setting loaded to true here ensures the component is ready to access #app-bar-actions,
        // as it's now part of the same DOM structure.
        // Accessing it before mounted() would cause an error because the component wouldn't be initialized in the DOM yet.
        this.loaded = true; // Setting loaded to true to indicate that the component has been mounted successfully
    }
}
</script>

<style>
/* Styling for user info display */
.user-info {
    display: flex;
    align-items: center;
    gap: 8px;
}
/* Styling for user avatar image*/
.user-info img {
    width: 24px;
    height: 24px;
}
</style>

For detailed guide on this section, refer to the guide on Displaying logged in user on FlowFuse Dashboard. Furthermore, if you want to add logos or buttons on the right side similar to the left side of the header, you just need to replace the to attribute with the #app-bar-actions.

Centering Header Items

Sometimes you may want to center or position items added to either the #app-bar-title or the #app-bar-actions. By default, these elements do not have a specified width, and when you add items into them, they grow to fit their content. To center the elements, you first need to ensure that they are sized appropriately.

Centering Items in the Left Side of the Header

To center items added to the #app-bar-title, apply the following CSS in the <style> tag of the ui-template widget:

#app-bar-title {
    flex-grow: 1;
    justify-content: center;
}

Centering Items in the Right Side of the Header

To center items in the #app-bar-actions area, add the following CSS to the <style> tag of the ui-template widget:

#v-toolbar__append {
    flex-grow: 1;
}

Styling Header

One of the significant customization features we've added recently is the ability to style the header in different ways.

To style the header:

Go to the FlowFuse Dashboard sidebar
Click on to the "Edit settings" option located at the top of the FlowFuse Dashboard sidebar.

Screenshot showing the 'edit setting' option in the dashboard sidebar

Select the desired option from the "Header Options" dropdown.

Screenshot showing the header style options in the dashboard settings

The following options are available for header styling:

Default

This option as it name suggest it is the default option set for header. In which the header will get hidden if we scrolled down.

Image showing the dashboard with default header

Hidden

Selecting this option completely hides the header, allowing you to use that space for other purposes.

Image showing the dashboard with hidden header

Fixed

Selecting this option keeps the header fixed at the top. This means that when you scroll the page down, the header will remain visible.

Image showing the dashboard with fixed header

Changing Dashboard Theme

In this section of the guide, you will learn how to change the Dashboard theme, where you can adjust the colors of the header, navigation sidebar, group and page backgrounds, the border color of groups, and the padding, sizing, and gaps between pages, groups, and widgets.

To edit the existing theme:

Go to the FlowFuse Dashboard sidebar.
Switch to the "Theme" tab.

Screenshot showing the dashboard theme tab in the sidebar

Click on the edit button next to the theme.
You can adjust the header color and the primary color (which applies to the navigation sidebar and elements like buttons and dropdowns) under the "Primary" section. In the "Pages" section, set the background color for pages, and in the "Groups" section, adjust the background color and border color of groups.

Screenshot showing the theme properties dialog

Under "Sizing," adjust the page padding (the space between dashboard groups), the page border, group gap, group border radius (the thickness of the group border), and widget gap.

For more information on theme, how to add new themes, and set themes for pages, refer to the Comprehensive guide: FlowFuse Dashboard layout, sidebar, and styling. Additionally, this guide covers FlowFuse Dashboard layouts, themes, and custom styling in detail.

Conclusion

In this article, we explored FlowFuse Dashboard's new customization features. We focused on adding elements like buttons and logos to the header, and discussed styling options such as default, hidden, and fixed for headers. We also covered how to adjust dashboard themes to personalize colors and layout. These insights empower users to create more personalized and functional Node-RED dashboards.

Looking to build a multi-user dashboard, deploy it in seconds, scale and manage Node-RED efficiently, and enable seamless remote access for your entire team?

FlowFuse Dashboard vs UI-Builder: A Comprehensive Comparison

2024-08-06T00:00:00Z

When choosing a dashboard solution for Node-RED, two popular options are FlowFuse Dashboard (also known as Dashboard 2.0) and UI-Builder. This article compares these tools across several key areas, including installation, ease of use, development activity, and customizability, to help you decide which one best suits your needs.

How Easy is it to Install?

FlowFuse Dashboard

When searching for flowfuse/node-red-dashboard on Google, the first result we get to the documentation, which is useful. However, in the Node-RED Palette Manager, finding the correct package can be confusing because there are many community third-party nodes and plugins that work with FlowFuse Dashboard. This can make it bit confusing for new users to locate the right package.

UI-Builder

Finding UI-Builder is straightforward, as its package name node-red-contrib-uibuilder is distinct and easily identifiable both on Google and in the Node-RED Palette Manager. This clear naming helps users quickly locate the correct package.

How Easy is it to Get Started?

FlowFuse Dashboard

Getting started with FlowFuse Dashboard is relatively easy due to its low-code approach. It features a sidebar for managing UI widgets, themes, configurations, and settings, with intuitive navigation to the dashboard page. This makes it accessible for users with varying levels of technical expertise.

UI-Builder

UI-Builder can be more challenging to start with, as it does not follow a low-code approach and lacks a separate sidebar for managing UI elements. Navigating dashboards built with UI-Builder can be less straightforward, and it requires users to have a deeper understanding of coding and UI design principles.

Migrating from Node-RED Dashboard (Dashboard 1.0)

Node-RED Dashboard is a module that provides a set of nodes in Node-RED to quickly create user interfaces or live data dashboards. It was developed by one of the creators of Node-RED and is the most used and downloaded package in the Node-RED ecosystem. However, it is now deprecated. For more information, refer to Node-RED Dashboard Formally Deprecated.

FlowFuse Dashboard

FlowFuse Dashboard is developed to replace the the deprecated standard Node-RED Dashboard. It retains the core concepts and UI elements but introduces more advanced options and configurations.

To facilitate the transition, FlowFuse, the creator of FlowFuse Dashboard, provides a migration service that simplifies migration of flows or projects from the Node-RED Dashboard to FlowFuse Dashboard. This service helps ensure a smoother migration process with minimal disruption.

UI-Builder

Migrating from Node-RED Dashboard 1 to UI-Builder is significantly more complex. UI-Builder does not follow the same concepts or provide the same UI elements as the Node-RED Dashboard.

Users will need to recreate their dashboards from scratch, as UI-Builder relies on custom coding and frontend frameworks rather than the predefined, low-code widgets of Node-RED Dashboard. This process can be overwhelming and requires a solid understanding of HTML, CSS and the frontend frameworks if you wanted use.

How Active is the Project's Development?

FlowFuse Dashboard

FlowFuse Dashboard, which replaced Node-RED Dashboard 1.0 in 2023, has shown consistent and high development activity. The project benefits from a dedicated team that regularly updates and improves it, ensuring it remains current with user needs and technological advancements.

Screenshot of the FlowFuse Dashboard GitHub commit chart.

UI-Builder

UI-Builder has been an active project for a long time and remains active. However, there has been a noticeable decline in development activity starting in early 2024. While the project continues to be maintained, it does not have a dedicated, full-time team.

Screenshot of the UI-Builder GitHub commit chart.

Pre-Built UI Elements

FlowFuse Dashboard

FlowFuse Dashboard offers an extensive set of UI elements, including forms, dropdowns, tables, charts, and gauges that are super easy to use. These widgets are built with complex Vue.js components, but users are completely shielded from this complexity, allowing them to focus on ease of use. Additionally, if you want to create your own custom widget, you can do so with the ui-template node that accepts complete Vue components. By default, FlowFuse Dashboard supports the Vuetify library, which provides an extensive set of UI components.

UI-Builder

UI-Builder also offers a number of widgets, but these are not as user-friendly as those in FlowFuse Dashboard. Users must send a JSON config object, which can be complex for new users who lack knowledge of HTML/CSS. Additionally, handling widget data requires using UI-Builder's methods, which can further increase complexity. However, UI-Builder's strength lies in its flexibility, allowing any HTML element to be used as a component, and it also supports the W3C standard web components. Despite this, users need to perform a lot of additional tasks to get everything set up and will have the hassle of writing things.

Changing the UI at Runtime

FlowFuse Dashboard

FlowFuse Dashboard supports dynamic control of the UI via the msg object. Each UI widget supports the msg.ui_update property, which allows you to control and update UI components dynamically. For example, you can update form fields based on user input, dynamically insert or update options in a dropdown, or change the appearance of the UI by sending CSS classes or selecting options in dropdowns or radio buttons through msg.

UI-Builder

UI-Builder also supports dynamic UI updates and control. Similar to FlowFuse Dashboard, you can use messages to control the state and content of UI elements.

Data Visualization

FlowFuse Dashboard

Monitoring devices is one of the core use cases for Node-RED, and FlowFuse Dashboard makes it easy to monitor device metrics with its built-in chart and gauge widgets. The chart widgets support various types, including line, bar, scatter, pie, and donut charts, while the gauge widgets offer options like tile, 3/4 gauge, and half gauge. This range of built-in options simplifies the creation of visualizations for monitoring device metrics. Additionally, you can use Vuetify or other third-party libraries in the ui-template node if you need different types of charts.

UI-Builder

UI-Builder does not provide built-in charting options. However, you can add charts using third-party JavaScript libraries. This approach requires additional effort to integrate and configure the libraries, as well as writing the relevant JavaScript to render the charts. While this increases the complexity of creating visualizations, it offers more control and customization.

Building Layout

FlowFuse Dashboard

FlowFuse Dashboard offers a collection of pre-defined layouts to make it easy for users to get started quickly. These are available as a configuration for each "Page" of your application.

These predefined layouts provide a solid foundation for most applications. If you need a different layout, FlowFuse Dashboard is limited in it's customization in terms of positioning of elements.

UI-Builder

UI-Builder does not come with predefined layouts, which can make it more complex for users to get started. it does however, provides the flexibility to completely define your own layout using CSS. This approach allows for complete customization, but it requires users to have a good understanding of HTML and CSS. The lack of predefined layouts means users have to create their own from scratch, which can be time-consuming.

Responsiveness on Mobile

FlowFuse Dashboard

FlowFuse Dashboard is designed with responsiveness in mind. It ensures that dashboards automatically adapt to different screen sizes and devices, providing a consistent user experience across desktops, tablets, and mobile devices. The dashboard elements are automatically adjusted to fit various resolutions, making it user-friendly for a wide audience.

UI-Builder

UI-Builder's support for different devices depends on the user's implementation. While it offers the potential for responsive designs, achieving this requires a good understanding of responsive design principles and CSS.

How Much Customization is Available?

FlowFuse Dashboard

FlowFuse Dashboard, built on Vue.js, offers a range of customization options through its widget configurations and settings.

While it provides predefined UI elements, users can override CSS and theming using the ui_template widget to enhance the dashboard's appearance.

This same widget also provides functionality to develop custom components or widgets for your Dashboard. These must be built with a VueJS core, but do support the integration of third-party JavaScript libraries.

UI-Builder

UI-Builder provides extensive customization capabilities, enabling users to build and style UI elements from scratch. This flexibility is advantageous for those with a strong background in frontend development, as it supports any frontend framework or custom design approach. However, achieving the desired results requires significant time and expertise, as users need to handle the coding and styling for each UI element they create.

Can it be Installed on Mobile?

FlowFuse Dashboard

FlowFuse Dashboard is built and deployed as a Progressive Web App. This means whilst it's built as a web application, it can be installed on your mobile device and run as a standalone application, behaving as if it was a native app.

Ui-Builder

Dashboards built with UI-Builder, on the other hand, cannot be installed as an app. It is designed as a web-based tool for building custom UIs and does not support installation as a standalone application.

How About Performance and Speed?

FlowFuse Dashboard

FlowFuse Dashboard provides reliable performance with efficient real-time updates. Initial page load times might be slower, particularly on mobile, but the overall performance is consistent and effective for dynamic dashboards.

UI-Builder

UI-Builder provides faster initial load times and smooth performance across customizations, ensuring high-speed interactions.

How is the Overall User Experience?

FlowFuse Dashboard

FlowFuse Dashboard offers a user-friendly experience with its low-code approach, intuitive UI, and extensive documentation. Users can quickly create and customize dashboards without needing advanced coding skills, making it accessible to a wide range of users, from beginners to experienced developers. This allows users to focus on solving business problems and IoT tasks rather than getting bogged down by complex coding requirements.

UI-Builder

UI-Builder provides a more flexible but complex user experience. While it allows for greater customization and the use of any frontend framework, it requires a solid understanding of coding and design principles. This can be daunting for users without a background in web development, but it offers powerful capabilities for those who are comfortable with custom coding.

How Active is the User Community?

FlowFuse Dashboard

FlowFuse Dashboard boasts a large and active user community. Users frequently participate in forums, contribute to discussions, and share custom solutions. The number of weekly downloads is growing rapidly, reflecting its high activity and popularity.

Screenshot of the FlowFuse Dashboard package's weekly download chart from npm

UI-Builder

UI-Builder has a smaller but still active user community. While not as large as FlowFuse Dashboard's, it includes dedicated users who also engage in forums, contribute to discussions, and share their use cases and solutions.

Screenshot of the Ui-Builder package's weekly download chart from npm

How Good is the Support and Documentation?

FlowFuse Dashboard

Support for FlowFuse Dashboard is robust, with assistance from both the FlowFuse team and the active Node-RED community. The documentation is comprehensive, easy to understand, and regularly updated. The team is also working on an interactive dashboard solution for previewing examples.

UI-Builder

UI-Builder also has good support, with active contributions from the author and the Node-RED community. The documentation is detailed but can be complex due to extensive use of technical language.

What are the future development plans?

FlowFuse Dashboard

FlowFuse Dashboard is actively working on enhancing its feature set. With extensive functionality already in place, the project also has ambitious plans to introduce more advanced features to better serve its users. You can track these developments on the FlowFuse Dashboard GitHub project board, where ongoing and upcoming features are documented.

Screenshot of the FlowFuse Dashboard GitHub project board

Additionally, updates about new features and enhancements are also provided through social media, blogs, and the Node-RED forums, ensuring that users stay informed about the latest developments.

UI-Builder

UI-Builder does not have a publicly accessible project roadmap or a dedicated planning board for future updates. While development continues, details about forthcoming features and enhancements are regularly updated on the Node-RED Discourse forums by its author.

Summary Table

Feature	FlowFuse Dashboard	UI-Builder
Ease of Installation	Moderately easy: Search for `flowfuse/node-red-dashboard` can be confusing due to multiple nodes; useful documentation available	Easy: Clear package name `node-red-ui-builder` makes it straightforward to find
Ease of Getting Started	Easy: Low-code interface with a sidebar for managing UI elements; intuitive for users of varying technical skills	Challenging: Requires understanding of coding and UI design; lacks a low-code approach
Migration from Node-RED Dashboard	Smooth: Migration service provided to transition from Node-RED Dashboard 1 to FlowFuse Dashboard	Complex: Requires rebuilding dashboards from scratch; significant effort needed for migration
Development Activity	High: Regular updates and improvements; actively maintained by a dedicated team	Moderate: Active but shows a decline in updates; less frequent enhancements
UI Elements Collection	Extensive: Includes a wide range of widgets like forms, charts, and gauges; built on Vue.js with Vuetify support	Flexible but complex: Allows any HTML element; requires custom coding and handling of UI elements
Visualization	Easy: Built-in charting options for various types; additional options with third-party libraries	Complex: No built-in charts; requires integration of third-party libraries for visualization
Dynamic UI Control	Supported: Can dynamically control and update UI components using `msg.ui_update` property	Supported: Dynamic updates possible, but can be more complex to implement

Web Layout Support	Predefined: Offers three main layouts with some options for custom styling	Customizable: No predefined layouts; users must create their own using CSS
Device and Screen Size Support	Excellent: Responsive design adapts well to various devices and screen sizes	Variable: Responsiveness depends on user's implementation and knowledge of CSS
Customization	Good: Offers customization through widget settings and custom CSS and ui-template; supports Vue components and third-party libraries	High: Full control over UI design and layout with custom coding; requires expertise in frontend development
App Installation	Available: Can be installed as a Progressive Web App (PWA) for use as a standalone application	Not available: Designed as a web-based tool; cannot be installed as an app
Performance and Speed	Reliable: Good performance with consistent updates; may have slower initial load times on mobile	Good: Generally good performance on both desktop and mobile
Support and Documentation	Robust: Comprehensive, regularly updated documentation and active community support	Good: Detailed but may be complex; documentation includes technical jargon
Overall User Experience	User-friendly: Accessible and easy to use with low-code approach; suitable for a wide range of users	Flexible but complex: Offers greater customization but requires coding expertise; can be daunting for non-developers
User Community Activity	Large and active: High engagement in forums and discussions; growing number of downloads	Smaller but dedicated: Active users, but less engagement compared to FlowFuse Dashboard
Future Development Plans	Active: Continuous enhancements and new features planned; updates tracked on GitHub project board	Less transparent: No detailed roadmap; future features are less clearly communicated

Conclusion

FlowFuse Dashboard is well-suited for users seeking a user-friendly, low-code solution with a wide range of pre-built elements and strong community support. Its ease of use and active development make it ideal for quick deployment and minimal technical overhead.

UI-Builder, however, offers nice performance and customization, benefiting users with coding expertise who need highly tailored UIs. Despite its flexibility and faster load times, it requires more complex setup and migration.

Looking to build a multi-user dashboard, deploy it in seconds, scale and manage Node-RED efficiently, and enable seamless remote access for your entire team?

FlowFuse 2.7: Improved management at scale & AI JSON Editor

2024-08-01T00:00:00Z

FlowFuse 2.7 has had a big focus on user experience improvements, particularly centered around teams running at large scales, with over a thousand devices and instances. With this in mind, we've introduced a new search feature that allows you to search across all of your FlowFuse instances, devices and applications from a single place, made it easier to manage your devices with bulk actions, introduced a new notifications inbox to give you a clearer picture on activity across your team, and just for good measure, we've also extended the AI-infused Node-RED experience to the JSON Editor.

FlowFuse Assistant in the JSON Editor

Last release we saw the introduction of the FlowFuse Assistant, and in this release we're rolling this out further to include Node-RED's JSON Editor.

(Left) Screenshot of the AI prompt for a list of 4-legged creatures and (Right) the resulting JSON generated by the FlowFuse Assistant

(Left) Screenshot of the AI prompt input for a list of simulated devices and (Right) the resulting JSON generated by the FlowFuse Assistant

This new feature empowers you to create custom data sets within seconds, meaning you can sketch out Dashboards or test Node-RED flows before connecting to real, production environments.

Managing Resources at Scale

As mentioned in the introduction, a big focus on this release, and moving forward into the next couple too, is around improving the user experience when managing large numbers of devices and instances.

Centralized Search

We have customers with over a thousand devices and instances running in FlowFuse. It can be very difficult to find the resource you're looking for. That's why we've introduced a new search feature that allows you to search across all of your FlowFuse instances, devices and applications from a single place.

Screenshot showing the new Application Search feature in FlowFuse

The search filters as you type, making it easy to find the resource you're looking for. It will keep reference to any applications and or child instances/devices where appropriate too.

Notifications Inbox

Screenshot showing the new Notifications Inbox in FlowFuse

This is a first step in introducing richer notifications across FlowFuse. We've introduced a new notifications inbox that will show you all the activity across your team. Currently, this just shows new team invites, but will soon show instance/device activity that needs your attention and more.

Bulk Device Actions

We've now enabled the ability to perform bulk actions on devices in FlowFuse. This is particularly useful for managing large numbers of devices, where you might want to update the settings, or delete multiple devices at once.

Screenshot showing the new Bulk Device Actions feature in FlowFuse

For now, we just support bulk delete, but we're planning to add more bulk actions in the very near future.

And Much More...

For a full list of everything that went into our 2.7 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try it out

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install using Docker or Kubernetes.

FlowFuse Cloud

Upgrading FlowFuse

If you're using FlowFuse Cloud, then there is nothing you need to do - it's already running 2.7, and you may have already been playing with the new features.

If you installed a previous version of FlowFuse and want to upgrade, our documentation provides a guide for upgrading your FlowFuse instance.

Getting help

Please check FlowFuse's documentation as the answers to many questions are covered there. Additionally you can go to the community forum if you have any feedback or feature requests.

How to Set Up SSO LDAP for Node-RED

2024-07-29T00:00:00Z

A few days ago, we published a blog explaining SSO and how to set up SAML for your self-hosted FlowFuse. Now, in this guide, we will walk you through the process of setting up SSO with LDAP for your self-hosted FlowFuse. We will use OpenLDAP as the provider and cover everything from introducing LDAP, how it works, installing and configuring OpenLDAP, managing users (create, delete, update), and finally setting up FlowFuse for SSO with LDAP.

Understanding LDAP SSO?

What is LDAP

LDAP (Lightweight Directory Access Protocol) is a protocol used to access and manage directory information. In the context of network administration, a directory service acts as a specialized database that stores and organizes information about users, devices, and other resources. Think of it as a digital phonebook for your network, allowing centralized management and efficient access to information.

LDAP enables applications and services to query, add, update, and delete directory entries stored on LDAP servers. It simplifies identity management by enabling easy authentication, authorization, and quick access to information across distributed systems.

How LDAP SSO works

User Authentication Request: A user attempts to access a service or application that requires authentication.
SSO Initiation: The application forwards the authentication request to the Identity Provider (IdP) configured with LDAP, such as OpenLDAP.
LDAP Authentication: The IdP (LDAP server) verifies the user's credentials against its directory.
Authentication Response: If the credentials are valid, the LDAP server sends an authentication response (usually a token or assertion) back to the application.
Access Granted: The application grants access to the user based on the authentication response received from the LDAP server.

Setting up SSO LDAP for FlowFuse

Before we proceed, ensure that FlowFuse is deployed on your server with an Enterprise license and you have ssh connection with it so that you can run commands on the server. If you haven't installed it yet, please check out our documentation on installing FlowFuse or our blog on deploying FlowFuse on Ubuntu with Docker.

Installing and Configuring OpenLDAP

Throughout this section, we will install and configure OpenLDAP on your Ubuntu server. Make sure to replace the commands and configs with your details. If you are using a different distribution, you can follow other resources available on the internet for installation and configuration, as well as managing of users.

Set the hostname for your LDAP server:

hostnamectl set-hostname ldap.<your-domain>.com

Add the server IP to /etc/hosts:

echo '<your_server_ip> ldap.<your-domain>.com' >> /etc/hosts

Install OpenLDAP and related utilities:
```
apt install slapd ldap-utils
```
Set an administrator password for LDAP during installation and confirm it in the next prompt.

Reconfigure the slapd package:
```
dpkg-reconfigure slapd
```
When asked to omit server configuration, select ‘NO’

Configure the base DN (Distinguished Name) for your LDAP directory:
- Use your domain name to construct the base DN. For example, if your domain is my-flows.site, the base DN would be dc=my-flows,dc=site and press 'ENTER' to confirm.

Provide a name for your organization, which will also be part of the base DN and press 'Enter.'

Enter the Administrator password for your LDAP directory.

Confirm the password.

When asked to remove the database when slapd is purged, select ‘NO’.

Select ‘Yes’ to remove the old database to create room for a new database.

Edit the main OpenLDAP configuration file:

sudo nano /etc/ldap/ldap.conf

Uncomment the lines beginning with “BASE” and “URI”, for example, my domain is my-flows.site, we have updated the file as below, but you have to update it according to your domain:

BASE `dc=my-flows,dc=site.`
URI `ldap://ldap.my-flows.site.`

Adding, Updating, and Deleting Groups and Users

Adding Groups and Users

Create a file for the base groups and open the editor:
```
nano groups.ldif
```
Add the following content to groups.ldif, which will create the users group, make sure when you create a new group the gidNumber and ou is unique:
```
dn: ou=users,dc=my-flows,dc=site
objectClass: organizationalUnit
ou: users
gidNumber: 7000
```

Add the groups to the LDAP directory:

ldapadd -x -D cn=admin,dc=my-flows,dc=site -W -f groups.ldif

Create a password for the user and store the encrypted password:

Slappasswd -g

Create a file for the user:
```
nano user.ldif
```

Add the following content to user.ldif. Replace the placeholders with actual values for uid, sn, givenName,displayName,cn ,gecos , homeDirectory, and set userPassword to the password generated earlier. Ensure each user has a unique uidNumber, and you can keep the gidNumber the same if users belong to the same primary group

dn: uid=sumit,ou=users,dc=my-flows,dc=site
objectClass: inetOrgPerson
objectClass: posixAccount
objectClass: shadowAccount
uid: sumit
sn: shinde
givenName: sumit
cn: sumit shinde
displayName: sumit shinde
uidNumber: 1000
gidNumber: 7000
userPassword: {SSHA}uQVjd8MLaJ7AXEd/grqViuKnk9tNojdy
gecos: sumit shinde
loginShell: /bin/bash
homeDirectory: /home/sumit

Save and exit the configuration file.

Add the user to the LDAP directory:

ldapadd -x -D cn=admin,dc=my-flows,dc=site -W -f user.ldif

Updating Groups and Users

Create a file for the user update:
```
nano user_update.ldif
```

Add the following content to user_update.ldif to update the user's details (e.g., changing the display name):

dn: uid=sumit,ou=users,dc=my-flows,dc=site
changetype: modify
replace: displayName
displayName: Sumit Rupesh Shinde

Save and exit the configuration file.

Apply the update to the LDAP directory:

ldapmodify -x -D cn=admin,dc=my-flows,dc=site -W -f user_update.ldif

Create a file for the group update:
```
nano group_update.ldif
```
Add the following content to group_update.ldif to update the group's details (e.g., changing the organizational unit name):
```
dn: ou=users,dc=my-flows,dc=site
changetype: modify
replace: ou
ou: staff
```
Save and exit the configuration file.

Apply the update to the LDAP directory:

ldapmodify -x -D cn=admin,dc=my-flows,dc=site -W -f group_update.ldif

Deleting Groups and Users

Delete a user from the LDAP directory:

ldapdelete -x -D cn=admin,dc=my-flows,dc=site -W "uid=sumit,ou=users,dc=my-flows,dc=site"

Delete a group from the LDAP directory:

ldapdelete -x -D cn=admin,dc=my-flows,dc=site -W "ou=users,dc=my-flows,dc=site"

Configuring and Enabling SSO in FlowFuse

To configure FlowFuse with SSO, make sure you are logged in as an administrator.
Go to Admin settings by clicking on the profile icon in the top-right corner and then selecting "Admin settings".

Click on "Settings" from the left sidebar and switch to the SSO section.

Click on the top-right "Create SSO configuration".

Enter the name for your configuration, then enter the domain with @ prefix and select the "LDAP" option. Click on the "Create configuration" button.

In the next form, in the server field enter your-server-ip:389. 389 is the default port for LDAP but make sure to check it. If you are going to enable TLS, replace the port with 636.

Enter the the bind DN into the username field.
Enter the password for the LDAP administrator in the password field.
Enter the Base DN. For example, if your domain is my-flows.site, the Base DN will be dc=my-flows,dc=site.
Click on the "Update configuration" button.

Signing in Using SSO

To sign in using SSO, users of your self-hosted FlowFuse must have a FlowFuse account created with an email ID associated with the domain configured with SSO. For more information, refer to creating users in FlowFuse.

Open your platform in the browser. Enter the username in the username/email field.
Click on "Login".
Then enter the password set in the LDAP directory for that user.

Note: Admin users will still be able to log in with their original FlowFuse username/password - this ensures they don't get locked out of the platform if there is a problem with the SSO configuration

Conclusion

In this guide, we covered how to set up SSO with LDAP for your self-hosted FlowFuse platform using OpenLDAP. We installed and configured OpenLDAP, learned to managed groups and users, and configured SSO within FlowFuse. This setup enhances security by centralizing user authentication and simplifies access across applications, ensuring efficient user management in your FlowFuse deployment.

Got questions or need help setting up SSO LDAP for FlowFuse (Node-RED)? with us!

Talk to Us Now

New Charts Available in FlowFuse Dashboard

2024-07-26T00:00:00Z

It's been a while coming, but we've finally introduced a new set of chart types to FlowFuse Dashboard. We've added Pie, Donut and Grouped (Stacks and Side-by-Side) Bar charts to the UI Chart node. We've also shipped plenty of other improvements and fixes in this release, so let's dive in.

Grouped Bar Charts

We now have the option "Group By" available when building Bar Charts, with the options "Stacks" and "Side-by-Side". This allows you to group data in a more meaningful way, and is particularly useful when comparing multiple data sets.

Stacks

Screenshot showing a stacked bar chart with Dashboard

Side-by-Side

Screenshot showing a side-by-side grouped bar chart with Dashboard

Pie & Donut Charts

Radial charts are now available in Dashboard, with the introduction of Pie and Donut charts. These are particularly useful when you want to show the proportion of a single data set.

If you're using multiple "Series" here, then you'll get multiple nested radial charts, which can be particularly useful when comparing multiple data sets.

Screenshot showing the new Pie and Donut charts available with Dashboard

General Chart Changes & Improvements

Breaking Changes - Bar Charts

With the introduction of the new chart types, we've generalised the key mapping features for charts. Previously, Bar Charts were using the "Series" property to define how data is rendered onto the x-axis. In hindsight, this didn't really make any sense, it should be the "X" property that defines the data used on the x-axis, so we've corrected that going forward, but it did mean introducing a breaking change. We don't do this lightly, but in this case, it was necessary to ensure the charting experience is consistent across all chart types.

It does however mean that Bar Charts created in 1.13.0 or below will need to be updated to reflect this. You just need to set "X" to whatever you have in the "Series" property, and then set "Series" to "None".

Mapping Your Data

Series

This property is now, consistently, how you want to group your data. If a new msg is coming in, and a property on that msg defines its group, then you can set "Series" to something like msg.myCategory.

If a single data point needs to plot multiple points/bars onto a chart, then you can use the "JSON" type here, and list the different properties you want to plot, one for each category.

For Radial charts (Pie & Donut), having multiple series would provide multiple, nested radial charts.

X

With this, we define which property (or properties if a single piece of data needs to plot multiple points/bars) we want to plot on the x-axis.

Note that on Radial charts (Pie & Donut), this is the value that defines the label of the segment.

Y

Which property should be used to define the y-axis value, i.e. height of the bar or the y-coordinate of a point on a scatter chart.

Note that on Radial charts (Pie & Donut), this is the value that defines the size of the segment.

Example: Plotting Star Wars Character Heights

The Star Wars API is a free, open API that provides data on the Star Wars universe, an example API call can return details about particular characters, and the response is as follows:

[{
    "name":"Luke Skywalker",
    "height":"172",
    "mass":"77",
    "hair_color":"blond",
    "skin_color":"fair",
    "eye_color":"blue",
    "birth_year":"19BBY",
    "gender":"male",
    ...
}, {
    ...
}]

We can configure a chart with the following "Mapping" options:

Example mapping of data to a UI Chart for data coming from the Star Wars API

and this would then be the resulting chart:

Example bar chart showing heights of Star Wars characters

Note, the chart takes in all of the data sent to it, uses the name field to define where on the x-axis the data should be plotted, and the height field to define the height of the bar (the y-axis).

You can read more about this example, and access the flow itself in our documentation here

Live Dashboard Demo

Screenshot of our new interactive Dashboard to demonstrate how charts render in FlowFuse Dashboard

With the new release also comes a new Public Demo Dashboard that we've made available for all to use and play with.

You can try it out, and interact with a range of different chart types, including the new Pie, Donut and Grouped Bar charts. We'll also be extending this soon to cover the full range of widgets available in FlowFuse Dashboard.

If you want more technical detail, you can also check out our online documentation here.

What else is new?

You can find the full 1.14.0 Release Notes here.

Just to highlight a few, particularly valuable, updates and fixes:

UI Button Group - Now supports msg.enabled to enable/disable the widget.
UI Form - Now supports msg.enabled to enable/disable the widget.
UI Button - Color customisation now available, without needing to write overriding CSS.
UI Switch - Fix missing msg.topic when setting the topic to a static string.

What's Next?

Work has already begun on the next release, 1.15.0, you can see what items we have queued up here, if you've got any feedback or suggestions, please do let us know, and feel free to open new issues on our GitHub

Evolution of Technology: Impact on Job Roles and Companies

2024-07-23T00:00:00Z

Throughout history, technology has continuously transformed industries, job roles, and entire companies. While these changes often evoke fear and resistance, they also create new jobs, opportunities for innovation and growth. This post will explore how historical technological advancements have reshaped both individual job roles and entire companies, examine current trends like AI and low-code tools, and discuss the critical importance of adaptability for both individuals and businesses in navigating technological disruption, Importantly, we will address the pressing question of our time: "How can AI and low-code tools both enhance and challenge human capabilities, creativity, and the job market, and is this the next frontier in manufacturing or just hype"

Historical Examples of Technological Disruption and Business Impact

The Industrial Revolution serves as a powerful example of how technological advancements disrupted entire industries and reshaped business landscapes. In the late 18th and early 19th centuries, mechanized manufacturing replaced traditional artisanal crafts and manual labor. Companies that embraced these new technologies, such as textile mills and steam-powered factories, experienced unprecedented growth and profitability. Conversely, businesses that clung to outdated methods faced decline or closure as they struggled to compete with more efficient and scalable production methods.

The advent of the automobile in the early 20th century brought about another wave of technological disruption. As cars replaced horse-drawn carriages, companies in the transportation and manufacturing sectors had to adapt or risk becoming obsolete. Established businesses that successfully transitioned to automotive manufacturing thrived, while those that resisted change faced significant challenges. For instance, companies that continued to produce horse-drawn carriages struggled to maintain market relevance and profitability.

The digital revolution of the late 20th century further accelerated technological disruption across industries. The introduction of computers, the internet, and digital communication transformed how businesses operated, communicated, and conducted commerce. Companies that embraced digital technologies gained competitive advantages in efficiency, customer engagement, and global market reach. In contrast, businesses that resisted digital transformation struggled to keep pace with rapidly evolving consumer expectations and market dynamics.

Current Trends: AI, Low-Code Tools, and Strategic Adaptation

Today, we are witnessing a new era of technological disruption driven by artificial intelligence (AI) and low-code/no-code development platforms. AI technologies are revolutionizing business operations by automating routine tasks, analyzing vast amounts of data, and enhancing decision-making processes. Companies that strategically integrate AI into their operations can optimize productivity, personalize customer experiences, and gain valuable insights into market trends and consumer behavior. However, businesses that hesitate to adopt AI risk falling behind competitors who leverage these technologies to innovate and drive business growth.

Low-code and no-code development platforms represent another transformative trend reshaping how companies approach software development and innovation. These platforms empower business users and citizen developers to create applications and automate workflows with minimal coding knowledge. By democratizing software development, low-code tools enable faster application deployment, greater agility in responding to market demands, and enhanced collaboration between IT and business teams. Companies that embrace low-code platforms like Node-RED can accelerate digital transformation initiatives, streamline business processes, and drive innovation across the organization.

Furthermore, AI and low-code tools disrupt traditional job roles and create new opportunities across various fields. Roles such as AI Integration Specialists, Data Scientists, and Machine Learning Engineers, prompt engineers are increasingly in demand as companies seek to enhance efficiency and productivity. Similarly, the adoption of low-code tools like Node-RED is leading to the creation of positions such as Automation Engineers, IoT Developers, and Integration specialists, and Node-RED is becoming a standard requirement in jobs across manufacturing and IoT industries.

The Importance of Adaptability and Strategic Vision

Historically, individuals and businesses that fail to adapt to technological change or embrace innovation risk becoming obsolete in competitive markets. A notable example is Nokia, once a dominant player in the mobile phone industry. Nokia initially thrived by pioneering mobile technology and establishing a strong market presence. However, the company's reluctance to embrace the shift to smartphones and its adherence to outdated business models ultimately led to its decline. In contrast, competitors like Apple and Samsung seized opportunities in the smartphone market, leveraging innovation and consumer-centric strategies to surpass Nokia in market share and profitability. There are numerous such examples, one being Xerox. Watch this short video where Steve Jobs, founder of Apple, explains Why Xerox failed.

The strategic adoption of AI and low-code tools is critical for maintaining competitive advantage and driving sustainable growth. While concerns about AI ethics and reliability are valid, businesses that implement AI technologies responsibly can enhance operational efficiency, improve decision-making processes, and deliver superior customer experiences. Similarly, companies that embrace low-code development platforms can accelerate time-to-market for new applications, reduce development costs, and empower business units to innovate and iterate more rapidly. Amazon, for instance, exemplifies this adaptability by evolving from an online bookstore to a global leader in e-commerce and cloud computing through strategic technology integration.

FlowFuse: The perfect combo of Low-code and AI

FlowFuse is a cloud-based platform for Node-RED, a popular low-code tool. It enhances Node-RED with real-time collaboration, version control, and remote edge device programming.

With the capability to integrate over 5000 applications, protocols, and technologies, FlowFuse empowers businesses to innovate and streamline operations. Recently, FlowFuse has integrated AI features like the Function GPT and Node-RED Builder and the FlowFuse AI Assistant. These tools allow users to automate flow creation, significantly boosting productivity. This combination of low-code development and AI positions FlowFuse as a transformative tool for modern businesses.

Manufacturing companies are already adopting these advanced features to optimize their operations and stay competitive. Tech professionals should also prepare to leverage these tools to harness the full potential of AI and low-code development.

FlowFuse provides businesses, particularly those in the manufacturing sector, with a revolutionary solution powered by artificial intelligence and effective low-code platforms that make operations more efficient and increase output. This combination promotes quick innovation and flexibility, essential for maintaining a competitive edge in the era of Industry 4.0. FlowFuse's strong integration features guarantee the ability to expand successfully and maintain smooth connections across various applications, enabling manufacturing companies to improve their operations, enhance teamwork, and provide outstanding products and services.

Conclusion

Technology has always driven change, disrupting traditional models and opening new growth avenues. From the Industrial Revolution to today's AI and low-code tools, adaptability, strategic vision, and innovation remain key to success. By embracing emerging technologies and a forward-thinking mindset, individuals and companies can lead in innovation, customer focus, and sustainable growth in a competitive global economy.

How to Set Up SSO SAML for Node-RED

2024-07-17T00:00:00Z

SSO plays a crucial role in modern enterprise environments by simplifying user authentication across multiple applications. At FlowFuse, we recognize the significance of SSO and offer robust support for integrating it with your self-hosted platform. In this comprehensive guide, we will focus on configuring SSO SAML, specifically using Google as the Identity Provider (IdP). We also support SSO with LDAP. For more information, refer to Setting up LDAP SSO for your Self-Hosted FlowFuse.

What is SSO?

Single Sign-On (SSO) is a technology that allows users to access multiple applications or services with one set of login credentials. When a user logs in to one central system, known as the Identity Provider (IdP) such as Google, Microsoft Azure AD, or Okta, it authenticates the user and creates a session token. This token is then used to access other connected applications without requiring the user to log in again. The IdP verifies the token and shares the authentication information with other applications, ensuring secure and seamless access across multiple platforms. This reduces the need to remember multiple passwords and enhances security by centralizing authentication.

Understanding SAML

SAML (Security Assertion Markup Language) is a protocol used in SSO scenarios to exchange authentication and authorization data between an Identity Provider (IdP) and a Service Provider (SP). Here’s how it works step-by-step:

User Request: A user attempts to access a service or application that is protected by SAML-based SSO.
Redirect to IdP: The Service Provider (SP), recognizing that the user needs authentication, redirects them to the Identity Provider (IdP).
User Authentication: The IdP prompts the user to authenticate themselves. This authentication can involve various methods, such as username/password, multi-factor authentication (MFA), or other authentication mechanisms supported by the IdP.
Generating SAML Assertion: Upon successful authentication, the IdP generates a SAML assertion. This assertion contains information about the user's identity (like username, email) and any attributes or roles associated with the user.
Sending SAML Assertion: The IdP sends this SAML assertion back to the Service Provider (SP), typically through the user's browser. The assertion is digitally signed by the IdP to ensure its authenticity and integrity.
Assertion Validation: The Service Provider (SP) receives the SAML assertion. It validates the assertion to ensure it comes from a trusted IdP and that the assertions' contents are accurate and have not been tampered with.
Granting Access: If the assertion is valid, the SP grants access to the user based on the information in the SAML assertion. This allows the user to access the protected application or service without needing to provide separate credentials to the SP.

Benefits of Using SSO in the Workspace

Improved User Experience: Users only need to remember one set of credentials, making the login process simpler and reducing password fatigue. For instance, In a manufacturing environment, employees often need to access multiple systems, such as Node-RED, ERP systems, and quality control applications. With SSO, they only need to remember one set of credentials, simplifying the login process and reducing password fatigue.
Simplified Management: Administrators can manage user access and permissions from a single platform, making it easier to onboard new employees and revoke access when someone leaves. This centralized management ensures that only authorized personnel can access the application flows.
Increased Security: Centralized authentication via SSO reduces the risk of weak or reused passwords, allowing for the implementation of stronger security policies. This is critical in a workspace where sensitive data and operational systems must be protected against unauthorized access.
Enhanced Productivity: SSO allows employees to log in once and gain access to all necessary applications, saving time and reducing interruptions.

Setting up SSO For Your Self-Hosted FlowFuse Platform

Before proceeding, ensure you have deployed FlowFuse on your server with an Enterprise license and configured it with email. Without email configuration, the SSO setup option won't appear in your FlowFuse.Furthermore, Make sure you have a Google Workspace account created and verified your domain within Google Workspace. FlowFuse supports other providers for SAML SSO as well; check our documentation on supported providers for details.

If you haven't deployed FlowFuse yet, refer to our documentation on installing FlowFuse or our blog on deploying FlowFuse on Ubuntu with Docker.

Configuring SSO in your Self-Hosted FlowFuse

To configure FlowFuse with SSO, make sure you are logged in as an administrator.
Go to Admin settings by clicking on the profile icon in the top-right corner and then selecting "Admin settings".

Click on "Settings" from the left sidebar and switch to the SSO section.

Click on the top-right "Create SSO configuration".

Enter a name for your configuration, then enter the domain that the platform will use for SSO and select "SAML" option and click on "create configuration" button.

In the next tab, you'll find the ACS URL and Entity ID. Copy and save them somewhere in the notepad.

Tick "Manage roles using group assertions" if needed. If enabled, keep the Group Assertion Name to its default value and select the team scope:
- "Apply to selected teams" restricts management to the provided list of groups, For adding the list refer to SAML Groups configuration, suitable for shared-tenancy platforms like FlowFuse Cloud.
- "Apply to all teams" allows SAML groups to manage all teams, suitable for a self-hosted installation with a single SSO configuration.
Click on "Update configuration", we will back to update this configuration with our configuration provided by our Google workpsace later.

Creating the SAML APP in Google Workspace.

Open the main menu from the top-right corner by clicking on menu icon.

Click on the "Apps" icon, which expands additional choices. Then click on the "Web and mobile apps."
Then the new tab opens, click on to the "Add app" from the top.

The options open select the "Add custom SAML apps."
Enter the app name description and upload an icon for the app.

Now copy your Copy the SSO URL, entity ID and certificate or you can simply download it in the one file by clicking on the Download metadata button.

Click on the continue.
In the next tab, enter the ACS URL and entity id provided by your self-hosted flowfuse platform.

Enter the start URL as forge.<your-domain>.com, we are specify that after successfull sign in the user should be redirected to this url.
Next, click on "Continue" button and then click on "finish".

Updating the FlowFuse SSO configuration and enabling it

Now that we have created the SAML app in the workspace, we need to update the FlowFuse configuration and connect it to the app created in the workspace to enable SSO.

Go to the SSO section of the admin settings in your self-hosted FlowFuse platform. Click on the three-dot icon located at the right corner of the added configuration and select "Edit."

Add the copied values for the fields: Identity Provider Single Sign-On URL, Identity Provider Issuer ID / URL, and X.509 Certificate Public Key provided by the provider. I instructed you in the above section to copy or download them.

Click on the "Active" option to enable the SSO in the same form.
Click on "Update configuration".

Signing in Using SSO

Open your platform in the browser, Enter the email address in the username/email field.
Click on "Login".
A Google tab will open, displaying the email addresses you are signed in with. Select the email address you entered into the username/email field.

Conclusion

In this guide, we've covered setting up SSO SAML for your self-hosted FlowFuse platform, exploring how SSO and SAML enhance user experience, improve security, and simplify management. You've learned to create an SSO configuration in FlowFuse, set up a SAML app in Google Workspace, and enable seamless authentication.

Got questions or need help setting up SSO SAML for FlowFuse (Node-RED)?

Talk to Us Now

Building on FlowFuse: Remote Device Monitoring

2024-07-17T00:00:00Z

FlowFuse has established a rich ecosystem of products to help you build bespoke, powerful, low-code applications.

We've seen customers utilizing these to revolutionise precision manufacturing, automate building management and modernize the distribution of global weather data, just to name a few examples.

In this series of articles, we'll be taking a look at the common architectures and design patterns we are seeing used across our customer base, and how you can use these to build your own applications. To kick things off, this article will focus on "Remote Device Monitoring".

Use Case

You have hundreds, if not, thousands of devices deployed remotely. These could be anything from sensors, to actuators, to entire machines. You need to monitor these devices, and potentially control them. It's important to know when they are online, that they're running optimally and if something is about to, or already has, gone wrong.

Diagram showing the breakdown of each component that makes up a "Device Monitoring" use case.

Breaking it down we have the following fundamental requirements:

Read: Reading data from the devices using the relevant protocol
Parse: Process the data into a computational format
Compute/Monitor: Analysis & monitoring of the data from all devices
Action: Taking action based on the data from the devices

Then, we have to consider that this functionality needs to be deployed out to thousands of devices. So, our final requirement is:

Maintain: If we update functionality on one device, we may need to be able to easily roll those updates out to other devices. We need to sure it's easy to update and deploy to our devices, and if anything goes wrong, we should be able to easily find out what the problem is, and get easy access to fix it.

Architecture

Let's consider an example architecture set in an automotive plant:

Diagram showing an example architecture of a "Device Monitoring" use case in an automotive plant.

Laser Welding Machine: Here we have a small system built around a single piece of laser welding hardware. The hardware is connected to a PLC via local network, and the PLC is connected to a local server. Each component here can have Node-RED installed, managed by FlowFuse and accessible via the Device Agent. Node-RED would enable extraction of data from the hardware, and provide a local, bespoke, Dashboard on a nearby PC for monitoring the hardware.
Body Shop: Here we have several piece of machinery, each with the "FlowFuse Device Agent" installed. This allows us to manage the Node-RED deployments on these machines remotely from FlowFuse, and easily extract data from the machines for analysis.
Plant: We have multiple servers running at the Planet-level, generally one for each "Shop", each with their own Device Agent installed, again for easy remote management and deployment of Node-RED, e.g. Dashboards that provide a single HMI for monitoring hardware across a full shop. Here, we also have our instance of FlowFuse. This is the central point for managing all of our Node-RED deployments across the factory floor.
Company IT Dept: The general IT department of the company would provide multiple servers and services, accessible to a range of departments and the plant. Node-RED could act as a bridge between the Plant and the Company IT Dept, allowing us to easily extract data from the Plant and send it to the Company IT Dept, and vice-versa.
Cloud: Here we demonstrate how a company may have external Cloud-based services they're dependent upon. For example, image analytics services. Node-RED can be used to parse machine imagery, and integrate straight with these external services from the FlowFuse server.

This diagram also demonstrates a sample of the rich ecosystem of communication protocols that Node-RED can support:

TCP: Read and process data from from bespoke and custom devices
EtherNet/IP: Collect data from Allen Bradley and other EtherNet/IP devices
MQTT: Modern devices and factory generated IIoT data
OPC-UA: Communicate with newer PLCs and OPC Servers
Modbus: Data collection from existing Modbus enabled devices like Temperature Probes, Invertors, Encoders
MC Protocol: Gather data from Mitsubishi PLCs
FINS: Gather data from OMRON PLCs
Siemens S7: Gather data from Siemens PLCs using the S7 Protocol

FlowFuse Technology Stack

Given the above architecture, let's take a look at the relevant FlowFuse offerings and see what they're contributing:

Node-RED: Low-code, drag-and-drop integration platform. Here we'd be using it in multiple places to read and parse data from the hardware, define the application logic, conduct analysis and provide alerting.
FlowFuse Dashboard: An add-on to Node-RED for building interactive user interfaces and dashboards. We use this here to provide visual feedback on local Dashboards for some devices, as well as at the Planet-level to provide an at-a-glance view of our plant.
FlowFuse: Centralized platform that provides a single entry point to manage all of your Node-RED applications and deployments, from your device inetrgators, through to your dashboards. FlowFuse provides role-based access control out of the box, so we can easily control who has access to flows, Dashboards and other configurations.
FlowFuse Device Agent: Installed onto the relevant servers and hardware, this links you directly, and securely to FlowFuse. Here, we're deploying it to multiple pieces of machinery, as well as local servers, such that we can easily manage (deploy, upgrade, debug) all of those Node-RED deployments remotely from FlowFuse.
FlowFuse Project Nodes: A small collection of nodes for Node-RED, running on FlowFuse, that provide communication over a secure (MQTT-based) connection between devices (our Node-RED deployments on our hardware in this case) and our hosted instances of Node-RED on FlowFuse. Extremely useful for reporting live sensor data back to FlowFuse for analysis, and for reporting information back to our devices.

What Next?

Deploy to FlowFuse

If you're interested in discussing how your company could benefit from this design pattern, please do get in touch.

Customer Stories

If you want to deep dive further into how this design pattern has been used by our customers, we have some customer stories that you might find interesting:

Deploying FlowFuse with Docker on an Ubuntu server

2024-07-15T00:00:00Z

With Node-RED's increasing role in IoT, FlowFuse Cloud has become a favored platform for deploying production Node-RED applications. It offers extensive features at a low cost, reducing operational overhead. However, the cloud is not the only option we provide; we also offer a self-hosted option for users who prefer to deploy FlowFuse on their servers. This guide demonstrates how to deploy FlowFuse on your Ubuntu server using Docker, covering key aspects such as domain setup, email, SSL, and more for real-world production scenarios

Note: While the approach provided in this article is an older method for deploying FlowFuse and still works, I recommend following the newer, simpler, and quicker approach. For more details, refer to the official Docker documentation.

What is Docker?

Docker is an open-source platform that simplifies how applications are deployed, scaled, and managed through containerization. It enables you to package all components required by your project such as code, libraries, and dependencies into a single, portable unit known as a Docker container. These containers ensure consistency in application environments and ease deployment by ensuring that applications run predictably across different computing environments, whether on a developer's laptop, a server, or a cloud platform.

Deploying FlowFuse on Ubuntu server with Docker

Before proceeding, ensure you have your domain and a server with Ubuntu installed, and Docker is installed on it. For more information, refer to Docker Compose Installation. Furthermore, If your server has Ubuntu installed without a GUI, you can connect to it from your computer using SSH, allowing you to run commands from your local computer on the server.

Adding DNS records for your domain

To make your application accessible on the internet via your domain name, adding DNS records is crucial. These records serve as a vital link between your domain name (like example.com) and your server's IP address. They ensure that when users type your domain into their browsers, they're directed to the correct location where your application is hosted.

Log in to your Domain Provider's Panel and access the DNS settings of the domain you want to use for the FlowFuse platform.
Add entry first entry type: "A", enter "@" into the name field (it points to the domain name itself), and the public IP of your Ubuntu server into the data field.
Add entry second entry type: "A", enter "*" into the name field (adding * serves as the wildcard domain entry to the IP address of the host running Docker, we are doing this because the FlowFuse application will be hosted on the forge.your-domain-name.com and when creating instances for each, our FlowFuse application will use unique subdomain ) and public IP of your Ubuntu server into the data field.
Add the last entry type: "A", and enter "www" into the name field (we are adding this because previously domain names used to have the www prefix) and the public IP of your Ubuntu server into the data field.

Installing and configuring FlowFuse

FlowFuse uses Docker Compose to install and manage the required components. We have built and maintaining that Docker Compose project.

Download the latest release tar.gz from our Docker Compose project.

cd /opt

wget <link of the latest tar.gz release>

Unpack this release with the following command. Make sure to replace the release name with the actual release name that you downloaded:

    tar -xvzf vx.x.x.tar.gz

Enter the folder with the following command. Again, don't forget to replace the release name with the actual release name that you downloaded:

    cd docker-compose-x.x.x

Now, update the FlowFuse configuration file flowforge.yml with your domain name. Currently, it is configured with example.com. To update it quickly, use the following command:

    sed -i 's/example.com/<replace-with-your-domain-name>/g' ./etc/flowforge.yml

Next, update the Docker Compose configuration file docker-compose.yml with your domain:

    sed -i 's/example.com/<replace-with-your-domain-name>/g' ./docker-compose.yml

The flowforge.yml file was updated to include our domain in key fields: domain, base_url, and broker.public_url. These adjustments ensure that instance names on Docker platforms incorporate your domain, provide accurate URLs for accessing the platform, and specify the correct URL for devices to connect to the broker if different from broker.url. Additionally, in the docker-compose.yml file, we configured VIRTUAL_HOST and LETSENCRYPT_HOST to reflect our domain.

For more details on these configuration changes, refer to the documentation.

Securing Communication with SSL

Securing communication with SSL (Secure Sockets Layer) is crucial for protecting data transmitted between your users and the server. Adding SSL requires obtaining a certificate from a trusted certificate authority (CA) and configuring your server to use this certificate. Configuring SSL manually can be a headache, so we have provided a setup you need to enable.

Open the Docker Compose file in your editor:

    nano docker-compose.yml

Uncomment the following lines by removing the # symbol:

    # - "./certs:/etc/nginx/certs"

    # - "443:443"
    # environment:
      # - "HTTPS_METHOD=redirect"

    # acme:
    #   image: nginxproxy/acme-companion
    #   restart: always
    #   volumes:
    #     - "/var/run/docker.sock:/var/run/docker.sock:ro"
    #     - "./acme:/etc/acme.sh"
    #   volumes_from:
    #     - nginx:rw
    #   environment:
    #     - "DEFAULT_EMAIL=mail@example.com"
    #   depends_on:
    #     - "nginx"

Update the lines with your domain and email associated with the domain, then save the file:

    - "DEFAULT_EMAIL=your-email@example.com"

    - "LETSENCRYPT_HOST=mqtt.yourdomain.com"

    - "LETSENCRYPT_HOST=forge.yourdomain.com"

Open the flowforge.yml file in your editor:

    nano /etc/flowforge.yml

Update the base_url to start with https:// instead of http:// and the broker.public_url entry to start with wss:// instead of ws://, then save the file.

    base_url: https://yourdomain.com

    broker:
      public_url: wss://mqtt.yourdomain.com

Now, when we start our application the acme container will also start and will generate the certificates with let's encrypt on demand for the forge app and then for each of the instances as they are started.

Configuring FlowFuse to Enable and Use the Email Feature

FlowFuse platform allows you to send invitations to other users within the platform and via email. It also supports receiving critical alerts and resetting passwords through email. To use these features, you need to enable and configure email in FlowFuse with your email address. Before you begin, make sure you have an email ID with an app password. FlowFuse supports Gmail and Outlook emails.

Creating an App Password for Your Email

If you're unfamiliar with generating an app password, watch these helpful videos:

Enabling and Configuring Email in FlowFuse

Open the flowforge.yml config file in your editor:

    nano /etc/flowforge.yml

Update the email configuration section with your email details:

For Gmail:

email:
  enabled: true
  debug: false
  smtp:
    host: smtp.gmail.com
    port: 465
    secure: true
    auth:
      user: your-email@gmail.com
      pass: your-app-password

For Outlook:

email:
  enabled: true
  debug: false
  smtp:
    host: smtp.office365.com
    port: 587
    secure: false
    tls:
      ciphers: "SSLv3"
      rejectUnauthorized: false
    auth:
      user: your-email@outlook.com
      pass: your-app-password

Running FlowFuse Application

We have completed the basic production-level configuration for running the FlowFuse application. Before running it, we need to ensure that we have the flowfuse/node-red container downloaded, which will be used as the default Node-RED stack.

To download the Node-RED container, run the following command:

    docker pull flowfuse/node-red

Now, to run the FlowFuse application, execute the following command:

    docker compose -p flowforge up -d

If you see an output similar to the following image, it indicates that all containers that are required for the flowfuse application to run correctly are running.

You can now access your self-hosted FlowFuse platform on the internet using the URL forge.<yourdomain>.com, and if your website shows the https as following that means the SSL configurations are also correct.

Setting up the FlowFuse Platform

When you open the platform in your browser for the first time, you'll need to create an administrator account and perform initial configurations:

Open the platform in your browser.
Click on the "START SETUP" button.
Enter the username, full name, email, and password, and confirm the password to the administrator user account. This first user will have full access to the platform, allowing them to configure settings, and manage users and teams.
Next, If you intend to use the FlowFuse Enterprise Edition, enter your license details.
Alternatively, you can continue with the FlowFuse Community Edition (CE), which is free, by clicking "Continue with FlowFuse CE".

Additional resources

Deploying FlowFuse with Docker Documentation: This documentation covers everything in detail on how to install FlowFuse using Docker.
Deploying FlowFuse with Docker on Ubuntu youtube video: This YouTube video demonstrates how to deploy FlowFuse using Docker on an Ubuntu server for your server's local network.
Form for requesting Installation Service: Fill this form if you need assistance with the installation process.

Got questions or need help deploying FlowFuse (Node-RED) on your Ubuntu server?

Talk to Us Now

Calling a Python script from Node-RED

2024-07-10T00:00:00Z

Python's robust data processing capabilities and extensive libraries are well-known in programming. When combined with Node-RED, these technologies can synergize to elevate data analytics and automation. This guide walks you through integrating Python scripts with Node-RED. You'll gain practical insights, troubleshooting tips, and effective techniques for executing scripts, enabling you to leverage this powerful combination for your IoT projects.

Why use python with Node-RED

Integrating Python and Node-RED can significantly enhance your IoT and automation initiatives by leveraging their distinct strengths. Node-RED excels in creating easy workflows, efficiently processing data streams, and integrating hardware, APIs, and. Meanwhile, Python offers a rich set of libraries for advanced tasks such as machine learning and AI, pivotal in realizing Industry 4.0 concepts.

This combination allows developers to build robust and flexible solutions. For instance, while Node-RED manages data flow and device communication, Python can perform complex analytics, and predictive modeling, or integrate with AI frameworks. This integration bridges the gap between data collection and actionable insights, enabling systems to make informed decisions autonomously.

Installing Python

When executing Python scripts, it's essential to have the Python runtime installed on your system. Before proceeding, make sure you have it installed. You can follow the official guide for instructions.

To verify if Python is installed, open your terminal and execute:

python --version

The above command displays the version of Python installed on your system as shown in the above image. If the above command doesn't work, try:

python3 --version

The specific command to use depends on how Python was installed and configured on your system. However, make sure to use python <filename>.py if the first command works, or python3 <filename>.py if the second command works, while executing Python scripts.

Executing Python Script from Node-RED

Let's now see how to call a Python script from Node-RED. First, we'll create a basic script file that contains a function to print text in the console based on input. Currently, the function uses hardcoded input. To create this file using Node-RED, import the following flow, deploy it, and press the inject button:

Now, let's execute this Python script from Node-RED. To do that, we will use Node-RED's Exec node, which allows running commands on your system.

Drag an Inject node onto the canvas.
Drag an Exec node onto the canvas and Configure the command to python ./example.py -u. The -u flag prevents potential output buffering issues when executing Python scripts via exec.

Drag a Debug node onto the canvas.
Connect the output of the Inject node to the input of the Exec node, and the output of the Exec node to the input of Debug node.

Now, when you deploy this flow and click on the inject node to execute the file, you should see the text 'Positive number entered' and { code: 0 }, which indicates your script has been successfully executed.

Reading Temperature Sensor using Python script

Having explored how to run a Python script within Node-RED with the basic practical example, let's move to a real-world scenario. We'll demonstrate how to read sensor data using Python, despite Node-RED providing numerous community-built nodes for this purpose. This approach provides deeper insights into integrating external scripts, showcasing the flexibility of Node-RED for custom solutions.

Before proceeding, ensure that Node-RED is running on a device connected to a temperature sensor. For detailed instructions, refer to Setting Up Node-RED on Different Hardware, In this case, we are running Node-RED on a Raspberry Pi 5 with a DHT11 sensor connected to it.

Drag an Inject node onto the canvas, and set repeat to 1 seconds of interval.
Drag an Exec node and set the path to python <filename>.py, replace the filename with the name of the file which reads the sensor data, and make sure the python file doesn't contain the loop.
Drag the JSON node onto the canvas and set the action to "Always convert to JSON object".
Drag the Debug node onto the canvas.
Connect the output of the Inject node to the input of the Exec node and output of the Exec node to the input of the JSON node, and finally the JSON node's output to the input of the Debug node.

Below is the complete flow which creates the Python file to read the DHT11 sensor and executes that file after 1 second of interval. After deploying the flow you should able to see the sensor data on the debug sidebar as shown in the below image.

Note: The Python script uses the adafruit-circuitpython to read the sensor data so make sure to install it. Additionally, the code contained in the template node in the following flow considers that your sensor's signal pin is connected to GPIO 4.

Executing Python Script with Arguments from Node-RED

Now, let's revisit our first example. In that example, we executed a simple Python file with a hardcoded value. Now, we'll learn how to pass arguments or inputs to the Python script when executing from Node-RED. For this, we'll need to update the file. Import the following flow, deploy it, and click on the inject button to create the file.

Drag the Inject node onto the canvas.
Drag the Exec node onto the canvas, set the command to python -u ./example.py <arg>, and replace the <arg> with your argument.
Now Drag the Debug node onto the canvas.
Connect the output of the Inject node to the input of the Exec node, and the output of the Exec node to the input of the Debug node.

If you examine the Python file we've created, you'll notice the use of the 'sys' module, which allows us to read command-line arguments. In our context, we execute the command python ./example.py -30. By accessing sys.argv[1], we retrieve the argument -30. The index 1 is used because sys.argv[0] provides the filename of the script being executed. Additionally, Python supports passing multiple arguments, so that you can pass as many arguments as you want.

Conclusion

In this guide, we've demonstrated how to seamlessly execute Python scripts from Node-RED, along with troubleshooting tips and instructions on passing arguments to scripts. By leveraging Python's extensive libraries for data processing, machine learning, and other tasks in conjunction with Node-RED, developers can build powerful IoT solutions with ease.

Simplify Node-RED management and deployment with FlowFuse. Optimize, scale, secure, collaborate effortlessly, and access your instance remotely.

FlowFuse 2.6: AI Infused Node-RED, Persistent File Storage & Lots More

2024-07-04T00:00:00Z

FlowFuse 2.6 is packed with great new features, and in this release we've had a heavy focus on improving the development experience of Node-RED, lowering the barrier to entry for new users and aligning to our Simplified Hosting and Low-Code plans from our Product Strategy.

Improving the Node-RED Experience

Whilst a big part of FlowFuse is the ability to run Node-RED, we're also focussing on how to improve the experience of building with Node-RED on FlowFuse too.

AI-Infused Node-RED

Screenshot of an example instruction sent to FlowFuse Assistant.

One of the joys of Node-RED is how it empowers users not experienced with development to create bespoke applications. A popular and very powerful node in Node-RED is the "function" node. This node allows users to write JavaScript code to manipulate messages. However, this can be daunting for users who are not familiar with JavaScript, it's a steep learning curve. As such, when you run Node-RED in FlowFuse, you'll be able to use the Node-RED Assistant in both the Editor toolbar, and the function nodes:

Screenshot showing the "FlowFuse Assistant" button available in the Editor Toolbar

Screenshot showing the "Ask the FlowFuse Assistant" button available in the function node

The Node-RED Assistant is an AI-powered tool that can help you write JavaScript code in the function node. It can suggest code snippets, help you debug your code, and even write code for you. This is a game-changer for users who are inexperienced with JavaScript, as it lowers the barrier to entry and makes it easier to create applications.

Immersive Editor Experience

During our investigation on how FlowFuse and Node-RED are used together, we found out that many users have to frequently switch between the Node-RED Editor and FlowFuse UI. This back-and-forth movement was often necessary to view logs, save snapshots, restart the Editor after updates, and perform other tasks.

We're always seeking to reduce friction in the FlowFuse user experience, and as such, we've introduced a large overhaul of the developer experience for Node-RED when running in FlowFuse, in what we're calling the "Immersive Editor".

Screenshot showing the "Immersive Editor" view, where the FlowFuse navigation is available as a floating bar.

Now, the instances tabs are all available in the same view as the Editor.

Screenshot showing the "FlowFuse" button at the bottom of the Node-RED Editor.

Don't worry though, if you want the full editor experience again, you can just collapse the FlowFuse menus down to a little "FlowFuse" button at the bottom.

The new Immersive Editor is available for instances running Node-RED 4.0.2 or later - older versions of Node-RED will still use the separate views.

Persistent File Storage

Since the early days of FlowFuse, we have provided custom File nodes that can be used to read and write individual files from a flow. This was necessary because the local file system was not considered persistent; restarting an instance would reset the file system back to how it was when the instance first started.

Whilst this solved the immediate problem for the File nodes, we know there were 3rd party nodes that would want to use the file system as well - and we couldn't expect them to update to work with our custom solution.

With the 2.6 release, each instance now gets a piece of persistent file system they can read and write to normally, from any node - with full confidence those files will be persisted between restarts.

This unlocks lots of new capabilities using nodes from the community. For example, the SQLite nodes can be used to quickly add a locally managed database to store your data in.

All newly created instances of FlowFuse Cloud from today will have this storage enabled. If you have an existing instance you'd like to move over, then do get in touch and we can help move you over.

Other Highlights

Compact Applications View

This is a great example of collaboration with our customers. Three weeks ago, a customer reached out to us with a design proposal for the main "Applications" view. Within three weeks it's not only been implemented, but is now live, running in FlowFuse Cloud, and available in FlowFuse 2.6.

Screenshot of new "Applications" view for a given Team in FlowFuse.

The improvement here is that we've moved instances and devices to be shown as a maximum of three per row (rather than the one perviously) meaning you can see far more content at a glance, and hopefully, get to where you need to go in fewer clicks.

Import/Export Blueprints

Screenshot showing the admin page for "Flow Blueprints" with the new "Import"/"Export" buttons

Administrators of FlowFuse instances can now import and export Blueprints. This is the first stage of a larger feature set for Blueprints that will make it easier to share common flows and patterns across FlowFuse instances, and see many extensions to our Blueprint Library.

Multi-line Environment Variables

Screenshot showing the "Environment Variables" table in an Instance's Settings

We now support the use of multi-line environment variables for your Node-RED instances running on FlowFuse. This unlocks the ability to store certs or multi-line values like JSON as environment variables.

We've also improved the .env importing to support the use of multi-line values too.

And Much More...

For a full list of everything that went into our 2.6 release, you can check out the release notes.

Together, we can make FlowFuse better with each release!

Try it out

Self-Hosted

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse yourself via a variety of install options. You can find out more details here.

FlowFuse Cloud

Upgrading FlowFuse

If you're using FlowFuse Cloud, then there is nothing you need to do - it's already running 2.6, and you may have already been playing with the new features.

If you installed a previous version of FlowFuse and want to upgrade, our documentation provides a guide for upgrading your FlowFuse instance.

Getting help

Please check FlowFuse's documentation as the answers to many questions are covered there. Additionally you can go to the community forum if you have any feedback or feature requests.

Node-RED Dashboard Formally Deprecated

2024-06-27T00:00:00Z

Dave Conway-Jones, the lead maintainer of Node-RED Dashboard, has just announced that Node-RED Dashboard has been formally deprecated, meaning there will be no further development activity on the project.

FlowFuse Dashboard (also known as Node-RED Dashboard 2.0) is a natural successor to Node-RED Dashboard, and in this article, we detail what FlowFuse Dashboard offers, and how you can get started.

What's new in Dashboard 2.0?

Not only have we made significant efforts to ensure that FlowFuse Dashboard has as much feature parity with Node-RED Dashboard as possible, but we've also introduced a number of new features that we think you'll love, some highlights include:

Multi Tenancy: A big change from Node-RED Dashboard is the introduction of multi-tenancy features. This allows you to build Dashboards that are unique to each user that interacts with your flows.
Responsive Layouts: FlowFuse Dashboard is built with a responsive layout in mind, meaning that your Dashboards will automatically adjust to the screen size of the device they are being viewed on.
New Nodes: We've introduced a five new nodes; Button Group, Radio Group, File Upload, Event and Table to help you build your Dashboards, without needing to write custom code, or depend on third-party libraries.
Directly Install on Mobile: FlowFuse Dashboard is built as a Progressive Web App (PWA), this means that you're able to install it directly onto your mobile device as if it were a native mobile application.
Vuetify Framework: FlowFuse Dashboard is built on VueJS, and with that, we made the decision to integrate in Vuetify, a very rich collection of functional UI widgets. All of these widgets are available, by default when you want to build your own custom widgets in a ui-template node.

What we have planned

We are actively investing into the development of FlowFuse Dashboard, and releasing new features and updates on a regular basis. We have a public Project Management Board that show exactly what we're working on, and what we have planned in the near future. Some particular highlights include:

Visual Layout Editor: This would be the biggest improvement to building dashboards in Node-RED. We're aiming for a fully interactive front-end to help you design your Dashboard layouts. This would live in your Dashboard itself, no more needing to switch between the Node-RED Editor and your Dashboard to sanity check changes. You can see more details here.
Diversity of Data Visualisation: We are planning to provide a richer ecosystem of data visualisations. We're also likely to be switching to Apache eCharts (subject to further investigation), and are considering a ui-template-type node that can be used to build custom charts too.
Feature Parity: Whilst we've covered there vast majority of Dashboard 1.0 features, we've still got a little bit to go, in particular, the most requested features we have are programmatic (mustache) title and labels.

If there are any other features you'd like to see, please do open a Feature Request, and we'll do our best to accommodate.

Getting Started with FlowFuse Dashboard

If you're ready to get started with FlowFuse Dashboard, you can install it directly from the Node-RED Palette Manager. Simply search for @flowfuse/node-red-dashboard and install the latest version.

A short recording to show how easy it is to setup your first dashboard

Getting started is as easy as dropping on your first node. FlowFuse Dashboard will automatically set you up with a default group, page, theme and underlying Dashboard configuration.

Resources

We have a comprehensive Getting Started Guide that will walk you through the process of setting up your first Dashboard. You can download our "Ultimate Guide" eBook too.

Dashboard Workshop

We'll running a Workshop on July 2nd, where we will be covering a collection of useful tips and design patterns to help you get the most out of Dashboard.

The recording will also be available on the FlowFuse YouTube channel after the event.

Migrating to FlowFuse Dashboard

If you're looking to migrate your existing Node-RED Dashboard flows to FlowFuse Dashboard, we have a Migration Guide that details all of the features and properties that have, and haven't, been migrated into FlowFuse Dashboard.

It's worth noting that FlowFuse Dashboard will run side-by-side with the original Node-RED Dashboard, so you can take your time to migrate your flows over, and do so, piece-by-piece.

This week, we also made available the first iteration of the Dashboard Migration Service:

Screenshot showing the Dashboard Migration Service available on FlowFuse's website

Currently, it'll convert your ui_tab, ui_group nodes, and setup your new ui-theme and ui-base nodes for you. We'll be extending this over time, and eventually hope to auto-convert most of your existing Dashboard 1.0 flows.

Final Thoughts

We're really excited to see what you can build with FlowFuse Dashboard, and we're here to help you every step of the way. If you have any questions, please do reach out to us on the Node-RED Community Forum.

If you're interested in contributing and extending FlowFuse Dashboard, we're very open to Pull Requests, and have a detailed contributing guide you can take a look at here.

Interacting with Google Sheets from Node-RED

2024-06-21T00:00:00Z

Have you ever needed to integrate Google Sheets with your Node-RED application to track and manage data seamlessly? This guide will walk you through the process of integrating Google Sheets with Node-RED, enabling you to write, read, update, and delete data effortlessly.

What is the Google Sheet?

Google Sheets is a cloud-based spreadsheet application developed by Google. It allows users to create, edit, and collaborate on spreadsheets in real-time over the Internet. This makes it an ideal option for easily and securely collaborating on data that is not large in size. In businesses, Google Sheets is commonly used for tasks such as analyzing daily profits, tracking expenses, and managing collaborative projects. However, for products or services with large user bases, businesses often prefer using databases, which are recommended for efficiently managing and scaling data operations.

Prequisite

Before proceeding, make sure you have installed the following node from the pallet manager.

node-red-contrib-google-sheets

Interacting with Google Sheets with Node-RED

To integrate Google Sheets with our application we must first enable the Google Sheets API, and create the service account in the Google Cloud, before proceeding, make sure you have the Google Cloud account created.

Open your browser and go to Service accounts.
Create a new project by clicking the "CREATE PROJECT" button in the top right corner. Enter the project details such as project name and organization.

Go to the main menu by clicking the menu icon in the top left, then select "APIs & Services."

Click on "Enable APIs and Services" in the header.

In the search bar, type "Google Sheets" and select it from the results.

Click the "Enable" button to enable the Google Sheets API.

Go back to the main menu and click on "IAM & Admin," then select "Service Accounts" from the left sidebar.

Click on "Create Service Account" in the header. Enter the necessary details and click "Create" to proceed.

Select the Role from the "Owner" and click on the "Continue" button.

Click "Done." Make sure to copy the generated service account email and save it for later use.

To generate a private key, click on the three dots icon on the right of the newly created service account and select "Manage keys."

Click on "Add key," choose "Create new key," select "JSON" as the key type, and click "Create." Your private key will be generated and downloaded.

Configuring the Google Sheet Node

Before proceeding, ensure you have added the environment variable for the private key that was generated. Additionally, grant the editor access to the sheet you want to interact with for that service account email we created in the above section.

Drag a GSheet node onto the canvas.
Double-click on the node and click on the pencil icon next to "creds."
Enter the environment variable added for the private key in the "creds" field and click "Add."
Go to the Google Sheet you want to interact with and copy its ID from the URL. The URL will be in this format: https://docs.google.com/spreadsheets/d/<id_of_sheet>/
Return to your Node-RED instance, double-click on the GSheet node again, and paste the spreadsheet ID into the "SpreadsheetID" field.
Enter the range of cells you want to work with using the syntax <sheetname!first-cell-name:last-cell-name>. For example, use Sheet1!A1:C3 to specify that you are working with the "Sheet1" tab, starting from cell "A1" to cell "C3". This syntax allows you to define specific ranges such as a row (A1:A5), a column (A1:E1), or a block (A1:C3) within the spreadsheet.

Writing Data to Cells

For demonstration purposes, I will write simulated sensor data which includes a timestamp and sensor data.

Drag the Inject node onto the canvas, and set msg.payload to [$moment().format(), $random() * 100] as a JSONata expression, and set it to repeat every 3 seconds of interval.
Double-click on the GSheet node, select the method to "Append Row" set the range to <sheetname>!A2, and replace sheetname with the name of your sheet. I have defined cell A2 because I want to start writing data from cell A2.
Drag the Debug node onto the canvas, which will help in debugging in case of any error.
Connect the output of the Inject node to the input of the GSheet node, and the output of the GSheet node to the input of the Debug node.

This flow generates a timestamp and a random number. The data is formatted as an array because I want the timestamp (the first item of the array) to be placed in column A and the random number (the second item of the array) to be placed in column B. If you want to insert data into additional columns, you can add more items to the array. For example, if you add a third item to the array, it will be placed in column C, a fourth item will be placed in column D, and so on.

Reading Data from Cells

Drag an Inject node onto the canvas.
Drag another GSheet node onto the canvas, and set the method to "Get Cells" and the range to <sheetname>!A2:C1000, as I wanted to read data from cell A2 to the next 1000 cells.
Drag a Debug node onto the canvas.
Connect the output of the Inject node to the input of the GSheet node, and the output of the GSheet node to the input of the Debug node.

Updating Data of Cells

Drag an Inject node onto the canvas, and set the updated value as the msg.payload.
Drag another GSheet node onto the canvas, and set the method to "Update Cells" and the range to <sheetname>!A2, as I wanted to update the value of cell A2.
Drag a Debug node onto the canvas.
Connect the output of the Inject node to the input of the GSheet node, and the output of the GSheet node to the input of the Debug node.

Deleting Data from Cells

Drag an Inject node onto the canvas.
Drag another GSheet node onto the canvas, and set the method to "Clear Cells" and the range to <sheetname>!A2:C50, as I wanted to clear the first 50 records.
Drag a Debug node onto the canvas.
Connect the output of the Inject node to the input of the GSheet node, and the output of the GSheet node to the input of the Debug node.

Below I have provided the complete flow that we have built through the guide, make sure to replace the environment variable with your environment variable added for the private key.

Conclusion

This guide demonstrated how to integrate Google Sheets with Node-RED for streamlined data management. We covered setting up the Google Sheets API, configuring Node-RED to interact with sheets, and performing actions like writing, reading, updating, and deleting data.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

Multi-Tenancy available for everyone with FlowFuse's Dashboard 2.0

2024-06-21T00:00:00Z

FlowFuse Dashboard has featured multi-tenancy features through the FlowFuse User Addon. This made user based applications available only to specific FlowFuse team tiers and customers. However, the Node-RED community wanted to use the same feature set in cases FlowFuse didn't consider initially. Taking this feedback on board, today we announce some significant changes to how you can build Dashboards with multi-tenancy in mind.

Having taken that feedback on board, we've made some significant changes to how you can build Dashboards with multi-tenancy in mind.

A quick summary of the changes are as follows:

Socket constraints moved to core Dashboard: The ability to constrain communications to a specific client (using the msg._client.socketId) has been moved to the core of Dashboard 2.0, and is no longer a feature of the FlowFuse User Addon. As such, it's available to all users, for all node types.
FlowFuse User Addon now Source Available: The addon is available to install in any instances of Node-RED running on FlowFuse, so that's all team tiers on FlowFuse Cloud, and any self-hosted instances of FlowFuse too. It is available to install from Node-RED's Palette Manager.
Cloudflare Auth Plugin: Release of the first community-created Auth Plugin for Dashboard for adding a user object when authenticating with Cloudflare. (See more details and install the plugin here)

Using Client Data

Available since our 1.10.0 release of Dashboard, we have a new sidebar tab - "Client Data".

This new tab acts as a portal to control whether data about the connected clients is included in any events emitted in the Node-RED editor (appended into msg._client). You can then use the "Accept CLient Data" options to define which nodes accept that data as a constraint for communication.

Screenshot showing the new "Client Data" sidebar available with Dashboard

In this case, if we send a msg to any ui-notification or ui-control which a specified msg._client.socketId, then that msg will only be sent to the relevant socket connection.

Building Multi-Tenant Dashboards

We have introduced a new section to our documentation on Design Patterns.

To summarise briefly, we now consider there to be two primary design patterns when building with Dashboard:

Single Source of Truth: All users of your Dashboard will see the same data. This is useful for industrial IoT or Home Automation applications.
Multi-Tenancy: Data shown in a particular widget is unique to a given client/session/user. This represents a more traditional web application, where each user has their own session and associated data.

Note that these patterns can be intertwined, some widgets on a screen may be driven by "Single Source of Truth", and others by "Multi-Tenancy".

Building a Single Source of Truth Dashboard

Example flow diagram to show the flow of data in a "Single Source of Truth" architecture

Data can be sent to these widgets at any time, when a user connects to the Dashboard, the respective widget will load the relevant data from the centralised data source in Node-RED and show it to the user.

Building a Multi-Tenancy Dashboard

Example flow diagram to show the flow of data in a "Multi-Tenancy" architecture

In this pattern, a very useful node is the ui-event node which fires a msg when a user views a page. This msg will contain a msg._client object, detailing the client's connection.

This _client object contains the socketId of the user (and potentially more depending on any Authentication plugins used). This msg can then be passed through to any other widget, and if configured to "Accept Client Constraints" that msg will only be sent to the specified client.

Authentication Plugins

In this release we've also added a special category of plugins, "Authentication Plugins".

These plugins register themselves with Dashboard, and are permitted to add to the msg._client object. This can be useful for adding additional information about end users, such as their user ID, e-mail address or username.

This data can be used to constrain communications from Node-RED to a specific user rather than just a socket connection, which is far more reliable and secure.

Screenshot showing "FlowFuse User" being appended to _client by the FlowFuse User Addon

Any active plugins you have installed, will also be detailed in the new "Client Data" sidebar (detailed above) so you can see which plugins are active and what data they are adding to the msg._client object.

FlowFuse User Addon

Whilst the plugin was first published a few months back, after hearing community feedback, we've made changes and are now publishing the plugin to the Node_RED Palette Manager. As such, it's available to all users running FlowFuse.

The addon appends a user object to the msg._client object, populated with the details of the FlowFuse user performing the relevant actions in Dashboard. You can use this information to build multi-tenant Dashboards.

You can install the FlowFuse User Addon from the Palette Manager in the Node-RED editor.

Screenshot of the Instance settings in FlowFuse to enable "FlowFuse User Authentication"

It's worth noting that instances must have "FlowFuse User Authentication" switched on in the instance's settings.

Cloudfare User Addon (Community Contribution)

We're also thrilled to announce that the first community-contributed plugin has been published which will append a user object to the msg._client object when authenticating with Cloudflare.

A huge thanks to Fred Loucks (@fullmetal-fred on GitHub) for his great contribution!

Build Multi Tenant Dashboards with FlowFuse Cloud

Start by following our Getting Started Guide.

Looking to build a multi-user dashboard, deploy it in seconds, scale and manage Node-RED efficiently, and enable seamless remote access for your entire team?

Node-RED 4: Bringing better collaboration to FlowFuse Cloud

2024-06-20T00:00:00Z

Node-RED 4.0 is the new major release of the project, which is at the heart of all we do at FlowFuse. It brings a range of new features that continue to make Node-RED the first choice for low-code development.

As we wrote recently, our product mission statement is to provide the best way to build, manage and deploy Node-RED applications at scale, in reliable and secure production environments. This drives the work we do both within the FlowFuse platform and our contributions back into the Node-RED project.

The Node-RED 4.0 release includes some of our recent contributions to improve the Build part of that mission - more specifically around the Collaborative Development part.

Within FlowFuse we already have features such as the Team Library that help team members share their flows with each other. That works well when working across separate Node-RED instances, but we wanted to improve the experience when working with the same Node-RED instance.

There has been a common complaint from users in the community on how Node-RED handles multiple users editing flows at the same time. Our goal is to make collaboration as simple and natural as possible and Node-RED 4.0 brings us a big step forward.

Multiplayer Mode

A key problem has been not knowing what other users were doing in the editor; not knowing that someone else was making changes until they deploy them, causing you to be interrupted in your own work to figure out how to pull their changes into your editor.

The new Node-RED Multiplayer Mode helps to address this by showing you who else has the editor open and 'where' they are in the editor - such as which tab they have open, or if they are currently editing a node.

This is just the first step to our eventual goal of being able to see the changes others are making in real-time.

Concurrent Deploy Handling

A second thread to this work has been to improve the workflow when someone deploys changes whilst you're busy working on your own flows.

With previous versions of Node-RED, each time someone deployed changes, you would receive a notification you couldn't ignore - having to deal it before you could continue what you were doing. Getting one notification wasn't so bad, but if your team mate was being particularly productive, they might be hitting the deploy button regularly - each time interrupting your own flow.

With Node-RED 4.0, we've made some small adjustments that should have a big impact. The notification that someone has deployed changes in the background is now much more discrete - and can be ignored entirely. Only when you want to deploy your changes will you need to merge in their changes first. This lets you stay in the zone whilst working, keeping the interruptions to a minimum.

Other Updates

There are of course many other great reasons to start using Node-RED 4.0. The community blog post describes all the other great features in this release.

Try it out on FlowFuse Cloud

Node-RED 4.0 is available on FlowFuse Cloud right now. You can spin up a new instance, or upgrade any of your existing instances via the options under the Instance Settings page.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

FlowFuse 2.5: New features to visualize snapshots, LDAP integration, and more

2024-06-06T00:00:00Z

FlowFuse 2.5 introduces LDAP integration, snapshot comparison, extends the ability to preview flow to Blueprints, rounds out the management for snapshots, and allows you to point your own domain names at your FlowFuse instances.

Support for LDAP integration #2558

In our commitment to making FlowFuse more versatile and secure, we've introduced support for LDAP alongside our existing SAML SSO options. This has been a much requested feature that we are excited to release. This allows organizations to manage user authentication seamlessly, leveraging their existing LDAP infrastructure. With this feature, you can ensure that access controls are robust and aligned with your company's security policies.

Compare Snapshots Visually to see differences #3624

Keeping track of changes and updates has never been easier. With our new visual comparison tool, you can now compare snapshots and see the differences at a glance. This feature provides a clear, graphical representation of changes, making it simple to identify modifications and understand their impact.

Preview Blueprints before Deployment #3838

Similarly to the feature to be able to compare snapshots we have enabled this same feature to allow users to preview team flows and blueprints prior to deploying. This expedites the process when you are attempting to find the correct flow for your application. We find that our users will be able to expedite the exploration of both their own team library and the blueprints.

Import and Export support for snapshots #3628

Managing your Node-RED artifacts just got simpler with our new import and export support for snapshots. With just a few clicks, you can easily transfer configurations between deployments or back up your current setup. This feature is perfect for those who need to replicate environments within their own enterprise with multiple deployments or ensure their configurations are safely stored.

Deploy Dashboard and APIs running on Flowfuse via your own Domain Names #324

Branding and accessibility are crucial, and with FlowFuse 2.5, you can now deploy dashboards and APIs on your own domain names. This enhancement allows you to present a consistent brand experience and makes it easier for users to access your services. Whether you're deploying internally or externally, this feature provides the flexibility you need.

Full list of release features and bug fixes

You can view everything included in 2.5 on the Github Release page.

We also regularly release updates to FlowFuse Cloud in between our monthly releases. You can follow the updates as they are made via our ChangeLog.

What's next?

We're always working to enhance your experience with FlowFuse. Here's how you can stay informed and contribute:

Roadmap Overview: Check out our Product Roadmap Page to see what we're planning for future updates.
Entire Roadmap: Visit our Roadmap on GitHub to follow our progress and contribute your ideas.
Feedback: We're interested in your thoughts about FlowFuse. Your feedback is crucial to us, and we'd love to hear about your experiences with the new features and improvements. Please share your thoughts, suggestions, or report any issues on GitHub.

Together, we can make FlowFuse better with each release!

Try it out

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse yourself via a variety of install options. You can find out more details here.

If you'd rather use our hosted offering: Get started for free on FlowFuse Cloud.

Upgrading FlowFuse

FlowFuse Cloud is already running 2.5.

If you installed a previous version of FlowFuse and want to upgrade, our documentation provides a guide for upgrading your FlowFuse instance.

Getting help

Please check FlowFuse's documentation as the answers to many questions are covered there. Additionally you can go to the community forum if you have any feedback or feature requests.

How to Use MQTT in Node-RED.

2024-06-05T00:00:00Z

Every day, factories generate terabytes of data from sensors, PLCs, and production equipment. Yet most of this data remains locked in silos, making it difficult to spot trends, prevent failures, or optimize operations. Manufacturers need a practical way to connect their equipment and get data flowing where it is needed most.

MQTT has become the industry standard for machine-to-machine communication because it is lightweight, reliable, and works even over limited bandwidth. When combined with Node-RED's drag-and-drop interface, engineers can create powerful data flows without writing complex code.

This guide walks through how to set up MQTT with Node-RED for industrial use cases—enabling real-time monitoring, alerting, and more.

Setting up your MQTT and Node-RED Environment

Setting up your MQTT Environment

In this guide, we will utilize the HiveMQ Cloud MQTT broker. We will use their free trial as we are learning, but if you want to use it for your project, make sure to use their correct cluster according to your needs. If you prefer to use another cloud platform, such as Mosquitto or EMqX, feel free to do so.

FlowFuse has also launched an MQTT broker service that is integrated directly into the platform, making it easy to use MQTT with Node-RED. For more information, check out FlowFuse's MQTT Broker Announcement.

Create your account with HiveMQ and log in.
After logging in, you will be asked to select a cluster. Choose the Starter cluster, then select the AWS Cloud provider and set the tier to Production S. Make sure to choose the correct region and proceed to create the cluster.
Now, click on Manage Cluster, then click on the Access Management option located at the top. Create credentials in the Authentication tab with the correct permissions.

Setting up your Node-RED Environment

For Node-RED, we will be using FlowFuse, which enhances Node-RED usage with managed instances, automated deployments, and real-time collaboration features, making it ideal for enterprise teams. It simplifies the configuration, monitoring, and operation of Node-RED applications.

Head to the FlowFuse sign-up page to create your new account and the FlowFuse login page to log in.
After successful login, you will see the Application and instance, which is added by default.
Click on that instance and then click on the editor URL to open the Node-RED editor.

Configuring MQTT Node in Node-RED

When you open the Node-RED editor, you'll see the MQTT nodes already installed as they are part of Node-RED core nodes. When you drag an mqtt-in or mqtt-out node onto the workspace, you need to configure the MQTT broker node. You can do this by Double-clicking the mqtt node, clicking on the edit icon next to the Server field, and entering the following details of your MQTT broker into the MQTT broker config node; for more information about mqtt nodes, refer to the MQTT core node docs.

Connection Tab

Enter the Server address from your HiveMQ cluster. For example: yourclustername.a02.usw2.aws.hivemq.cloud.
Set the Port to 8883 for secure connections in production. Use 1883 only for unencrypted testing.
Check the “Connect Automatically” option to allow Node-RED to reconnect if the connection drops.
Enable the “Use TLS” option to ensure the connection is encrypted. This is strongly recommended for production use.
Select MQTT Version 3.1.1 from the protocol version dropdown.
Leave the Client ID field blank to auto-generate one, or enter a specific ID if your broker requires it.
Keep the Keep Alive interval at the default value of 60 seconds unless your Application requires a different interval.
Uncheck “Clean Session” if you want Node-RED to receive messages that were sent while it was offline.

Security Tab

Enter the Username that you created in the HiveMQ Access Management tab. If you're using a different broker, use the appropriate username for that broker.
Enter the Password associated with that username.
Use environment variables for the username and password to avoid exposing sensitive information directly in the flow.

For more information, refer to Using Environment Variables in Node-RED.

Publishing Data to a Topic on MQTT Broker

Drag an mqtt-out node onto the canvas.
Double-click on the mqtt-out node and select the added broker configuration to which you want to send data in the server field.
In the topic field, enter the desired topic name.
Set the QoS to 2 for accurate and guaranteed data delivery.
Set retain to true if you want to retain the data.
Connect the node's output, which is emitting the payload data you want to send to the MQTT broker, to the input of the mqtt-out node.

Subscribing to a Topic on MQTT Broker

Drag an MQTT-in node onto the canvas.
Double-click on the MQTT-in node and select the appropriate added broker configuration from which you want to receive data in the server field.
Set action to subscribe to a single topic and enter the topic name to which you want to subscribe for receiving data in the topic field.
Set the QoS to 2.
Set the output to the desired format.
Connect the output of the mqtt-in node to the input of the node to whom you want to pass the data for further processing or analysis.

Deploying the Flow

To deploy the flow, click on the deploy button located at the top-right corner.

Tip: To ensure that your MQTT node is connected to the broker, check the node status. It will display 'connected' if the connection is successful.

Creating a Simple Project

Let’s build a practical temperature monitoring system to demonstrate how MQTT works in action. In this setup, one Node-RED instance will publish temperature data, and another will subscribe to and display it.

While MQTT is a reliable choice for communication across distributed systems, FlowFuse simplifies this even further with Project Link nodes. These nodes enable direct data sharing between Node-RED instances—no need to configure external MQTT brokers or manage topics. Just link your instances and start exchanging messages. Behind the scenes, Project Link still uses MQTT but abstracts away the setup. This makes it especially useful when prototyping or when fast, instance-to-instance communication is needed.

For this example, we will use MQTT directly to illustrate how it fits into production environments where standard, interoperable protocols are essential. If you are running Node-RED on edge devices, refer to our Raspberry Pi 4 guide for setup instructions.

Publishing Temperature Data to a Topic on the MQTT Broker

Drag an mqtt-out node onto the canvas and configure it with the MQTT broker to which you want to send data.
Enter "temp" in the topic field and set QoS to 2.
Connect the output of the node that is reading your temperature data to the input of the mqtt-out node.
Deploy the flow by clicking on the deploy button located at the top-right corner.

Subscribing to the Topic on the MQTT Broker to Receive Temperature Data

Now, create a new instance in which we will receive the temperature data by subscribing to the Topic. Refer to this guide, which shows how you can create a new instance in FlowFuse.

Drag an mqtt-in node onto the canvas, and configure it with the broker to which you are sending temperature data.
Enter "temp" in the topic field and set QoS to 2.
Drag a Debug node onto the canvas.
Connect the mqtt-in node's output to the Debug node's input.
Deploy the flow by clicking on the deploy button located at the top-right corner.

Now, you will see the temperature data printed in the debug tab in the sidebar. Additionally, you can display this data on a chart using FlowFuse Dashboard or store it in a database. For more details, refer to the following guides:

Best Practices

Ensuring the security and efficiency of your MQTT and Node-RED deployments is crucial for successful IoT projects. Explore these best practices to enhance your system's performance and protect your data.

SSL/TLS Encryption: Secure your MQTT communication by enabling SSL/TLS encryption. This ensures that data transmitted between devices and the broker is encrypted.
Authentication and Authorization: Implement strong authentication mechanisms to verify the identity of clients connecting to the broker. Additionally, enforce access control policies to restrict clients' actions based on their roles and permissions. For instance, you can allow specific clients to only publish or subscribe to data as needed.
Environment Variables: Utilize environment variables to prevent exposing your sensitive configuration data within the flow.
Quality of Service (QoS) Levels: Choose the appropriate QoS level for your MQTT messages based on the reliability requirements of your Application. Higher QoS levels ensure message delivery but may incur increased network overhead.
Payload Size Optimization: Optimize the size of MQTT message payloads to minimize bandwidth usage and improve network efficiency. Transmit only essential data and consider compressing payloads when applicable to reduce transmission times.

Conclusion

This guide showed how MQTT and Node-RED enable reliable industrial data communication. By following these patterns, manufacturers can connect diverse equipment and build real-time monitoring systems without complex custom code.

Start with one production line, prove the value, then scale across your facility using the same proven approach.

As you grow, you may face common challenges: managing multiple Node-RED instances, coordinating team changes, ensuring uptime, and handling backups. That’s where FlowFuse helps.

It adds:

Centralized instance management
Easy scaling and deployment
Remote device management
Automatic backups and version control
Seamless team collaboration without conflicts
Enterprise-grade security (SSO, audit logs, RBAC)
High availability for 24/7 operations
Expert support when needed
And much more

Your Node-RED flows work the same—FlowFuse just makes them easier to manage and production-ready.

Start your free trial and see why manufacturers choose us for scaling with confidence.

Exploring Node-RED Dashboard 2.0 Widgets

2024-05-27T00:00:00Z

This guide delves into Node-RED Dashboard 2.0 widgets. It is a guide on how to build a Dashboard application, and will cover many of the widgets available today.

If you're new to Dashboard 2.0, we recommend starting with the Getting Started with Dashboard 2.0 guide and make sure to install it.

What Are Widgets?

Widgets in Node-RED Dashboard 2.0 are the building blocks for creating a user interface. In Dashboard 2.0, you get a variety of widgets like forms, templates, buttons, and others to make different parts of your interface.

Building Applications with Dashboard 2.0 Widgets

Income-expense tracker build with dashboard 2.0

In this guide, we'll create a basic application to input expenses and income. This will then be displayed in a chart and table for analysis. The application will utilize a wide range of widgets available in Dashboard 2.0, helping you understand and use them confidently.

Adding Forms

For the income and expense submission, we'll incorporate a form using the ui-form widget.

Drag the ui-form widget onto the canvas.
Double-click on it to access various widget properties and select the ui-group where it should render.
Add "date", "description", "amount", and "note" form elements by clicking the +element button at the bottom left.

Screenshot displaying Income submission ui-form's configuration

Once you've added the income submission form, repeat the process to add an expense submission form on another ui-page and ui-group. For more information on ui-form, refer to the ui-form docs.

Screenshot displaying Expense submission ui-form's configuration

Storing Form Data

The ui-form widget emits a payload object with key-value pairs of form elements upon submission. We'll store this data in a global context, If you are not familiar with Node-RED context, refer to Understanding Node-RED varriables.

Drag a function node onto the canvas and add the following code. This will store the submission in the income global context variable, and then modify msg.payload to pass on a notification to any further connected nodes.

// Retrieve the existing 'income' array from the global context, or initialize it as an empty array if it doesn't exist
let income = global.get('income') || [];

// Push the incoming payload along with a 'type' property set to "income" into the 'income' array
income.push({
  ...msg.payload,
  type: "income",
});

// Store the updated 'income' array back into the global context
global.set('income', income);

// Set the message payload to a confirmation message for notification
msg.payload = "Thank you for submitting income!";

// Return the modified message
return msg;

Similarly, you can do this for storing expense data submitted using the expense submission form.

Displaying Notifications

For displaying notifications on the dashboard, we'll utilize the ui-notification widget, which emits notifications to the user's dashboard. It accepts msg.payload which should be a string format or raw HTML/JavaScript for custom formatting.

Drag the ui-notification widget onto the canvas.
Set the position property to center. You can also adjust colors or notification timeout by modifying the color and timeout properties. Please take a look at the ui-notification docs for more information on ui-notification.

Screenshot displaying ui-notification widgets configuration

Listening for events

In Dashboard 2.0, the ui-event widget allows you to listen to user behavior or events. It does not render any content or components on the dashboard. Currently, this widget only listens for page views ($pageview) and leave ($pageleave) events.

With this, we can listen for page view and page leave events and trigger tasks based on those events. For instance, in our application, we will be displaying a table containing income and expense data, along with a chart. We'll update them when navigating to a new page or leaving a page.

Drag an ui-event widget onto the canvas.
Double-click on it and select the correct ui-base of your application.

For more information on ui-event refer to ui-event docs.

Retrieving Income-Expense Data

In our income-expense application, we will display the income and expenses in a single table.

Drag a change node onto the canvas.
Set msg.payload to the JSONata expression below, which merges the income and expense arrays.

[$globalContext('income'), $globalContext('expense')]

Connect the output of the ui-event widget to the input of the change node.

Screenshot displaying the change node setting JSON expression to payload for retrieving and sorting data.

Displaying Data on the Table

To display data on the table, we use the ui-table widget in Dashboard 2.0. This widget accepts an array of objects as input. The columns in the table correspond to the properties of the objects within the array, and each row represents a different object with values corresponding to those properties.

Drag a ui-table widget onto the canvas.
Create a new ui-page and ui-group for it.
Connect the output of the change node to the input of the ui-table widget.

Screenshot displaying the ui-table widget configuration

For more information on ui-table refer to ui-table docs

Calculating total category-wise

In our application, we will display data on the chart, showing the total income and total expenses for analysis. In this section, we will calculate the total expenses and income using the function node.

Drag the two change node onto the canvas.
For the first Change node Set msg.payload to global.income and msg.topic to "income" and give it name "retrive income". For the second Change node, set msg.payload to global.expense and msg.topic to "expense" and give that second change node name "retrive expense".

Screenshot displaying the change node retrieving income data from global context

Screenshot displaying the change node retrieving expense data from global context

Drag a Split node onto the canvas.
Drag the Change node onto the canvas and set msg.payload.amount to the JSONata expression $number(payload.amount) and give it name "Convert amount to number".

Screenshot displaying the change node converting amount to number

Drag a Join node onto the canvas, select mode as reduced expression, and set the Reduce exp to $A + payload.amount. Set Initial value to 0, and Fix-up exp to $A. Give this join node the name "Calculate total". This function operates similarly to using the javascript reduce method on an array to calculate the sum of its values. $A stores the accumulated value, and with every incoming message payload, it adds the payload.amount value to it, for more details on this refer to the core node docs on join node.

Screenshot displaying the join node calculating the total income and expense data

Drag an another join node onto the canvas set mode to manual, combine each to complete message, to create to array and After a number of message parts to 2 and give it name "combine two objects into array".

Screenshot displaying the join node combining the income and expense object into the array

Connect the output of the ui-event widget to the input of the Change node named "Retrieve Income" and "Retrieve Expense". Then, connect the outputs of the "Retrieve Income" and "Retrieve Expense" Change nodes to the input of the Split node.
Next, connect the output of the Split node to the Change node named "Convert Amount to Number". Afterward, connect the output of that Change node to the input of the Join node named "Calculate Total". Finally, connect the output of the "Calculate Total" Join node to the input of the Join node named "Combine Objects into Array".

Displaying data on the chart

To display charts on the dashboard, we have to use the ui-chart widget which allows us to display different types of charts on a dashboard including linear, bar, scatter, etc. This accepts an array and object as input.

Drag a ui-chart widget onto the canvas.
Double-click on the widget and select Type as bar.
Configure the series to category and the y-axis to amount. This configuration informs the chart that the amount property of the input objects will be plotted on the y-axis and category to the x-axis of the chart.
Connect the output of the join node named "Combine Objects into Array" to the ui-chart widget's input.

Screenshot displaying the ui-chart widget's configuration

With the ui-template widget, we can add a custom component to our app using Vue.js. It also allows adding custom CSS for the dashboard and lot of other things. For more information refer to ui-template docs.

Using this widget, we will add a footer to our application.

Drag an ui-template widget onto the canvas.
Set the widget type (scoped UI) that will render this widget on the entire dashboard, eliminating the need to add separate footers for each page of the dashboard.
Insert the following vue.js code in the ui-template widget.

<template>
  <!-- Footer Component -->
  <div class="footer">
    <!-- Description of the Income-Expense Tracker -->
    <div>
      Welcome to our comprehensive income expense tracker! Take control of your finances by monitoring your income and
      expenses effortlessly. Our user-friendly interface makes it simple to record transactions, categorize expenses, and
      analyze your financial trends. With real-time insights into your spending habits, you can make smarter financial
      decisions and achieve your money goals faster.
    </div>
    <!-- Copyright Information -->
    <div class="copyright">
      <!-- Display Current Year and Copyright Information -->
      2024 — <strong>Vuetify</strong>
    </div>
  </div>
</template>
<style scoped>
  /* Make the footer occupy all available space */
  .footer {
    position:absolute;
    bottom:0;
    background-color:rgb(26,26,26);
    color:rgb(238,238,238);
    height:130px;
    text-align:center;
    padding:14px;
  }

  .copyright{
    margin-top:10px;
  }
</style>

Deploying your application flow

Deploy the flow by clicking the top right Deploy button.
Locate the *Open Dashboard button at the top-right corner of the Dashboard 2.0 sidebar and click on it to navigate to the dashboard.

Now that we've built an income-expense tracker application and gained a basic understanding of Dashboard 2.0 widgets for building dashboards.

Up next

If you want to enhance this simple application by adding more features or want to make the application personalize for users, consider the following resources:

Webinar - This webinar provides an in-depth discussion of the Personalised Multi-User Dashboards feature and offers guidance on how to get started with it.
Comprehensive guide: Node-RED Dashboard 2.0 layout, sidebar, and styling - This comprehensive guide will cover everything about Node-RED Dashboard 2.0 styling, layouts and sidebars.
Displaying logged-in users on Dashboard 2.0 - This detailed guide demonstrates how to display logged-in users on Dashboard 2.0 which using the FlowFuse Multiuser addon and FlowFuse.
How to Build an Admin Dashboard with Node-RED Dashboard 2.0 - This detailed guide demonstrates how to build a secure admin page in Node-RED Dashboard 2.0.
How to Build An Application With Node-RED Dashboard 2.0 - This guide, covers how you can build personalize multiuser dashboard using flow fuse multi-user addon.
Multi-User Dashboard for Ticket/Task Management blueprint - this blueprint allows you to utilize templates to develop a personalized multi-user dashboard quickly. This Task management blueprint has all features such as adding, updating, and deleting tasks, user profiles, and admin dashboard.

If you are looking to build a multi-user dashboard, deploy it in seconds, scale and manage Node-RED efficiently, and enable seamless remote access for your entire team, sign up for FlowFuse and get started today!

Looking to build a multi-user dashboard, deploy it in seconds, scale and manage Node-RED efficiently, and enable seamless remote access for your entire team?

Why you need a low-code platform

2024-05-22T00:00:00Z

Digital transformation is a series of technological advancements that aim to simplify complex tasks. From calculators and graphical user interfaces (GUIs) to new programming languages, these advancements have enabled individuals to create value that was once beyond their reach. The key is to understand that these tools are not meant to replace expertise but to enhance it, making complex tasks more manageable, speeding up development time, and empowering more people.

What Does It Mean to Empower Someone?

Often, people perceive "empowerment" as a derogatory term, but it shouldn't be. Empowerment should mean enabling a domain expert to further grow their expertise. They are adding one more tool (and hopefully replacing some) to their toolbox to bring value to what they know. And what they know is often hard to explain. It has taken years to master their role, which people usually take for granted because they don't understand the complex dance they do to make their section of the world operate flawlessly.

What Do They Do, and Why Is It Hard to Explain?

Imagine a simple project like building a tire swing. The humorous illustration below shows how different interpretations and outcomes can arise throughout a project lifecycle:

This analogy highlights the potential misunderstandings and miscommunications that occur between various stakeholders in a project. From the initial customer explanation to the final product, each stage can introduce variations that stray from the original intent. This leads to a final outcome that often doesn't meet the customer's needs or expectations.

In a perfect world, with clear instructions and years of prep work to define the problem statement, there's a chance the project will be completed close to 95% of what the domain expert wanted, if you're lucky. But how do you close the last 5%? Developers might move on to new projects, or worse, leave the company. The remaining tasks become difficult to complete and often go undone.

Put the Domain Expert in the Driver’s Seat

Calculators were not created to be used only by mathematicians. GUIs weren't created to be used only by programmers. They were created to make people's lives easier. No longer was there a need to use the command line to start an application; simply click the icon for the desired application. These simple iterations open the opportunity for a larger range of people to leverage tools.

With low-code applications, the process is the same. Put the domain expert in the driver’s seat. Make them their own developer. They understand the process better than anyone else. Pair them with a low-code domain expert and have them co-develop the application.

With the domain expert in the driver’s seat of their own low-code project, the days of the last 5% undone become less common. There is always a path forward.

Which Low-Code Solution Should You Go With?

With over 10 years of development emerging from IBM’s Emerging Technology Group, Node-RED is a clear leader. Dare I say the de facto solution. It is open-source and easy to spin up. It is currently being leveraged in many industries; ranging from pharmaceuticals, to agriculture, and to telecom.

But you might think Node-RED is just a proof-of-concept tool. You’re wrong. Has it been used as Shadow-IT? Yes, and that is beautiful and awesome. Innovation is at the heart of Shadow-IT. No one ever said, “There is a tool supported by my IT company that would be perfect for the job, but I think I would rather deploy an unsanctioned tool.” The flaw in this statement is believing there is a choice in tools. Node-RED has often been the only tool available in the domain expert's toolbox.

Increased Development Speed

Domain experts often find themselves needing to develop solutions but learning a new programming language can be time-consuming. With the open-source community behind Node-RED, many common integrations and transformations have already been created. This community sharing of knowledge accelerates development because often a needed programming task has already been developed and shared. This allows domain experts to repurpose existing code as nodes, flows, or collections, significantly speeding up the development process.

FlowFuse

FlowFuse is your solution to solving Shadow-IT and paving the way for your Citizen Development journey. All the reasons why Node-RED hasn’t been sanctioned within organizations have nothing to do with its ability to execute but more with its lack of scalability, easy-to-use security, and manageability. Enter FlowFuse, developed by the same people who developed your go-to low-code solution. FlowFuse addresses exactly the problems that put it in the Shadow-IT realm.

With security and scalability top of mind, FlowFuse allows IT teams to manage their Node-RED deployments with features like Role-Based Access Control (RBAC), remote management of Node-RED runtimes, and backup and recovery of Node-RED deployments called Snapshots. These are just a few of the features that elevate an already widely used solution, making it ready for enterprise networks.

Low-code platform success in the real world

Low-code platforms are industry-agnostic, with applications varying from industrial manufacturing to news agencies. Here are some customer success stories of how the FlowFuse low-code platform has helped:

Abrasive Technology: Leveraged Node-RED and FlowFuse to optimize automation and improve operational efficiency. The transition to FlowFuse Cloud has enhanced their ability to manage Node-RED instances effectively, supporting innovation and agility in their manufacturing processes.
Power Workplace: Utilized FlowFuse and Node-RED to automate building management, significantly reducing development time and enhancing scalability and reliability. This has helped them meet security and compliance requirements more easily, improving service delivery across multiple regions.
Large US Manufacturing Company: Employed Node-RED and FlowFuse to drive digital transformation across numerous manufacturing sites. By decentralizing innovation, they have improved data visibility, real-time decision-making, and overall process efficiency, using FlowFuse to manage extensive Node-RED deployments and version control.

The Low-Code Future

In conclusion, low-code platforms like Node-RED and FlowFuse empower domain experts to take control of their own digital transformation journeys. By putting the domain expert in the driver’s seat, low-code applications enable them to create solutions tailored to their specific needs and requirements. This approach not only reduces the risk of the last 5% of a project going undone but also fosters a culture of innovation and collaboration within organizations.

Product Mission Statement and Strategy Updates

2024-05-14T00:00:00Z

It's now been two years since our first ever 0.1.0 release of FlowFuse. In that time, we've been working hard to build out a platform to help users elevate their Node-RED experience. In that time we've delivered some incredibly valuable features to FlowFuse users such as centralized instance management, remote deployments and version control. We've also learned a lot about our users, their needs, and how we can best serve them, and in a recent reflection on our product strategy decided to refine our product mission statement.

Product Mission Statement

FlowFuse is used across a range of industries and use-cases, and in the hundreds of conversations we've had with customers, we've found that in every scenario there is a common pattern. So, to reflect ths, we've created a new Product Mission Statement, to make it clear to existing and prospective users of FlowFuse what it is that we're striving for.

Our new mission statement is as follows:

Provide the best way to build, manage and deploy Node-RED applications at scale, in reliable and secure production environments.

We believe that by focusing on this mission, we can better serve our users and provide them with the tools they need to succeed. This mission statement will act as the north star for our product prioritization moving forward, and be our compass to ensure we're staying on track in delivering value to our users.

Build

FlowFuse strives to be the best place to build Node-RED applications by providing tools to help users build applications with more confidence.

Simplified Hosting: Whether you want cloud-hosted instances, or to run Node-RED on edge devices, FlowFuse provides the smoothest experience to setup new Node-RED instances.
Trust: Certified Nodes ensure Node-RED developers can trust the reliability, quality and security of third-party nodes they're using in their applications.
Version Control: Snapshots capture point-in-time views of Node-RED flows, environment variables and other configuration settings. We even capture automatic snapshots of your flows every time you deploy, so you can always be confident you have a backup.
Collaborative Development: We are building FlowFuse to be a platform that enables teams to work seamlessly together on Node-RED applications. From the Team Library, through to Node-RED Multiplayer, we want to make sure that FlowFuse is the best platform for collaborative development in Node-RED.
Remote Access: FlowFuse provides a secure way to access your Node-RED instances and devices from anywhere in the world, so you can build and debug your applications with ease.

Manage

With FlowFuse, it's possible to manage thousands of Node-RED instances, all in one place. We make sure you have a clear picture of what's happening across all of your instances, and provide tools to help you manage them effectively.

Centralized Management: FlowFuse provides a single entry point to manage all of your Node-RED instances, no matter where they are hosted.
Security: FlowFuse provides a range of security features to help you keep your Node-RED instances secure. From Two-Factor Authentication to Role-Based Access Control, we're building FlowFuse to be the most secure way to manage your Node-RED instances.
Frictionless Maintenance: Whether you're updating your Node-RED version, or one of the many third-party dependencies that your applications depend upon, FlowFuse provides tools to make it easy to keep your instances up-to-date and running smoothly.
Observability: FlowFuse provides tools to help you keep an eye on your Node-RED instances and make sure they're running smoothly. Get alerts when something goes wrong, and use the Audit Logs to help you debug issues when they arise.

Deploy

With FlowFuse, we aim to provide the best way to deploy Node-RED applications to production environments, whether that be to hundreds of remote devices, or via staging environments to ensure you can deploy with confidence.

DevOps: Test your applications in development and staging environments, ensuring you can deploy them with confidence to production.
Remote Deployments: Deploy your applications to hundreds of remote devices with a single-click, ensuring you can get your applications running in production quickly and easily.
Reliability: FlowFuse users can have trust that their applications will run without issues with features like High Availability. FlowFuse makes sure users have the tools to monitor and manage the reliability of their applications, including being alerted when things go wrong, and making the recovery as easy as possible.

What's Next?

Our development team are busy working on a range of new features to help us deliver on our mission. If you're interested to see what highlight features we're working on for the next release (v2.5) in four weeks time, you can checkout our Development Board on GitHub.

For longer term planning, we have our Product Planning Board, which outlines the features we're working on for the next 12 months. It's subject to change, as we're always iterating, but it gives a good idea of where our focus will likely be in the coming months.

In the mean time, please do reach out if there are any features you'd like to see in FlowFuse, or if you have any feedback on our product strategy. We're always keen to hear from our users and learn how we can better serve you.

If you're interested in learning more about our company and product strategies, you can read more detail in our Handbook:

The MIND stack with Node-RED and FlowFuse Dashboard 2.0

2024-05-14T00:00:00Z

The MING stack has gained significant popularity over the years as it built upon open-source projects. That has given way to many people leveraging this stack to build solutions upon in various different environments. The MING stack is composed of 4 main components, MQTT, InfluxDB, Node-RED, and Grafana. Combined together are the 4 main pillars, data transportation, data storage, data transformation, and visualizations. With this, it requires the management of 4 different applications, which often reside on the same server, but not necessarily. With more moving parts, creates complexity.

FlowFuse: Integrated IoT Deployment

With FlowFuse we have bundled up 3 of those 4. First and foremost, the FlowFuse platform deploys Node-RED in two main ways. A cloud based deployment and remote deployment with management from the FlowFuse platform. Part of this management piece leverage MQTT between the devices for management. Because of this we have a built in MQTT broker that allows for communication between Node-RED instance within the FlowFuse platform. Lastly, with the release of Dashboards 2.0 from FlowFuse we have introduced the next generation of visualizations for the Node-RED platform.

It often makes sense to deploy a full MING stack, but in some deployments, it might be necessary to deploy a more simplistic version of the MING stack. This is where MIND comes into play.

FlowFuse MQTT: Simplified Communications

FlowFuse has a built-in feature called project link nodes, which leverages MQTT, that allows the communication of data between FlowFuse runtimes of Node-RED. One caveat is that this MQTT broker is only available within the FlowFuse platform. What this means is there needs to be some form of translation to be done within Node-RED. This isn’t a big deal for small deployments, because often Node-RED runtimes at the edger are collecting data from various sources that aren’t MQTT. The flow of data is as follows:

Sensor > Node-RED(FlowFuse Device Agent) > MQTT Encapsulated by FlowFuse > Node-RED(FlowFuse Platform) > InfluxDB

Node-RED(FlowFuse Device Agent) > MQTT Encapsulated by FlowFuse > Node-RED(FlowFuse Platform) > InfluxDB"" loading="lazy" decoding="async" src="https://flowfuse.com/img/sensor-data-mqtt-node-red-dashboard-influxdb-C_RhRpco9v-1654.jpeg" width="1654" height="593" />

A key benefit of having the MQTT broker encapsulated by FlowFuse is that it becomes extremely easy to set up. With the project nodes, there isn’t a need to configure certificates or security credentials because it is only exposed internally to the FlowFuse platform. Furthermore, the access and control limits are applied by the platform so your data remains within the same FlowFuse Team.

InfluxDB: Efficient Data Storage

The deployment of InFluxDB doesn't change in the MIND configuration. The only significant change is that InFluxDB is deployed higher up in the architecture and closer to the FlowFuse Platform instead of the edge.

Data Visualization with Dashboard 2.0

FlowFuse's Dashboard 2.0 makes it incredibly easy to visualize your data. You can create beautiful and informative dashboards in minutes. Simply drag and drop your desired widgets onto the canvas, and configure them with a few clicks.

We have gone through the step of providing you with an example dashboard for visualizing your MIND stack.

This dashboard example allows you to do quick visualizations of data from an InfluxDB. In this particular case, it leverages the Relative Humidity (RH) and Temperature of a sensor. It captures the data and stores in InfluxDB and then visualizes it in Dashboard 2.0. Use this as a starting point to display data in the MIND stack.

Advantages of FlowFuse’s MIND Stack

FlowFuse provides built-in features, such as MQTT, backups, deployment pipelines, and access control, helping to protect data and devices from unauthorized access. FlowFuse simplifies the MING stack to the MIND deployment, bringing numerous benefits to organizations. It reduces the complexity of managing multiple components, minimizing configuration, update, and maintenance overhead. The single platform approach for MQTT, Node-RED, and visualization simplifies maintenance tasks, lowers the risk of conflicts, and ensures consistency. FlowFuse's lighter deployment requires fewer hardware resources, making it suitable for resource-constrained environments or cost-sensitive projects. Organizations can potentially save on licensing and maintenance costs by reducing the number of deployed software components. Faster deployment is enabled with fewer components to set up and configure, allowing projects to realize value sooner. FlowFuse's scalable architecture handles large data volumes and devices, ensuring suitability for growing IoT deployments.

Conclusion

While we believe that the MING stack is here to stay, we believe as the market matures, it should offer many different variations suitable for each customer's needs. However, we find that the MIND offering does fill a niche in the market that may better suit your needs. None the less, choosing FlowFuse to manage your Node-RED runtimes will ensure that your applications will be secure, scalable, and easily manageable. Allowing your domain experts to take control and extend their knowledge bringing increased value to industrial facilities around the world.

Optimize your factory operations with FlowFuse. Effortlessly manage, deploy, scale, and secure your Node-RED instances.

Mapping location data within Node-RED Dashboard 2.0.

2024-05-13T00:00:00Z

Fleet management in IoT uses sensors and software to collect real-time data on vehicles, such as location, fuel consumption, and driver behavior. This data allows companies to optimize routes, reduce costs, improve safety, and enhance overall operational efficiency of their fleet. Building an application that allows the tracking of location to support Fleet management is what this post is about.

Before moving further, make sure you have installed Dashboard 2.0. If you are new to Dashboard 2.0, please refer to Getting Started with Dashboard 2.0 for more information.

Installing world map custom node

To render an interactive world map webpage for plotting location data, we will use a popular custom node called node-red-contrib-web-worldmap-page. This node offers extensive features enabling us to render a world map and plot various items with different icons, colors, NATO symbologies, ranges, and more.

Click the Node-RED Settings (top-right).
Click "Manage Palette".
Switch to the "Install" tab.
Search for node-red-contrib-web-worldmap.
Click "Install".

Retrieving location Data

Before plotting locations, we need to obtain the data first. For this purpose, we will utilize the Edenburg Open Public Transportation API. This API provides the live locations of all of Edenburg's public buses and trams, enabling us to access the necessary data for plotting on Worldmap within Dashboard 2.0.

Drag an Inject node onto the canvas and set the repeat property to a 20-second interval.
Drag an HTTP request node onto the canvas, Dobule-click on it and choose GET method, and enter https://tfe-opendata.com/api/v1/vehicle_locations in the URL field and select return as a parsed json object. This API is public, so no need for environment variables. For private APIs, consider using environment variables for security.

Connect the Inject node's output to the HTTP request node's input.

Formatting Location Data

To ensure compatibility with the Worldmap custom node, we need to format the location data appropriately.

Drag the Change node onto the canvas, and set the msg.payload to msg.payload.vehicles, and give it name Set payload.

Drag a Split node onto the canvas.
Add another Change node to the canvas. Configure it to set and delete properties as shown in the image below, and give it name Change and delete properties. By changing and deleting properties of the location, we ensure that only the properties acceptable by the Worldmap node are included in the location data.

Drag a Switch node onto the canvas and add conditions to check if msg.payload.vehicle_type is equal to tram or not.

Add another Change node to the canvas and give it a name set icon and icon color for tram. Set msg.payload.icon to fa-train and msg.payload.iconColor to yellow.

Add another Change node to the canvas and give it a name set icon and icon color for bus. Set msg.payload.icon to bus and msg.payload.iconColor to red.

Connect the HTTP request node's output to the input of the Change node named Set payload, and connect the output of that Change node to the input of the Split node.
Then, connect the output of the Split node to the input of the Change node named Change and delete properties, and connect the output of the "Change and delete properties" node to the input of the Switch node. Then Switch node's first output to the input of the Change node named set icon and icon color for tram, and its second output to the input of the Change node named set icon and icon color for bus.

Plotting location data on Worldmap

Drag a Worldmap node onto the canvas. Set the path to /worldmap and keep the rest of the settings unchanged, although you can modify other properties according to your preferences.

With the worldmap node configured, it will generate a world map with plotted data accessible at the specified path.
Connect the Function node's output to Worldmap node's input.

Now we have successfully created a page with a world map displaying plotted vehicle location data. To confirm, you can visit https://<your-instance-name>.flowfuse.cloud/worldmap.

Rendering map on Dashboard 2.0

To render worlmap webpage on dashboard 2.0 we will use iframe custom widget which will allow us to embed an external webpage into Dashboard 2.0 applications using an iframe.

Click the Node-RED Settings (top-right)
Click Manage Palette
Switch to the Install tab
Search for @flowfuse/node-red-dashboard-2-ui-iframe
Click Install

Rendering worlmap on Dashboard 2.0

Drag an iframe widget onto the canvas.
Select ui-group and ui-base for it, where you want to render the webpage.
Set height and width for it according to your preference and set URL to /worlmap.

Deploying the flow

With your flow updated to include the above, click the Deploy button in the top-right of the Node-RED Editor.
Locate the Open Dashboard button at the top-right corner of the Dashboard 2.0 sidebar and click on it to navigate to the dashboard.

Now you can view the live location of Edinburgh public transport vehicles on the dashboard. Additionally, clicking on each vehicle reveals further details such as its name, speed, and other properties you've included. Moreover, if you wish to track the live locations of your own vehicles instead of Edinburgh's public transport vehicles, you can connect your devices and access GPS and sensor data using the Flowfuse device agent.

Conclusion

In conclusion, this guide shows an easy way to map location data on Dashboard 2.0. By following these steps, you can make interactive dashboards that give you real-time info, useful for things like managing fleets and tracking logistics.

Looking to build a multi-user dashboard, deploy it in seconds, scale and manage Node-RED efficiently, and enable seamless remote access for your entire team?

Comprehensive guide: Node-RED Dashboard 2.0 layout, sidebar, and styling

2024-05-10T00:00:00Z

In this comprehensive guide, we will explore different layouts and sidebar styles in Dashboard 2.0. Additionally, we will cover how you can style Dashboard 2.0 elements effortlessly.

If you are new to Dashboard 2.0, refer to Getting started with Node-RED Dashboard 2.0 and make sure you have installed it.

Understanding Dashboard 2.0 layouts.

A layout in Node-RED Dashboard 2.0 refers to how groups of widgets are organized and arranged on a page. It controls the visual structure and placement of these widget groups to create an organized and easy-to-use interface.

Exploring Dashboard 2.0 layouts

In Dashboard 2.0, we have three types of layouts: Grid, Notebook, and Fixed.

Grid layout

Choosing this layout divides your dashboard page into 12 equally-sized columns, and you can specify how many columns your group will occupy using the size property. When groups within a row take up all available columns, a new row automatically starts. The height of each row is determined by the tallest widget in that row.

In the image above, you can see that the first and last widget groups occupy all 12 columns, while in the middle, two groups each take up six columns.

Notebook layout

Choosing the Notebook layout for your page in Dashboard 2.0 makes it work like a Jupyter Notebook, fixed at a width of 1024px and centered. Here, a groups' "width" defines the number of columns the group contains. The group itself will always render the full width of the Notebook. It's great for dynamic Markdown, data tables, and visuals. Groups of pages are stacked vertically.

Fixed layout

In this layout, the width value is converted to "units", with each unit being 90px wide. For example, if you set the group width to 3, it will be 3 * 90 = 270px wide. Within a given group, the group size represents a column in the group's internal grid, following the same pattern as other layouts.

Note: Currently this layout is not optimised, with plans to make it similar to Dashboard 1.0 in how it compresses content vertically, so it is recommended to use other layouts.

Setting page layout

Navigate to the page configuration by clicking on the edit button of your page in the Dashboard 2.0 sidebar.
In the page configuration, you can select the preferred layout for that page within the layout field.

Setting Dashboard 2.0 elements size

Setting the size for elements in Dashboard 2.0 is straightforward, but understanding the actual unit size in the size property can be a bit tricky.

It's important to note that the size of a single horizontal unit varies depending on the layout, but the vertical size of a single row is consistently 48px.

Sizing Widgets within a Group

In any layout—Grid, Notebook, or Fixed—widgets within a group are sized using a unified approach. The size property assigned to widgets determines their width within the group. Each unit in the size property represents a fraction of the group's total width. This width is determined by an internal grid established by the group.

Widgets are sized relative to the number of columns in the internal grid. For example, if a group has 4 columns and two widgets, and the first widget is set to 1 width while the second to 3 width, the first widget will occupy 25% of the group's width, and the second widget will occupy 75%.

Regardless of the layout type, the concept of sizing widgets within a group remains consistent. Whether it's the grid, notebook, or fixed layout, the same principles apply, ensuring uniformity in widget layout and design.

Setting element size

To set the size of groups and widgets in Dashboard 2.0, follow these steps:

Go to the Dashboard 2.0 sidebar and click on the edit button next to the element you want to resize.
Adjust the size using the size property.

Understanding Dashboard 2.0 Theme

The theme is a collection of colors that control the look and feel of the widgets, groups, and other elements on the page.

In Dashboard 2.0, when adding a page ( ui-page ) we can specify which theme it will use. By default, we have one theme in Dashboard 2.0, we can add more themes using the Dashboard 2.0 side panel.

Understanding theme properties

In the theme (ui-theme) configuration, there are two main sections:

Colors: Specify colors for Navigation, primary elements, page background, group backgrounds, and outlines.
Sizing: Define the gaps between groups, page padding, group outline radius, and gaps between widgets, all in pixels.

For additional information on the ui-theme settings, please refer to the ui-theme documentation.

Setting a new page theme

Navigate to the Dashboard 2.0 sidebar and switch to the theme tab.
Click on the top-right “+theme” button to add a new theme.
After specifying colors and sizing click on the top right update button to save the theme.
Now switch to the layout tab and click on the edit button next to the page for which you want to set a new theme.
In the page config, select the newly added theme in the Theme field.

Navigate to the Dashboard 2.0 sidebar in the Node-RED editor
Click on the "Edit Settings" button located at the top left side of the Dashboard 2.0 sidebar.
Select your preferred sidebar style from the "Style" field in the sidebar options section.

In Dashboard 2.0, we have 5 different navigation options for your application.

Collapsing

This is the default sidebar, when it's opened, the page content adjusts to the width of the sidebar.

You can see in the image above how the page content automatically adjusts when the sidebar is opened.

Fixed

In this type, the sidebar is always visible and fixed on the left side, and the top menu icon is hidden. The page content adjusts to the width of the sidebar.

Collapse to icon

This type of sidebar is similar to the collapsible one, but when the sidebar is collapsed, you can still navigate through different pages as the page icons become visible.

Apear over content

When the sidebar is opened, the page is partially covered by a transparent layer, and the sidebar appears on top of this layer

In this type of sidebar, you can notice how the sidebar opens without affecting the width of the page content

Always hide

In this type, the sidebar is always hidden, and navigation between different pages can be achieved using the ui-control widget.

Customising your Dashboard 2.0 further

In Dashboard 2.0, we can add classes to almost all widgets, pages, and groups and style them using CSS.

Adding classes

To add classes to your widget, page, or group, you'll need to open its configuration
Find the 'Class' field and enter your class.

Writing custom CSS

In Dashboard 2.0, the ui-template node allows you to write custom CSS for Dashboard 2.0.

In the template node, you can add CSS for two different scopes:

Single Page: Selecting this allows you to specify CSS that is constrained to a single page of your dashboard.
All Pages: Selecting this allows you to define CSS that will apply across your whole dashboard.

To define your own CSS:

Drag an ui-template widget onto the canvas.
Double-click on it and select the scope within the type field.
If you select the "CSS (Single Page)" type, you'll then need to select the ui-page to which your custom class definitions will apply. If you select the "CSS (All Pages)" type, then you'll need to select the ui-base that includes those pages to which you want to add styling.
Now you can write your custom CSS within the ui-template.

Up Next

To delve deeper into Node-RED Dashboard 2.0, we recommend exploring the following resources:

FlowFuse Dashboard Articles - Collection of examples and guides written by FlowFuse.
Node-RED Dashboard 2.0 Documentation - Detailed information for each of the nodes available in Dashboard 2.0, as well as useful guides on building custom nodes and widgets of your own.
Node-RED Forums - Dashboard 2.0 - The Node-RED forums are a great place to ask questions, share your projects and get help from the community.
Beginner Guide to a Professional Node-RED - A free guide to an enterprise-ready Node-RED. Learn all about Node-RED history, securing your flows, and dashboard data visualization.

Looking to build a multi-user dashboard, deploy it in seconds, scale and manage Node-RED efficiently, and enable seamless remote access for your entire team?

FlowFuse 2.4: making it easier to work with Snapshots, Blueprints & Devices

2024-05-09T00:00:00Z

FlowFuse 2.4 introduces better ways to work with Snapshots, Blueprints, view the content of you flows in FlowFuse, and manage the version of Node-RED running on Devices

Export Snapshots from FlowFuse #3627

You can now export your Snapshots of your Node-RED instances. This is our first step towards making it easier to move Snapshots in and out or your FlowFuse projects, as well as share them with other teams. We will be adding many more Snapshot management features over the next few releases.

Easier creation of Node-RED instances from Blueprints #3729

We introduced our library of Node-RED Blueprints in October 2023. FlowFuse Blueprints aim to make the Node-RED experience more accessible for newcomers, while also offering a treasure trove of fresh ideas for seasoned Node-RED users. In this release, we are making it even easier to start a new Node-RED instance based on a Blueprint from our library.

View Flows within the Team Library without loading Node-RED #3803

In September 2023, Node-RED community member gorenje created some code that could be used to visualise Node-RED flows without having to load the full Node-RED editor. This was added to the community flow library and has proven to be a great addition.

With gorenje's support, we've packaged up his library to make it easier to embed in other sites and have made it generally available here. A big thanks to gorenje for laying the ground work and allow us to build on it.

We've wasted no time putting this to good use within FlowFuse. Our first step is in our Team Library. You can now view a visual representation of saved flows in your Team Library.

View Flows within Snapshots without loading Node-RED #3798

The second place we are adding the ability to preview flows is to the Snapshots interface. Again, based on node-red-flowviewer-js, the Flow Viewer will make loading the snapshot you need into your Node-RED instance quicker and easier.

Manage Node-RED versions on Devices #3766

It can be useful to select a specific version of Node-RED to run, for example where you are using a custom node which only runs on specific versions of Node-RED. In this release we have added the ability to easily select the version of Node-RED you wish to run on your devices.

Full list of release features and bug fixes

You can view everything included in 2.4 on the Github Release page.

We also regularly release updates to FlowFuse Cloud in between our monthly releases. You can follow the updates as they are made via our ChangeLog.

What's next?

We're always working to enhance your experience with FlowFuse. Here's how you can stay informed and contribute:

Roadmap Overview: Check out our Product Roadmap Page to see what we're planning for future updates.
Entire Roadmap: Visit our Roadmap on GitHub to follow our progress and contribute your ideas.
Feedback: We're interested in your thoughts about FlowFuse. Your feedback is crucial to us, and we'd love to hear about your experiences with the new features and improvements. Please share your thoughts, suggestions, or report any issues on GitHub.

Together, we can make FlowFuse better with each release!

Try it out

We're confident you can have self managed FlowFuse running locally in under 30 minutes. You can install FlowFuse yourself via a variety of install options. You can find out more details here.

If you'd rather use our hosted offering: Get started for free on FlowFuse Cloud.

Upgrading FlowFuse

FlowFuse Cloud is already running 2.4.

If you installed a previous version of FlowFuse and want to upgrade, our documentation provides a guide for upgrading your FlowFuse instance.

Getting help

Please check FlowFuse's documentation as the answers to many questions are covered there. Additionally you can go to the community forum if you have any feedback or feature requests.

Understanding Node, Flow, Global, and Environment Variables in Node-RED

2024-05-06T00:00:00Z

Node-RED is a low-code programming tool for connecting hardware, APIs, and online services. While its visual interface makes development accessible, understanding how to work with variables like node, flow, global, and environment is key to building efficient, organized flows.

This guide provides a clear explanation of each variable type in Node-RED, including how to initialize, access, and manage them effectively. Whether you are just starting with Node-RED or looking to improve your workflows, this article will help you gain a solid understanding of the variable context system and how to use it to your advantage.

Understanding Node-RED Variables

Variables help you store and manage data in Node-RED. There are three main types: message, context, and environment variables.

Message variables are part of the message as it moves through the flow. For example, msg.payload carries the main data between nodes. You can learn more about messages in the Understanding Node-RED Messages guide.

Context variables let you store information about the current state of the application. These can be saved at the node level, the flow level, or globally across the whole instance.

Environment variables are used for configuration and often store sensitive data like secrets or API keys. They help keep important information safe and separate from the flow itself.

Exploring Global variables

Global variables in Node-RED are accessible to function, change, inject, and switch nodes within a given Node-RED instance. They serve as a centralized storage point for data that needs to be accessed across different parts of an application. This is especially useful when you want to share data across multiple flows or tabs within the same Node-RED instance.

For example, in a home automation system with flows for lighting, security, and climate control, global variables can store user preferences or system settings that all flows can access and update. This allows for consistent behavior across the entire system.

Initiating/setting Global variable

We can set Global variables using the function and change node.

In the change node, you can set it as shown in the below image

To initiate a global variable using the function node, use the global's set method as shown below:

global.set('variableName', value);

Retrieving Global variable

Retrieving global variables using change, inject, and switch nodes is quite similar. You simply need to select the "global" option and enter the variable name in the input field. Below is an image showing how you can retrieve global variables using the change node:

To retrieve a global variable using the function, use the global's get method like the below in the function node:

global.get('variableName');

Deleting Global variables

To delete the global variables again you can use both the "context data" tab and the change node. I have shown in the below image how you can delete global variables using the change node:

Exploring Flow variables

Flow variables are accessible to function, change, inject, and switch nodes and some third-party nodes within the same tab or flow where they have been set. It is useful for sharing data within a specific flow or tab, allowing for seamless data transfer between nodes within the same flow.

For example, in a temperature monitoring system, you have multiple sensors sending data to different nodes within the same flow. You can use flow variables to pass the current temperature reading between nodes for processing and analysis within that specific flow.

Initiating/Setting Flow variable

We can set flow variables using function and change node.

In the change node, you can set it as shown in the below image

To initiate a flow variable using the function node, use the flow's set method as shown below:

flow.set('variableName', value);

Retrieving Flow variable

You can retrieve flow variables using the function, change, inject, and switch.

Retrieving flow variables using change, inject, and switch nodes is quite similar. You simply need to select the "flow" option and enter the variable name in the input field. Below is an image showing how you can retrieve flow variables using the change node.

To retrieve a flow variable, use the flow's get method like the below in the function node:

flow.get('variableName');

Deleting Flow variables

To delete flow variables you can use both the "context data" tab and the change node. I have shown in the below image how you can delete flow variables using the change node:

Exploring Node variables

Node variables are specific to each node and are only visible within that node. This means we cannot read or write into that variable from outside of the node where it is initialized. This is ideal for cases where you want to store data specific to a single node, to ensure data isolation and prevent interference with other nodes

For example, You have a form on a Node-RED Dashboard 2.0, and you want to insert the submitted data into a database along with a unique ID for each submission. You can use a node variable to store and track a counter variable in the function node.

Initiating/setting Node variable

To initiate and set a node variable using the function node, you will have to use the context’s set method:

context.set('variableName', value);

This action sets the value for the context variable with the specified name.

Retrieving Node variable

To retrieve a node variable using a function node, use the context's get method:

context.get('variableName');

Deleting Node variables

Node variables cannot be deleted using a Node-RED node. To delete them, use the Context Data tab in the Node-RED editor, where a delete option is available for each variable. For more details, refer to the Exploring the Context Data tab section of this guide.

FlowFuse persistent storage

So far, we have seen three types of context variables and all are stored in memory. This means that when we stop the Node-RED instance, the variables will get wiped out.

FlowFuse provides a way to persist these variable values between restarts and FlowFuse stack updates. For more details, refer to FlowFuse Persistent Context.

Setting Persistent Variables in Function Node

To set variables in persistent store using change node steps are the same as storing them in memory you just need to change the store option to persistent from memory in the change node like below:

In the function node, you just need to pass one more argument "persistent" in the set method.

global.set('variableName',value,'persistent');

flow.set('variableName',value,'persistent');

context.set('variableName',value,'persistent');

Retrieving Persistent Variables

You can retrieve variables stored in the persistent store using the change node as shown in the below image:

To retrieve a variable stored in the persistent store using the function node, you'll need to pass "persistent" in the get method.

global.get('variableName','persistent');

flow.get('variableName','persistent');

context.get('variableName','persistent');

Exploring Context Data tab

Node-RED provides a dedicated interface for viewing and managing all Node-RED variables. Navigate to the sidebar's "Context Data" tab, where you'll find sections for Node, Flow, and Global variables. Each section has a refresh icon at the top right corner; click on it to see the latest or newly added variables.

In this tab, you'll also find information about when each variable was set or updated, along with additional options on the right side of each variable. The first option allows you to copy the variable's name, the second option lets you copy the variable's value, the third option refreshes the variable to show the most recent value, and the fourth option allows you to delete the variable.

Exploring Environmental variables

Environment variables are specifically used for storing sensitive configuration data, such as API keys or database credentials, ensuring this information isn't directly exposed within your flows. In Node-RED you can set environment variables at flow and global level.

Flow-level environment: Used to store sensitive configuration data accessible only within a specific flow. This ensures secure and isolated storage of sensitive information. For example, when building a multi-flow Node-RED application, each flow may need different configuration details, like API keys or unique identifiers. Using flow-level environment variables allows each flow to securely store its specific sensitive data without exposing it to other flows.
Global-level environment: Variables are used to store sensitive data accessible across all flows in a Node-RED instance. They are helpful when you need to share the same sensitive data across different flows. For example, If multiple flows need to use the same API key, setting a global-level environment variable allows them to access this data securely, avoiding repeated configurations and ensuring consistency.

Setting Environment Variables

To set flow-level environment variables you'll have to use the edit dialog of the flow.

For information on setting and managing global-level environment variables, refer to Using Environment variables in Node-RED.

Accessing Environment variables

Environment variables in the change, inject, and switch nodes can be accessed by selecting the "$ env variable" option and entering the variable name in the input field. Here's an example of Accessing an environment variable using the change node:

To access environment variables in a function node, use:

env.get('variableName');

In the template node, you can access it as shown below:

This is my username : {{env.USERNAME}}.

And if you need to access environment variables in third-party configuration nodes where they haven't provided an option to use environment variables, you can access them with ${variableName} in the node's input field.

Note: If a flow-level and a global-level environment variable share the same name, Node-RED prioritizes the flow-level variable. To access the global-level variable in this case, prefix the variable name with $parent.

Deleting Environment variables

To delete added environment variables, you can use the same interface where added them. In the right corner of your added environment variable, you'll see a delete or cross icon. Simply click on it to delete the variable and restart your Node-RED instance.

By now, you should have a complete understanding of how variables function within Node-RED, how to set, retrieve, and delete them, both in memory and in persistent storage.

Conclusion

Building with Node-RED becomes much easier when you understand how data moves and is stored throughout your flows. With the right use of context and configuration, your flows become not just functional, but maintainable and scalable.

As your projects grow, so does the need for better tools—whether it's managing deployments, collaborating with a team, or keeping things running smoothly across environments. That’s where FlowFuse helps you take the next step.

Start using FlowFuse today and improve your Node-RED experience with built-in tools for scaling, collaboration, and reliability

Dashboard 2.0: Milestones, PWA and New Components

2024-04-26T00:00:00Z

With a new release of Node-RED Dashboard 2.0 we have plenty of new fixes and improvements being added to the project. In this post, we'll deep dive into community contributions, PWA support, new Vuetify components, and the rest of the great work published in this latest release.

Community Contributions

We firstly wanted to take this opportunity to point out a big milestone that we're very proud to see in Node-RED Dashboard 2.0.

This release marks the first time we've had more contributions in a single release from the community, than from FlowFuse employees. I think this is a testament to the community, and a big milestone in validating the success, and popularity, of Dashboard 2.0 in the wider Node-RED community.

So thank you very much @BartButenaers, @Ek1nox, @fullmetal-fred and @cgjgh for for great efforts and initiative in improving Node-RED Dashboard 2.0.

For anyone else that's interested in contributing to the project, please do reach out, and we'll be happy to help you get started. We also have a Contributing Guide if you want to dive straight in.

Progressive Web App (PWA) Support

The biggest community contribution we saw in this release was the addition of Progressive Web App (PWA) support. This feature was added by @cgjgh, and allows you to install your Node-RED Dashboard 2.0 applications directly onto your platform, including Windows, iOS and Android.

This work will give your Dashboard's a much more native/natural feel when running on your own machines, and mean you no longer need to go via your browser to access your applications.

New Vuetify (Preview) Components Available

Vuetify is the component library on which most of our Dashboard 2.0 components are built. Our core widgets implement the more fundamental UI elements, but that doesn't stop you from building out fully customized interfaces yourself using our ui-template node with the vast collection of Vuetify components.

Within the ui-template node, we natively support any of the core Vuetify components, but Vuetify itself is always evolving and often they release components into their Vuetify Labs.

In their latest releases, a few of the new components have caught our eye as we've seen them regularly requested in Dashboard 2.0. As such, we've now made available the following Vuetify components inside a ui-template node:

Number Input (docs)

An example v-number-input from Vuetify's component library

We do have plans for this to become a core widget, and will likely introduce this sooner, rather than later, however, in the mean time, you can now use the v-number-input component in a ui-template node to create your own number inputs instead.

<template>
    <v-number-input v-model="value"></v-number-input>
</template>

<script>
  export default {
    data() {
      return {
        value: 0
      }
    },
    watch: {
      value: function () {
        this.send({payload: this.value})
      }
    }
  }
</script>

<style>
    .v-number-input__control .v-btn {
        color: var(--v-theme-on-surface);
    }
</style>

Sparkline (docs)

An example v-sparkline rendering the output from a ui-slider

Sparklines are a great way to visualize data trends in a small space, and we've seen them requested a few times in the past. Now you can use the v-sparkline component in a ui-template node to create your own sparklines.

This will also likely become a standalone node at some point too, possibly as a third-party widget, but for now implementing into a ui-template is very straight forward.

In the following example ui-template, we append any incoming msg.payload to a value array and render the sparkline accordingly.

<template>
  <v-sparkline class="nrdb-ui-sparkline" :auto-line-width="false" :fill="false" :gradient="gradient"
    :gradient-direction="'top'" :line-width="2" :model-value="value" :padding="8"
    :smooth="10" :stroke-linecap="'round'" :type="'trend'" auto-draw></v-sparkline>
</template>

<script>
  export default {
    data: function () {
      return {
        gradient: ['#f72047', '#ffd200', '#1feaea'],
        value: [0, 2, 5, 9, 5, 10, 3, 5, 0, 0, 1, 8, 2, 9, 0]
      }
    },
    watch: {
      msg: function () {
        this.value.push(this.msg.payload)
      }
    }
  }
</script>

<style>
.nrdb-ui-sparkline path {
  stroke-dasharray: 0 !important;
}
</style>

There is no limitation on where you can use the sparkline either, we could, for example, add it to a v-data-table to show a sparkline of a particular feature for each row in the table:

An example v-data-table that renders a v-sparkline on each row

Here we see the corresponding template for the above v-data-table example:

<template>
    <!-- Provide an input text box to search the content -->
    <v-text-field v-model="search" label="Search" prepend-inner-icon="mdi-magnify" single-line variant="outlined"
        hide-details></v-text-field>
    <v-data-table v-model:search="search" :items="msg?.payload" :headers="headers">
        <template v-slot:header.pingvalues="{ item }">
            Ping History
        </template>
        <template v-slot:item.ping="{ item }">
            ms
        </template>
        <template v-slot:item.pingvalues="{ item }">
            <v-sparkline v-model="item.pingValues" :gradient="['#42b3f4', '#42b3f400']"
                :line-width="2" gradientDirection="top" :smooth="true" :fill="true">
        </template>

    </v-data-table>
</template>

<script>
export default {
  data () {
    return {
      search: '',
      headers: [
        { key: 'id', title: 'ID' },
        { key: 'ping', title: 'Ping' },
        { key: 'pingvalues', title: 'Ping History' }
      ]
    }
  }
}
</script>

Treeview (docs)

An example v-treeview from Vuetify Lab's component library

The v-treeview component is a great way to visualize hierarchical data in a tree-like structure. We've seen this requested a few times in the past, and now you can use the v-treeview component in a ui-template node to create your own treeviews.

There is still scope for this to, one day, become a core or third party widget, but in the mean time, it's very easy to get this up and running in a ui-template node.

The Treeview example, and other examples above are available in this sample flow:

Other Highlights

Whilst the above are the main highlights of this release, we've also had a number of other smaller improvements and fixes that have been added to the project. These include:

UI Radio Group - Dynamic radio options in #765
UI Notification - Notification output & output msg when button clicked in #766
UI Dropdown - Clear dropdown selection in #775
UI Button - Add "Emulate Click" option in #783

You can see the full list of changes in the 1.8.0 Release Notes.

Follow our Progress

New features and improvements are coming to Node-RED Dashboard 2.0 every week, if you're interested in what we have lined up, or want to contribute yourself, then you can track the work we have lined up on our GitHub Projects:

If you have any feature requests, bugs/complaints or general feedback, please do reach out, and raise issues on our relevant GitHub repository.

FlowFuse

FlowFuse 2.20: AI-Assisted Node-RED & New Database Service

Introducing: FlowFuse Tables

New Node: Query

AI-Assisted Node-RED with Smart Suggestions

New Blueprint: Agentic AI with Retrieval Augmented Generation

Refined Applications Page

More Powerful "Small" Instances

What's Next?

What else is new?

Try FlowFuse

FlowFuse Cloud

Self-Hosted

FlowFuse AI Assistant: Let Your Engineers Build Automation, Not Write Code

Parsing Machine Data Without the JavaScript Struggle

Creating Test Data in Seconds, Not Hours

Building Custom Dashboards Without Web Development

Documenting Complex Flows Before Knowledge Walks Out

Start Building Today

How Leading Manufacturers Save Thousands of Dollars/Year with Real-Time SPC

Why Traditional Quality Control Falls Short

Building Your First SPC System with FlowFuse

What We're Building

Step 1: Get Your Tools Ready

Step 2: Simulate Your Machine Data

Step 3: Add the Statistical Brain

Step 4: Make the Data Chart-Ready

Step 5: Build Your Control Room Dashboard

Step 6: Add the Alert System

Step 7: Test Your SPC System

SPC Chart Rules That Actually Matter

Connecting to Real Equipment

The Money You're Leaving on the Table

Start Preventing Defects Today

References

OPC UA Tutorial: Connect and Exchange Data with Industrial Equipment

Why OPC UA?

Breaking the Cycle

Universal Connectivity

Information, Not Just Data

Security Built for Industry

Future-Proof Investment

Getting Started

What You’ll Need

Installing OPC UA Support in FlowFuse

Install the OPC UA Node Package

Connecting to Your OPC UA Server

Browsing Tags (Optional)

Reading Tag Values

Reading a Single Tag

Reading Multiple Tags

Writing Values

Writing a Single Tag

Writing Multiple Tags

What’s Next

Connecting Manufacturing Equipment via Serial Port

Making Sense of Serial Communication

Data Direction: Which Way Does It Flow?

Data Format: How Is It Structured?

Interface Types: How Devices Physically Connect

Setting Up Serial Communication with FlowFuse

Prerequisites

Configuring the Serial Port Node

Writing to Serial Port

Reading and Processing Serial Data

Handling Request-Response Serial Communication

Dynamically Managing Serial Ports

Key Takeaways

How we Built a Smart Manufacturing Order Execution Panel with FlowFuse

Demo: Smart Manufacturing Order Execution Panel in Action

How It Works: Behind the Scenes

System Components

Workflow Breakdown

Why This Matters for Business

Ready to Connect Your Shop Floor?

FlowFuse 2.19: More Powerful AI in Node-RED, Drop-In Blueprints, Memory Monitoring, and Faster Onboarding

AI Enhancements to Node-RED

Comprehensive Performance Monitoring

Add Blueprints to Existing Instances

Social Sign-in for Easy Onboarding