How-to
Stable Node-RED gateway flows with vendor-pinned nodes
Short answer
Yes: install the vendor's SE Modbus and Machine Advisor Node-RED packages from offline files, but only after the installed Yocto image meets the prerequisite in each node's manual. If you keep the template's open-source Modbus node instead, pin it to the example's stated version, 2.5.0.0, and re-verify after any package change.
On this page
Yes, there are official packages. The automation vendor behind this gateway class supplies two Node-RED node packages — SE Modbus for the field-side Modbus link and Machine Advisor for the cloud connection — and both install offline from supplied files on a Yocto-based Linux IPC. Your instability has a cause: the vendor's template example was built against the open-source node-red-contrib-modbus package at version 2.5.0.0, and an unpinned open-source package moves under a working flow as updates land. The decision: commission new or rebuilt gateways on the vendor packages, and pin 2.5.0.0 only where the template flow must stay untouched.
Choose the package path before you touch the IPC #
npm resolves a bare package name to the newest published release, so every reinstall or palette update of the template's Modbus node is a silent upgrade of a working flow. The pin is the template example's own constraint, and it applies to the open-source package only — never to SE Modbus or Machine Advisor, whose versions and image support come from their own manuals.
The template route is one instance of sending PLC data to an IoT hub without custom software; its weakness on this box is the floating dependency, not the pattern.
| Path | What holds it stable | Commissioning decision |
|---|---|---|
| Vendor packages: SE Modbus + Machine Advisor | Each manual fixes its supported Yocto image and its own offline procedure | Pass the image gate, install from the offline files, verify recognition and data before deploying |
| Template flow on the open-source Modbus node | The pin alone: the example requires node-red-contrib-modbus 2.5.0.0 | Keep that exact version, name it explicitly on the install command, re-verify the flow after any package change |
For a gateway that must run unattended, take the vendor path. Keep the open-source node only while the template flow must remain untouched, and treat it as a pinned dependency, not a floating one.
Gate the install on the image prerequisite #
Each manual carries a prerequisite section naming the Yocto image it supports. That is a gate, not a post-installation adjustment. These IPCs arrive with Node-RED already installed; if your box arrives blank instead, installing Node-RED natively on a Linux edge computer is the step before all of this.
- Read the installed image version using the method given in the image and restoration documentation supplied with the IPC.
- Compare that reading against the SE Modbus manual's prerequisite, then repeat the comparison against the Machine Advisor manual. Make the two comparisons separately: an image that satisfies one package can still fail the other.
- If the installed image is below a stated requirement, restore the required image with the supplied image and restoration instructions, read the version again, and repeat both comparisons.
- If the documentation cannot establish compatibility, stop before installing either node. The model name alone does not establish it.
Stage the offline files #
- Take the vendor package archive from the supplied package folder and extract it.
- Confirm the extracted set contains the offline files for both nodes and that both manuals are at hand. An install started from an incomplete set fails halfway.
- Copy the extracted files to USB storage and confirm the IPC reads them where its manual expects them.
Use the same discipline as installing licensed software on an industrial edge PC: complete, verified media before anything is configured.
Install SE Modbus and Machine Advisor from the files #
- Install SE Modbus following the offline procedure in its manual. Do not substitute an assumed npm command or an online route; the manual's procedure is the documented one for these packages.
- Confirm Node-RED recognizes the node, using the confirmation method the manual specifies.
- Install Machine Advisor following its own manual's offline procedure.
- Confirm its recognition independently. A successful SE Modbus install proves nothing about Machine Advisor.
- Configure both nodes with the settings their manuals specify, and deploy only after the flow validates in Node-RED.
Configure the link and verify in layers #
The documented arrangement for this gateway sends data over HTTPS and MQTTS through Node-RED, with a VPN tunnel carrying connectivity where the design uses one. Endpoint addresses, credentials, certificate settings, topic names and payload schema are project values: read them from the project configuration and the platform documentation, never invent them.
- Node-RED runs and both nodes are recognized.
- The network path for the chosen protocol exists, including the tunnel where the design depends on it.
- The cloud node's connection session is established and its mapping matches the project configuration.
- The expected data arrives in Machine Advisor.
Each layer proves only itself: a standing tunnel does not prove an application session, and a deployed flow does not prove delivery. Only the fourth layer closes commissioning.
Worked example: prove delivery with a count #
Illustrative numbers — substitute your flow's. Suppose the flow reads 10 holding registers over Modbus TCP every 5 s and publishes one MQTTS message per read carrying all 10 values.
- Cycles per minute: 60 s ÷ 5 s = 12
- Values per minute: 12 × 10 = 120
- Over a 5-minute check window: 12 × 5 = 60 messages and 120 × 5 = 600 values
Read the platform after the window and decide: zero received means the failure sits in the path, session or mapping layers, so fix those before touching packages. Roughly half the expected count means the mapping dropped part of the register set, not the connection. The full 600 values proves the path end to end, and the flow can be left running.
When it fails after installation #
| Symptom | First check | Action |
|---|---|---|
| Offline install will not complete or a node does not appear | Installed image version against that manual's prerequisite; completeness of the extracted files | Meet the prerequisite or restore the required image, repeat the manual's procedure, confirm recognition before configuring |
| The template flow changes behavior after a package update | Which release of the open-source Modbus node is now installed | Reinstall the example's pinned release and re-verify; the symptom is the version change, not the flow logic |
| Nodes are recognized but the platform shows no data | The four layers, in order | Fix the first failing layer only |
Do not change package versions to chase a data symptom: an unplanned version change during diagnosis destroys the baseline and turns one fault into two.
Questions asked
Can I install these vendor nodes with Node-RED's palette manager?
No. The palette manager pulls from the online npm registry, which the offline IPC cannot reach; on a connected machine it installs the newest release rather than a chosen one. These packages follow their manuals' offline file procedure instead, so the palette manager is the wrong tool for them here.
My IPC already runs the template flow. How do I move it to the vendor nodes?
Export the working flow before touching packages, keep the pinned open-source install in place until the vendor path passes both recognition checks, and cut over only after an end-to-end test delivers the expected data in the platform. That ordering leaves you a verified fallback at every step of the migration.
Where does the installed Yocto image version come from?
From the readout method given in the image and restoration documentation supplied with the IPC. Compare that reading against the prerequisite in each node manual separately, because one package can demand a newer image than the other, and treat the model name alone as proof of nothing.
The VPN tunnel is up but no data reaches Machine Advisor. Should I reinstall the node?
Not necessarily, and reinstalling is the wrong first move. The tunnel proves only the network path. Check next that the node's connection session is established and that the mapping matches the project configuration, then compare the received sample count against what the flow should deliver. Fix the first layer that fails.
How often does a pinned open-source flow need re-verification?
After any event that can change the package: a palette update, a reinstall from backup media, or an image restoration. Between such events the pin holds the behavior stable, which is exactly what the template depends on.