EtherNet/IP Integration Guide

Connect MaestroHub to Allen-Bradley PLCs (ControlLogix, CompactLogix, Micro820) using the EtherNet/IP protocol. This guide covers connection setup, function authoring, and pipeline integration for tag-based industrial communication.

Overview

The EtherNet/IP connector provides:

• Native CIP communication with Allen-Bradley PLCs over EtherNet/IP
• Tag-based addressing with support for controller-scoped and program-scoped tags
• Comprehensive data type support for all standard CIP types including arrays
• Tag discovery to browse and explore available tags in the PLC
• Batch operations for efficient multi-tag reads and writes

Supported PLCs

This connector is designed for Allen-Bradley PLCs that support EtherNet/IP CIP (Common Industrial Protocol):

• ControlLogix (1756 series) - configure the appropriate CPU slot
• CompactLogix (1769 series) - uses slot 0
• Micro820 - uses slot 0

Connection Configuration

Creating an EtherNet/IP Connection

From Connections → New Connection → EtherNet/IP, configure the fields below:

EtherNet/IP Connection Creation Fields

1. Profile Information

Field	Default	Description
Profile Name	-	A descriptive name for this connection profile (required, max 100 characters)
Description	-	Optional description for this EtherNet/IP connection

2. PLC Configuration

Field	Default	Description
Host	-	PLC IP address or hostname (e.g., 192.168.1.100) - required
Port	44818	TCP port number (1-65535). Standard EtherNet/IP port is 44818
Slot	0	CPU slot number in the chassis (0-16). Use 0 for CompactLogix and Micro820

Slot Configuration by PLC Type

PLC Type	Slot Setting	Notes
ControlLogix (1756)	0-16	Set to the physical slot where the CPU module is installed
CompactLogix (1769)	0	Always use slot 0
Micro820	0	Always use slot 0

3. Timeout Configuration

Field	Default	Description
Timeout (ms)	5000	Connection and request timeout in milliseconds (1000-300000)

4. Keep-Alive Settings

Field	Default	Description
Keep Alive	true	Enable TCP keep-alive to maintain the connection
Keep Alive Interval (ms)	10000	Interval between keep-alive packets in milliseconds (1000-3600000)

5. Connection Labels

Field	Default	Description
Labels	-	Key-value pairs to categorize and organize this connection (max 10 labels)

Example Labels

• environment: production
• team: automation
• protocol: ethernetip
• plc-type: controllogix

Notes

• Slot Configuration: For ControlLogix systems with multiple modules, set the slot to match the physical slot number of the CPU module (typically slot 0 for the leftmost position).
• Timeout Values: Increase timeout values for PLCs on slow networks or when reading large tag arrays.
• Keep-Alive: Enabling keep-alive prevents the connection from being dropped during idle periods and helps detect connection failures.
• Standard Port: The default EtherNet/IP port 44818 is the industry standard. Only change this if your network requires a non-standard configuration.

Supported Data Types

EtherNet/IP uses CIP (Common Industrial Protocol) data types. The connector supports all standard types:

CIP Type	Description	Value Range
bool	Boolean	true / false
sint	Signed 8-bit integer	-128 to 127
int	Signed 16-bit integer	-32,768 to 32,767
dint	Signed 32-bit integer	-2,147,483,648 to 2,147,483,647
lint	Signed 64-bit integer	Full 64-bit range
usint	Unsigned 8-bit integer	0 to 255
uint	Unsigned 16-bit integer	0 to 65,535
udint	Unsigned 32-bit integer	0 to 4,294,967,295
ulint	Unsigned 64-bit integer	Full 64-bit range
real	32-bit floating point	IEEE 754 single precision
lreal	64-bit floating point	IEEE 754 double precision
string	Character string	Variable length

Tag Naming Conventions

Allen-Bradley PLCs use a hierarchical tag naming system:

Controller-Scoped Tags

Temperature
Motor1_Speed
Process_Data

Program-Scoped Tags

Program:Main.LocalVar
Program:Safety.EmergencyStop

Array Elements

DataArray[0]
Temperature_History[5]
Motor_Speeds[0]

Structure Members

Motor.Speed
Pump_Data.Pressure
Recipe.Step1.Duration

Case Sensitivity

CIP protocol is case-insensitive. Tags like Temperature, TEMPERATURE, and temperature all reference the same tag.

Function Builder

Creating EtherNet/IP Functions

After saving the connection, author reusable EtherNet/IP functions:

1. Open Functions → New Function
2. Choose the appropriate function type: Read Tag, Write Tag, Read Multiple Tags, Write Multiple Tags, or Browse Tags
3. Select the EtherNet/IP connection profile you configured
4. Define tag names, data types, and execution options

Quick Add: Bulk Function Creation

When you need to create multiple EtherNet/IP functions at once, the Quick Add feature accelerates the setup process by allowing batch creation from a table or CSV import.

When to Use Quick Add

• Onboarding a new PLC with many tags to monitor
• Converting existing tag lists from PLC programming software
• Rapidly setting up data collection for multiple process variables
• Standardizing function definitions across similar PLCs

How to Use Quick Add

1. Navigate to your EtherNet/IP connection in Connections
2. Click Quick Add Functions button
3. Choose your input method:
   • Table Entry: Define functions row by row in the interface
   • CSV Import: Upload a prepared CSV file with tag definitions

Table Columns

Column	Required For	Description	Example
Function Name	All	Unique name for the function within this connection	Read_Temperature
Type	All	EtherNet/IP operation	ethernetip.read, ethernetip.write, ethernetip.read_tags, ethernetip.write_tags, ethernetip.browse
Tag Name	All except browse	Full tag path, supports array indices, structure members, and program scopes	Temperature, Program:Main.Speed, DataArray[0]
Data Type	All except browse	CIP data type (see Supported Data Types)	real, dint, bool
Value	Writes only (write, write_tags)	Literal value or ((paramName)) template substituted at run-time	75.5, ((targetTemp))
Filter	Browse only	Optional prefix filter for ethernetip.browse — leave blank to browse all tags	Motor, Program:Main.
Labels	Optional, all	Per-function tags for filtering and grouping. Click the Labels button to edit; the badge shows the current count. In CSV use key=value;key=value. Up to 10 labels per function.	area=process;env=prod

Read rows leave Value blank; browse rows leave Tag Name / Data Type / Value blank and may put a prefix in Filter. Write rows require both Data Type and Value.

Supported Function Types

• ethernetip.read (Read Tag) — read one tag from the PLC
• ethernetip.write (Write Tag) — write a value to one tag in the PLC
• ethernetip.read_tags (Read Multiple Tags) — read N tags in a single batched request
• ethernetip.write_tags (Write Multiple Tags) — write N tag values in a single batched request
• ethernetip.browse (Browse Tags) — discover available tags, optionally filtered by a prefix

Automatic Grouping

Rows whose function type is ethernetip.read_tags or ethernetip.write_tags and share the same Function Name auto-merge into a single batch function:

name,functionType,tagName,dataType,value,filter,labels
Process_Readings,ethernetip.read_tags,Temperature,real,,,area=process
Process_Readings,ethernetip.read_tags,Pressure,real,,,area=process
Process_Readings,ethernetip.read_tags,FlowRate,real,,,area=process

The three rows above produce one function called Process_Readings whose config is { tags: [{tagName:"Temperature",…}, {tagName:"Pressure",…}, {tagName:"FlowRate",…}] }. Labels from every contributing row are merged into one set on the resulting function. The Quick Add table shows grouped rows with a coloured left border to make the grouping visible. Each row's per-tag test result fans out across every row that contributed to the same function.

If two grouped rows set the same label key to different values, validation flags the conflict before submit — rather than silently picking one. Setting the same key on multiple rows with the same value is fine and is the common case.

Single-tag function types (ethernetip.read, ethernetip.write, ethernetip.browse) never group — 1 row = 1 function regardless of name collisions, which are auto-suffixed _2, _3, …

CSV Import Format

The CSV header must match the column keys exactly (case-insensitive). Note: functionType — not type.

The labels column is optional. Pairs are separated by ; and each pair uses key=value. The first = per pair is the delimiter so values can contain =. Label values cannot contain a literal ; in CSV — use the popover editor when you need that.

name,functionType,tagName,dataType,value,filter,labels
Read_Temperature,ethernetip.read,Temperature,real,,,area=process;env=prod
Read_MotorStatus,ethernetip.read,Motor1_Running,bool,,,area=motors
Write_Setpoint,ethernetip.write,Setpoint,real,75.5,,team=automation
Write_TargetFromParam,ethernetip.write,Setpoint,real,((targetTemp)),,team=automation;priority=high
Process_Readings,ethernetip.read_tags,Temperature,real,,,area=process
Process_Readings,ethernetip.read_tags,Pressure,real,,,area=process
Process_Readings,ethernetip.read_tags,FlowRate,real,,,area=process
Recipe_Setpoints,ethernetip.write_tags,Setpoint,real,75.5,,team=recipe
Recipe_Setpoints,ethernetip.write_tags,Tank1_Setpoint,real,50.0,,team=recipe
Browse_MotorTags,ethernetip.browse,,,,Motor,

CSV import accepts both the short form (read, write, read_tags, write_tags, browse) and the canonical ethernetip.* form — both are normalised before grouping. Files exported from Excel-on-Windows (with a UTF-8 BOM) are accepted; the BOM is stripped automatically.

Use the Example CSV button in the Quick Add dialog header to download a starter template with these exact columns, or Copy / Download inside the CSV Format Guide pane.

Validation Rules

• Function names must be unique within the connection (duplicates within a single Quick Add batch are auto-suffixed _2, _3, …).
• Tag names follow Allen-Bradley syntax ([A-Za-z_][A-Za-z0-9_\[\]\.\:]*) or contain a ((paramName)) template.
• Data Type must be one of the supported CIP types; blank or unknown values are rejected at row level before submit.
• For write rows: Value is required and cannot be blank.
• For browse rows: only Function Name is required; Filter is optional.
• Labels are optional. Each label needs a non-empty key and value; keys must be unique within a row; up to 10 labels per function. In grouped multi-tag functions, conflicting label values across rows fail validation before submit.
• Validation runs before Test All and Create — errors surface inline on each row.

Test All vs Submit

Both Test All and Create N Functions build their payload from the same row-to-wire-format builder. A multi-tag group is tested as the full multi-tag function (not as N single-tag slices), so what passes Test All is exactly what gets submitted. Per-row Test on a multi-tag row also builds the whole group, so the per-row test result mirrors the production execution shape.

Read Tag Function

Purpose: Read a single tag value from the PLC. Supports scalar values and array elements.

Configuration Fields

Field	Type	Required	Default	Description
Tag Name	String	Yes	-	Full tag path (e.g., Temperature, Program:Main.Speed, DataArray[0])
Data Type	Enum	Yes	-	CIP data type (bool, sint, int, dint, lint, usint, uint, udint, ulint, real, lreal, string)
Length	Number	No	1	Number of elements to read (1 for scalar, >1 for array reads, max 10000)

Use Cases: Process variable monitoring, sensor readings, equipment status checks, setpoint verification

Example Output

{
  "value": 75.5,
  "tagName": "Temperature",
  "dataType": "real"
}

Write Tag Function

Purpose: Write a value to a single tag in the PLC. Supports automatic type conversion.

Configuration Fields

Field	Type	Required	Default	Description
Tag Name	String	Yes	-	Full tag path (e.g., Setpoint, Program:Main.Target)
Data Type	Enum	Yes	-	CIP data type for the target tag
Value	Any	Yes	-	Value to write (supports parameters with ((parameterName)) syntax)
Length	Number	No	1	For arrays, number of elements to write

Use Cases: Setpoint updates, recipe downloads, equipment control, alarm acknowledgement

Safety First

Always implement validation and safety checks before writing to industrial equipment. Consider adding condition nodes to verify values are within safe ranges before writing to the PLC.

Read Multiple Tags Function

Purpose: Read multiple tags in a single batch operation. More efficient than multiple single-tag reads.

Configuration Fields

Field	Type	Required	Default	Description
Tags	Array	Yes	-	Array of tag definitions, each with tagName and dataType

Tag Definition Fields

Field	Type	Required	Description
tagName	String	Yes	Full tag path
dataType	Enum	Yes	CIP data type

Use Cases: Dashboard data collection, periodic process snapshots, historian logging, batch process monitoring

Example Output

{
  "results": [
    { "tagName": "Temperature", "value": 75.5, "success": true },
    { "tagName": "Pressure", "value": 14.7, "success": true },
    { "tagName": "FlowRate", "value": 120.3, "success": true }
  ]
}

Write Multiple Tags Function

Purpose: Write values to multiple tags in a single batch operation.

Configuration Fields

Field	Type	Required	Default	Description
Tags	Array	Yes	-	Array of tag definitions, each with tagName, dataType, and value

Tag Definition Fields

Field	Type	Required	Description
tagName	String	Yes	Full tag path
dataType	Enum	Yes	CIP data type
value	Any	Yes	Value to write

Use Cases: Recipe downloads, batch setpoint updates, coordinated control actions, system configuration updates

Example Output

{
  "results": [
    { "tagName": "Setpoint1", "success": true },
    { "tagName": "Setpoint2", "success": true },
    { "tagName": "Mode", "success": true }
  ]
}

Browse Tags Function

Purpose: Discover and list all available tags in the PLC. Useful for initial setup and tag exploration.

Configuration Fields

Field	Type	Required	Default	Description
Filter	String	No	-	Optional prefix filter to narrow results (case-insensitive). Leave empty to browse all tags

Use Cases: PLC tag discovery, documentation generation, configuration validation, integration setup

Example Output

{
  "tags": [
    { "name": "Temperature", "dataType": "real", "scope": "controller" },
    { "name": "Motor1_Speed", "dataType": "dint", "scope": "controller" },
    { "name": "Program:Main.LocalVar", "dataType": "int", "scope": "program" }
  ]
}

Using Parameters

Parameters follow the ((parameterName)) syntax and appear in the function editor panel. Use parameters to make functions reusable across different contexts.

Configuration	Description	Example
Type	Coerce runtime values into CIP data types	number, string, boolean
Required	Enforce presence of the parameter	Required / Optional
Default Value	Provide fallback values for unattended runs	0, false, 100.0
Description	Help field to capture parameter purpose	"Target temperature setpoint in degrees C"

Example: A write function with a parameterized value:

• Tag Name: Setpoint
• Data Type: real
• Value: ((targetValue))

This allows the same function to write different values based on pipeline inputs.

Pipeline Integration

Use the EtherNet/IP connection functions you create here as nodes inside the Pipeline Designer to coordinate PLC data with the rest of your production flow.

EtherNet/IP Node

The EtherNet/IP Node executes a single function from your connection. Drag the node onto the canvas, select your connection and function, bind parameters to upstream outputs or constants, and tune retries or error branches as needed.

The function you select determines the operation: read, write, browse, or batch operations are all performed through the same node type.

If you are planning broader orchestration, review the Connector Nodes page for guidance on where EtherNet/IP nodes fit within multi-system automation patterns.

EtherNet/IP Read Group Node

The EtherNet/IP Read Group node allows you to execute multiple read operations efficiently within a single node. Use this for comprehensive data collection from multiple tags or connections.

When to use Read Group vs. standard node:

Approach	Use Case
EtherNet/IP Node	Execute a single function (read, write, browse, or batch operation)
Read Group Node	Execute multiple read functions from one or more connections in a single node