Mitsubishi MELSEC Nodes
Read and write Mitsubishi MELSEC PLCs directly from pipelines over SLMP / MC Protocol. Each function type authored on a MELSEC connection is available as a matching node in the Pipeline Designer, plus a dedicated MELSEC Read Group node for executing several reads in one node with request coalescing.
For connection setup, the device addressing model, data types, and per-function configuration fields, see the Mitsubishi MELSEC connection guide.
Configuration Quick Reference
| Field | What you choose | Details |
|---|---|---|
| Parameters | Connection, Function, Function Parameters, Timeout Override | Select the MELSEC connection profile, pick a function, bind parameters with expression support, and optionally override the timeout. |
| Settings | Description, Timeout (seconds), Retry on Timeout, Retry on Fail, On Error | Node description, maximum execution time, retry behaviour on timeout or failure, and error strategy. All execution settings default to pipeline-level values. |
MELSEC Read Node
MELSEC Read Node
Read a single typed value from one device, or many typed datapoints from a device range in a single coalesced call. The node runs whichever read function you select — melsec.read.device (one value) or melsec.read.block (a batch of named points).
Supported Function Types:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
Read Device (melsec.read.device) | Read one typed value from a single device address | Setpoint readback, status/input bit, timer/counter value |
Read Block (melsec.read.block) | Read many typed datapoints from a device range in the fewest SLMP requests | Dashboard snapshots, historian logging, mixed-type process blocks |
Node Configuration
| Parameter | Type | Required | Description |
|---|---|---|---|
| Connection | Selection | Yes | MELSEC connection profile to use |
| Function | Selection | Yes | A melsec.read.device or melsec.read.block function from the selected connection |
| Function Parameters | Dynamic | Varies | Auto-populated from the function schema (device, dataType, length, wordSwap, or the dataPoints array for a block read). See the MELSEC connection functions for field-level details. |
| Timeout Override | Number (seconds) | No | Override the default function timeout |
All function parameters support expression syntax ({{ expression }}) for dynamic values from the pipeline context.
Input
The node receives the output of the previous node as input. Input data can be referenced in function parameter expressions using $input.
Output Structure
Read Device — a single decoded value. quality is good when the device answered: an SLMP end code fails the node instead of storing a value, so a value that reached the result is the PLC's own reading. Read Block carries the same top-level quality.
{
"result": {
"device": "D100",
"dataType": "REAL",
"value": 72.5,
"quality": "good"
},
"_metadata": { "success": true, "functionId": "<function-id>", "durationMs": 11, "timestamp": "2026-06-05T08:30:00Z" }
}
| Field | Type | Description |
|---|---|---|
_metadata.success | boolean | true when the read completed without an error |
_metadata.functionId | string | ID of the executed function |
result.device | string | Echoes the device/tag reference you supplied (a raw address such as D100, or the tag name if you used one) |
result.dataType | string | Data type used to decode the value |
result.quality | string | good — an SLMP end code fails the node instead of storing a value |
result.value | any | The decoded value — type matches dataType (BIT → boolean, WORD/INT/DWORD/DINT → number, REAL/LREAL → number, STRING → string) |
_metadata.durationMs | number | Execution time in milliseconds |
_metadata.timestamp | string | ISO 8601 / RFC 3339 UTC timestamp |
Read Block — a map keyed by datapoint name:
{
"result": {
"count": 4,
"values": {
"speed": 1234,
"count": 100000,
"level": 72.5,
"estop": true
},
"totalDataPoints": 4,
"totalReads": 2
},
"_metadata": { "success": true, "functionId": "<function-id>", "durationMs": 18, "timestamp": "2026-06-05T08:30:00Z" }
}
| Field | Type | Description |
|---|---|---|
result.values | object | Map keyed by datapoint name — every point configured in the function appears here. |
result.count | number | Number of decoded datapoints returned |
result.totalDataPoints | number | Number of datapoints requested |
result.totalReads | number | Number of SLMP batch requests the points were coalesced into (gap-merged + ceiling-chunked) |
Access pattern in downstream nodes:
{{ $node["MELSEC Read"].result.values.speed }}
{{ $node["MELSEC Read"].result.values.estop }}
A Read Block sorts its datapoints per device code and merges them into the fewest SLMP batch requests — adjacent word points within a small gap become one ReadWords request, adjacent bit points become one ReadBits request, and anything above the per-request ceiling (3584 words / 7168 bits) is automatically chunked. The totalReads field shows how many wire requests the read actually used.
MELSEC Write Node
MELSEC Write Node
Write a single typed value to one writable device. 32-bit and float values are written as a single multi-word batch (atomic per request); bit devices are written natively. Read-only devices (X inputs, TN, CN, SD, SM) are rejected before the request reaches the PLC.
Supported Function Type:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
Write Device (melsec.write.device) | Write a typed value to a single device | Setpoints, recipe download, control/output bits, mode changes |
Node Configuration
| Parameter | Type | Required | Description |
|---|---|---|---|
| Connection | Selection | Yes | MELSEC connection profile to use |
| Function | Selection | Yes | A melsec.write.device function from the selected connection |
| Function Parameters | Dynamic | Varies | Auto-populated from the function schema (device, dataType, value, length, wordSwap). The value field supports ((paramName)) templates — see the MELSEC connection functions. |
| Timeout Override | Number (seconds) | No | Override the default function timeout |
All function parameters support expression syntax ({{ expression }}) and template placeholders (((paramName))). Use expressions like {{ $input[0].result.value }} (an upstream read) to feed dynamic values into the value parameter.
Input
The node receives the output of the previous node as input.
Output Structure
On success:
{
"result": {
"device": "D100",
"dataType": "REAL",
"value": "3.14"
},
"_metadata": { "success": true, "functionId": "<function-id>", "durationMs": 12, "timestamp": "2026-06-05T08:30:00Z" }
}
| Field | Type | Description |
|---|---|---|
result.device | string | Echoes the device/tag reference that was written (raw address, or the tag name if you used one) |
result.dataType | string | Data type used to encode the value |
result.value | any | Echo of the value that was written (after parameter substitution) |
A write to a read-only device returns success: false with an error like device X0 (X) is read-only, and the request never reaches the PLC.
Always validate values in a Condition node before writing to industrial equipment. A setpoint or output bit can move a motor, valve, or actuator immediately. Use parameter type/default/required settings to enforce ranges, and remember that STRING writes require the function's String Length to be set to the full string length or the value is truncated.
MELSEC Read Group Node
MELSEC Read Group Node
Execute multiple read functions from a single MELSEC connection in one node. The read group runs the selected functions (in parallel or sequentially) and merges their results, which is ideal for comprehensive data collection from one PLC without dropping a node per function.
Per-request batching and chunking still happen inside each melsec.read.block function; the read group coalesces at the pipeline level, the same way the Siemens S7 read group does.
Supported Function Types:
| Function Name | Purpose |
|---|---|
Read Device (melsec.read.device) | One typed value per function |
Read Block (melsec.read.block) | A batch of named datapoints per function |
Node Configuration
| Parameter | Type | Required | Description |
|---|---|---|---|
| Connection | Selection | Yes | MELSEC connection profile to use |
| Function Selection | Selection | No | Select Functions (default) reads the functions you list, All Functions reads every read function on the connection, By Labels reads every function whose labels match the labels you pick |
| Functions | List | With Select Functions | One or more read functions from the selected connection, each with an optional alias that becomes its output key |
| Execution Mode | Selection | No | How to execute the coalesced requests (parallel or sequential) |
| Continue on Error | Toggle | No | On by default: a failed read is recorded in the output and the other functions still run. Off: the node fails as soon as any function fails |
Output Structure
The node output is the canonical {result, _metadata} envelope: result holds one entry per function read, keyed by the function's output key; _metadata holds the group's accounting.
{
"result": {
"Line Status": {
"value": 1,
"success": true,
"error": "",
"duration": 11,
"timestamp": "2026-09-07T08:30:00Z"
},
"Process Block": {
"value": { "count": 2, "values": { "Temperature": { "device": "D100", "dataType": "REAL", "value": 72.5 }, "Pressure": { "device": "D102", "dataType": "REAL", "value": 1.02 } } },
"success": true,
"error": "",
"duration": 19,
"timestamp": "2026-09-07T08:30:00Z"
}
},
"_metadata": {
"connectionId": "conn-123",
"connectionName": "Line 3 PLC",
"total": 2,
"successful": 2,
"failed": 0,
"totalDuration": 83,
"executionMode": "parallel",
"originalRequests": 2
}
}
Each entry under result is one function's read — keyed by the function's alias, else its name, else its id:
| Field | Type | Description |
|---|---|---|
result.<alias>.value | any | What the function read — its own result.value when it has one (the decoded value for melsec.read.device, since its result carries value; the whole {count, values} object for melsec.read.block), otherwise its whole result. null when the read failed |
result.<alias>.success | boolean | true when this function's read succeeded |
result.<alias>.error | string | Why the read failed; empty when it succeeded — always present |
result.<alias>.duration | number | How long this function's read took, in milliseconds |
result.<alias>.timestamp | string | When the read was issued, RFC 3339 UTC |
The _metadata object is the group's execution summary:
| Field | Type | Description |
|---|---|---|
_metadata.connectionId | string | The connection every function was read on |
_metadata.connectionName | string | That connection's display name |
_metadata.total | number | How many functions the group ran |
_metadata.successful | number | How many read successfully — including the ones onChange then suppressed |
_metadata.failed | number | How many failed; successful + failed = total |
_metadata.totalDuration | number | Wall-clock time of the whole group, in milliseconds |
_metadata.executionMode | string | parallel or sequential |
_metadata.originalRequests | number | How many functions were selected to run |
_metadata.keyCollisions | string[] | Output keys that two or more functions resolved to — the later read overwrote the earlier under that key. Present only when it happened |
_metadata.configWarnings | string[] | Non-fatal problems in the node's config, each saying what was ignored. Present only when there were any |
_metadata.outputMode | string | onChange — present only in that mode |
_metadata.suppressedCount | number | onChange mode: how many successful reads were unchanged since the last run and left out of result |
_metadata.emittedCount | number | onChange mode: how many entries result carries — total − suppressedCount |
_metadata.suppressedKeys | string[] | onChange mode: the output keys left out as unchanged. Present only when at least one was |
_metadata.reason | string | onChange mode, when every successful read was unchanged: why result is empty — the node buffers instead of waking downstream |
When to use Read Group vs. the standard Read node
| Approach | Use Case |
|---|---|
| MELSEC Read | Execute a single read function (one device or one block) |
| MELSEC Read Group | Execute several read functions from one connection together, with their requests grouped into the fewest SLMP requests |
Device and block reads are grouped into the fewest SLMP requests, with anything above the per-request ceiling (3584 words / 7168 bits; 64 words / 256 bits on the FX 1E frame) auto-chunked for optimal performance.
Settings Tab
All MELSEC node types share the same Settings tab:
| Setting | Type | Default | Description |
|---|---|---|---|
| Description | Text | — | Optional description displayed on the node |
| Timeout (seconds) | Number | Pipeline default | Maximum time the node may run before timing out |
| Retry on Timeout | Toggle | Pipeline default | Automatically retry the node if it times out |
| Retry on Fail | Toggle | Pipeline default | Automatically retry the node if it fails |
| On Error | Selection | Pipeline default | Error strategy: Pipeline Default (the pipeline's Error Handling setting), Stop Pipeline or Continue Execution |
When left at their defaults, these settings inherit from the pipeline-level execution configuration.
Use the Test Function button in the function form (on the connection page) to validate every MELSEC function against the live PLC before wiring it into a pipeline. It is the fastest way to catch a wrong address, wrong radix (hex vs decimal), wrong data type, or a read-only target.