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	Description	Example
Function Name	Unique identifier for the function	Read_Temperature
Type	EtherNet/IP operation	Read Tag, Write Tag
Tag Name	Full tag path	Temperature, Program:Main.Speed
Data Type	CIP data type	real, dint, bool

CSV Import Format

name,functionType,tagName,dataType,value
Read_Temperature,read,Temperature,real,
Read_MotorStatus,read,Motor1_Running,bool,
Write_Setpoint,write,Setpoint,real,75.5
Read_Process_Values,read_tags,Temperature,real,
Read_Process_Values,read_tags,Pressure,real,
Write_Setpoints,write_tags,Setpoint,real,75.5

Grouping for Multi-Tag Functions

When importing read_tags or write_tags functions, rows with the same function name are grouped together:

name,functionType,tagName,dataType,value
Process_Readings,read_tags,Temperature,real,
Process_Readings,read_tags,Pressure,real,
Process_Readings,read_tags,FlowRate,real,

This creates a single Process_Readings function that reads all three tags in one batch operation.

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