EtherNet/IP Integration Guide

Connect MaestroHub to Allen-Bradley controllers over EtherNet/IP and work with their tags — the named variables of a controller program, such as Motor1_Speed or Program:Main.BatchCount. This guide covers everything you need: creating the connection, the controller families, every function type with its exact inputs and outputs, the tag picker, data types, limits, troubleshooting, and how to configure the connector through the API or an AI agent.

Overview

The EtherNet/IP connector provides:

• Tag reads and writes by name — controller-scoped and program-scoped tags, array elements, bits of integers (read), structure members, and whole structures (UDTs)
• Batch reads and writes — many tags in one call, each tag with its own result, so one bad tag never hides the others' values
• Automatic data types — read a tag as the controller types it, without knowing its type in advance
• Tag discovery — list the controller's tags with their types, and the members of every structure
• A tag picker in the function editor — browse the controller, or load a Studio 5000 export (.L5X) to pick tags without a live connection
• Keep-alive, request deadlines, and a Test Connection that tells you what to fix

Supported controllers

Controller family	Models	Setting
Logix	ControlLogix (1756), CompactLogix (1769, 5370, 5380, 5480) and other Logix 5000 controllers	Controller Family Logix, and the CPU's slot
Micro800	Micro820, Micro850, Micro870	Controller Family Micro800 (no slot)

Not supported

Older Allen-Bradley controllers that speak PCCC rather than Logix tag services — SLC 500, MicroLogix and PLC-5 — are not supported by this connector. Cyclic (implicit, class 1) I/O connections are not used: the connector reads and writes tags on request.

Before you start

• Network: MaestroHub must reach the controller's IP address on TCP port 44818 (the EtherNet/IP standard). For a ControlLogix, the address is the Ethernet module's (for example a 1756-EN2T) — the connector then routes to the CPU through the chassis.
• Tag names: you address tags by the names in the controller program. You can find them with Browse Tags, the tag picker, or a Studio 5000 export.
• External Access: in Studio 5000, a tag whose External Access is None cannot be read or written by any client, and Read Only refuses writes. Constants refuse writes too.
• Micro800: only global variables are reachable over the network; a program's local variables are not. A Micro800 does not describe its structures to network clients, so structures (UDTs) and BOOL arrays are not listed by Browse and cannot be read whole with data type udt.

Connection Configuration

Creating an EtherNet/IP Connection

From Connections → New Connection → EtherNet/IP, fill in the fields below, then click Test Connection and Create Connection.

Field	Default	Description
Profile Name	–	A descriptive name for this connection (required, up to 100 characters)
Description	–	Optional free text
Labels	–	Key–value pairs to organise connections (up to 10), for example plant: north, line: packaging
PLC Host	–	IP address or hostname of the controller, or of the ControlLogix Ethernet module (required)
Port	44818	TCP port. Change it only if your network maps EtherNet/IP to another port
Controller Family	Logix	Logix (ControlLogix, CompactLogix) or Micro800 (Micro820, Micro850, Micro870) — see below
PLC Slot	0	Slot of the CPU in the chassis, 0–16 (Logix only). Disabled for a Micro800, which takes no slot
Timeout (ms)	5000	How long to wait for the controller to answer one request, 1000–60000 in the form (the API accepts up to 300000). A request that is not answered in time fails, and the connection is re-opened for the next one
Keep-Alive	on	Send a small request every keep-alive interval while no function runs, so the controller does not close an idle connection
Keep-Alive Interval (ms)	10000	Time between keep-alive requests, 1000–60000 in the form

Controller Family and slot

The controller family decides how the connection reaches the CPU and how batches are sent:

	Logix	Micro800
Route to the CPU	Through the chassis to the slot you set	None — the controller answers directly
PLC Slot	The CPU's slot (0 for a CompactLogix, whose CPU is always slot 0)	Not used
Read/Write Multiple Tags	As many tags per request as fit	One tag per request, with the same per-tag results
Program-scoped tags	Program:<Program>.<Tag>	Not reachable (global variables only)
Structures (UDTs)	Listed by Browse with their members; readable whole (udt)	Not listed; not readable whole
Connections the controller accepts	Many (depends on the controller)	Up to 16 at a time — keep the number of MaestroHub connections and other clients to one controller small

A connection saved without a controller family is a Logix connection — every connection created before this setting existed keeps working unchanged.

Choosing the slot (Logix)

Controller	Slot
CompactLogix (1769, 5370, 5380, 5480)	0
ControlLogix (1756)	The physical slot of the CPU module, counting from 0 at the left of the chassis

Test Connection

Test Connection opens a real connection to the controller, runs the keep-alive check, asks the controller what it is, and closes the connection. It passes when the controller answers, and adds a note — without failing — when something deserves attention:

Note	What to do
The controller identifies itself as 1756-L83E/B, which is not a Micro800, but the controller family is micro800 …	Set the Controller Family to Logix and enter the CPU's slot
The controller identifies itself as 2080-…, a Micro800, but the controller family is logix …	Set the Controller Family to Micro800
Keep-alive is on, but the controller refused the keep-alive request …	Nothing required: the connection runs without keep-alive, and the controller may close it after a quiet period; the next request reconnects
The slot (N) is not used: a Micro800 takes no route.	Nothing required; the slot is ignored
The controller did not say what it is …	The family could not be checked; the connection itself works

When the controller refuses the connection, the error says what to check:

• on a Logix connection: "… the connection was routed to the CPU in slot N: check the slot; a Micro800 (Micro820/850/870) takes no route: set controllerFamily to micro800"
• on a Micro800 connection: "… the connection was opened without a route, as a Micro800 takes it; for a ControlLogix or CompactLogix set controllerFamily to logix and the CPU's slot"

When nothing answers at all, the error names the host and port it tried: check the address, the port, and that the network lets MaestroHub reach the controller.

Keep-alive

A controller closes a connection on which nothing has been sent for a while (roughly a minute and a half). With Keep-Alive on, the connector sends one small request every Keep-Alive Interval while no function runs, so the connection stays open and a pipeline that runs every few minutes does not reconnect each time. The setting is checked once when the connection opens: a controller that refuses the keep-alive request keeps its connection, runs without keep-alive, and Test Connection says so. If a keep-alive request goes unanswered, the connection is re-opened, as it would be for any unanswered request.

Timeouts

Three limits can end a request, and the shortest applies:

Limit	Where it is set	Default
Timeout (ms) of the connection	The connection form	5 s — how long to wait for each answer from the controller
Request timeout of a function	requestTimeout in the function's configuration (API) — a duration such as "10s", 1s–1h	30 min
Node deadline of a pipeline	The pipeline node's settings	The pipeline's

When a limit is reached, the request fails with a message saying so and the connection is re-opened; requests made in the few seconds while it re-opens fail with "not connected" and succeed again once it is back. Raise the connection timeout for controllers on slow links and for very large arrays or structures.

Tags and addressing

Tag names are not case-sensitive: Temperature, TEMPERATURE and temperature are the same tag.

What	Syntax	Example
Controller-scoped tag	<Tag>	Motor1_Speed
Program-scoped tag (Logix)	Program:<Program>.<Tag>	Program:MainProgram.BatchCount
Array element	<Tag>[i]	Temperature[3]
Element of a multi-dimensional array	<Tag>[i,j]	Matrix[1,2]
Structure (UDT) member	<Tag>.<Member>	Motor1.Speed
Nested member	<Tag>.<Member>.<Member>	Line1.Drive.Speed
Member of an array element	<Tag>[i].<Member>	Motors[2].Speed
Bit of an integer (read only)	<Tag>.<bit>	StatusWord.3 (DINT bits 0–31, INT 0–15, SINT 0–7)
Whole array	the tag name + Length	Temperature with Length 10
Part of an array	the first element + Length	Temperature[4] with Length 3 reads elements 4, 5 and 6
A parameter	((name)) anywhere in the name	((line)).Speed, Motors[((index))]

Data types

Every read and write names a data type. Use the lowercase names below (the connector also accepts them in upper case).

Data Type	Controller type	Values	Read	Write
bool	BOOL	true / false	✓	✓
sint	SINT	−128 to 127	✓	✓
int	INT	−32,768 to 32,767	✓	✓
dint	DINT	−2,147,483,648 to 2,147,483,647	✓	✓
lint	LINT	64-bit signed	✓	✓
usint	USINT	0 to 255	✓	✓
uint	UINT	0 to 65,535	✓	✓
udint	UDINT	0 to 4,294,967,295	✓	✓
ulint	ULINT	64-bit unsigned	✓	✓
real	REAL	32-bit floating point	✓	✓
lreal	LREAL	64-bit floating point	✓	✓
string	STRING (string types of your own read as text too)	Text; a STRING write stores up to 82 characters	✓	✓
udt	Any structure: a user-defined type, an Add-On Instruction, a TIMER…	An object of the structure's members	✓	–
auto	Whatever the tag is	As the controller types it; the result names the type	✓	–

BOOL arrays. A Logix controller stores a BOOL array 32 bits to a DWORD, and reports it that way: Browse lists a BOOL[64] as a DWORD array of 2 elements, a BOOL array inside a structure appears as DWORD members, and auto reads them as unsigned 32-bit words (udint), bit 0 of the first word being element 0.

The type must match the tag. A Read Tag whose data type is not the tag's is refused with the tag's real type — "failed to read tag 'Motor1_Speed': the tag is REAL; the function reads it as dint" — so change the data type, or use auto. In Read Multiple Tags each value is returned as the controller types it, whatever the entry says.

udt — a whole structure

Reads a structure tag in one call and returns it as an object keyed by member name — nested structures as nested objects, array members as lists, BOOL members as true/false, STRING members as text. Members Studio 5000 keeps hidden are left out. The result carries udtName, the structure's name in the controller.

{ "tagName": "Motor1", "dataType": "udt", "udtName": "MotorUDT", "quality": "good",
  "value": { "Running": true, "Faulted": false, "Speed": 1234.5, "Count": 77, "Label": "Conveyor A" } }

• An array of structures reads with a Length (up to 1000) and returns a list of objects.
• A structure is written member by member: write Motor1.Speed as real, Motor1.Running as bool. A write with data type udt is refused.
• To read a single member, address it: Motor1.Speed with data type real.

auto — the controller's type

Reads the tag and returns the value as the controller types it; the result's dataType names what it found — dint, real, string, bool for a bit, udt (with udtName) for a structure. BYTE, WORD, DWORD and LWORD tags read as usint, uint, udint and ulint. Use it when you do not know a tag's type, or when a function reads tags of different types through a parameter. Writes always name a type: auto is refused there.

Function Builder

After saving the connection, create functions — reusable, named operations — from the connection's Functions tab → New Function, then pick the function type:

Function type	ID	Purpose
Read Tag	ethernetip.read	Read one tag, array or structure
Write Tag	ethernetip.write	Write one tag or array
Read Multiple Tags	ethernetip.read_tags	Read many tags in one call, each with its own result
Write Multiple Tags	ethernetip.write_tags	Write many tags in one call, each with its own result
Browse Tags	ethernetip.browse	List the controller's tags and the members of its structures

Every function has a Test Function button that runs it against the controller before you save.

The tag picker

The Browse Tags panel beside the Read Tag, Write Tag, Read Multiple Tags and Write Multiple Tags forms lets you pick tags instead of typing them:

• Browse lists the controller's tags (the connection must be able to reach it).
• Load L5X reads the tags from a Studio 5000 export (.L5X) — no connection to the controller needed. The file is read in your browser and never uploaded; exports up to 100 MB are accepted. To export, open the project in Studio 5000 (Logix Designer) and choose File → Save As… with the file type Logix Designer XML File (*.L5X). For a very large project, export a part of it instead — right-click a program and choose Export Program… — and load that.

In the list:

• a structure expands into its members, an array into its elements (the first 1000; type any other index by hand);
• the filter box narrows the list by tag name, type or description;
• clicking a row fills the form exactly as typing would: the tag name, its data type, and — for a whole array — its Length. In Read/Write Multiple Tags a click fills the first empty row, or adds one;
• a row that the form cannot take stays visible, greyed out, with the reason — a structure in a write form (written member by member — expand it and pick a member), a whole array in a Multiple Tags form (one element per tag), an array longer than a read or write takes, and, from an L5X, a tag whose External Access is None or Read Only, a constant, or an alias in a write form;
• a tag whose type the form does not name (for example a DWORD) is picked with data type auto in a read form.

The last list you loaded stays available for that connection while the page is open, so you can create several functions in a row without browsing again; reloading the page clears it.

Read Tag

Purpose: read one tag — a single value, an array or a part of one, a bit, a structure member, or a whole structure.

Field	Required	Default	Description
Tag Name	Yes	–	The tag's address — see Tags and addressing. Supports ((parameters))
Data Type	Yes	dint	Any type of the table, including udt and auto
Length	No	1	Number of elements: 1 for a single value; more for an array, starting at the element in Tag Name. Up to 10000, or 1000 for udt

Output — a single value:

{ "tagName": "Motor1_Speed", "dataType": "real", "value": 1500.5, "quality": "good" }

An array (Length > 1) adds length and isArray, and value is a list:

{ "tagName": "Temperature", "dataType": "real", "value": [20, 21, 22], "length": 3, "isArray": true, "quality": "good" }

A whole structure adds udtName (see udt). With auto, dataType is the type the controller gave.

Use cases: process variables, equipment status, a whole equipment structure in one read, historian collection of an array.

Write Tag

Purpose: write one tag, one element, a structure member, or a run of array elements.

Field	Required	Default	Description
Tag Name	Yes	–	The tag's address; for an array, the first element to write
Data Type	Yes	dint	The tag's type — one of the 12 writable types (not udt or auto)
Value	Yes	–	The value to write; supports ((parameters))
Length	No	1	Number of elements to write, starting at Tag Name (up to 10000)

Values

Data type	Accepted values
bool	true / false, 1 / 0, yes / no, on / off
integers	Whole numbers within the type's range (25.5 is refused for a dint)
real, lreal	Numbers
string	Text; up to 82 characters are stored, longer text is cut to 82
An array (Length > 1)	A list: [1, 2, 3], or the elements separated by commas: 1, 2, 3. For STRING elements that contain a comma use the bracketed form: ["a,b", "c"]

The list may hold fewer elements than Length; only the elements given are written.

Output:

{ "tagName": "Setpoint1", "dataType": "real", "value": 25.5 }

An array write adds length and isArray.

Not writable: a bit of an integer (StatusWord.3) — write the whole integer, or a BOOL tag; a whole structure — write its members; a tag whose External Access is Read Only or None, and constants — the controller refuses them ("the controller refused access: the tag is read-only or its External Access forbids it").

Safety First

Writes change a running process. Validate values before writing to industrial equipment — for example with a condition node that checks a value is within a safe range — and restrict who can create and run write functions.

Read Multiple Tags

Purpose: read many tags in one call. The connector sends them in as few requests as the connection allows (on a Micro800, one per tag), and every tag gets its own result: a tag the controller refuses is marked bad with its reason, and every other tag still delivers its value.

Field	Required	Description
Tags	Yes	A list of entries, each with a Tag Name and a Data Type (udt and auto included). Each entry reads one element — use Temperature[3], not a Length

Output:

{
  "tags": [
    { "tagName": "ProductCount", "dataType": "dint", "success": true, "value": 42, "quality": "good" },
    { "tagName": "Motor1", "dataType": "udt", "udtName": "MotorUDT", "success": true, "value": { "Running": true, "Speed": 1234.5 }, "quality": "good" },
    { "tagName": "NoSuchTag", "dataType": "dint", "success": false, "error": "not found on the controller (CIP status 0x04: path segment error)", "quality": "bad" }
  ],
  "count": 3,
  "quality": "bad"
}

• quality of the whole result is bad when any tag failed, good otherwise.
• When some tags fail, the function reports a summary — "1 of 3 tags failed (NoSuchTag: not found on the controller …)" — the Test dialog shows it in red, and in a pipeline the node still completes with every tag's result, so the next nodes can use the values that were read and branch on the ones that were not.

Write Multiple Tags

Purpose: write many tags in one call, each tag with its own result.

Field	Required	Description
Tags	Yes	A list of entries, each with Tag Name, Data Type (one of the 12 writable types) and Value. One element per entry

Output:

{
  "tags": [
    { "tagName": "Setpoint1", "dataType": "real", "success": true },
    { "tagName": "Setpoint2", "dataType": "dint", "success": false, "error": "value conversion failed: cannot parse string '25.5' to int32 …" }
  ],
  "count": 2,
  "successCount": 1,
  "failureCount": 1
}

• A tag whose value does not convert to its type is refused before anything is sent; the others are written.
• A tag the controller refuses carries the controller's reason; the others are written.
• As with reads, a partial failure is summarised ("1 of 2 tags failed (Setpoint2: …)") and a pipeline node completes; branch on failureCount or on each tag's success.

Browse Tags

Purpose: list the controller's tags — controller-scoped and every program's — with their types, and the members of every structure they hold.

Field	Required	Description
Filter	No	Keep only tags whose name or address starts with this text (not case-sensitive), for example Motor or Program:Main.. Leave empty to list everything

Output:

{
  "tags": [
    { "name": "Temperature", "address": "Temperature", "dataType": "REAL", "dimensions": [10], "isArray": true, "isStruct": false },
    { "name": "Motor1", "address": "Motor1", "dataType": "UDT", "udtName": "MotorUDT", "dimensions": [], "isArray": false, "isStruct": true },
    { "name": "program:MainProgram.BatchCount", "address": "Program:MainProgram.BatchCount", "dataType": "DINT", "dimensions": [], "isArray": false, "isStruct": false, "program": "MainProgram" }
  ],
  "tagCount": 3,
  "types": {
    "MotorUDT": [
      { "name": "Running", "dataType": "BOOL", "dimensions": [], "isArray": false, "isStruct": false },
      { "name": "Speed", "dataType": "REAL", "dimensions": [], "isArray": false, "isStruct": false },
      { "name": "Label", "dataType": "STRING", "dimensions": [], "isArray": false, "isStruct": true }
    ]
  }
}

Key	Meaning
address	The tag name to use in a read or write — for a program tag, Program:<Program>.<Tag>
name	The tag's listed name (for a program tag, program:<Program>.<Tag>)
dataType	The controller's type name in upper case (DINT, REAL, …), STRING for a string, UDT for a structure
udtName	For a structure: its type's name
dimensions, isArray	An array's size per dimension
isStruct	true for a structure, a STRING included
program	For a program-scoped tag: the program's name
types	Every structure the listed tags hold, nested ones included, by name: each member's name, dataType, dimensions, isArray, isStruct, and udtName when the member is itself a structure. A member is read as <address>.<member name>

Browse lists the tags a client can use: controller system entries, hidden tags (names starting with __) and module-defined I/O tags (names with a colon, such as Local:1:I) are not listed, and programs themselves are not listed as tags. On a Micro800 it lists the global variables, except structures and BOOL arrays, which a Micro800 does not list.

Using Parameters

Any Tag Name or Value can contain parameters with the ((parameterName)) syntax. They appear in the function editor's Function Parameters panel and are filled in when the function runs — from a pipeline, or from the Test dialog.

Setting	Description	Example
Type	The type the value is given in	number, string, boolean
Required	Whether a value must be given	Required / Optional
Default Value	Used when no value is given	0, false, 100.0
Description	What the parameter is for	"Target temperature in °C"

Examples:

• Write Tag, Tag Name Setpoint, Data Type real, Value ((target)) — one function writes any setpoint a pipeline computes.
• Read Tag, Tag Name ((tag)), Data Type auto — one function reads any tag by name.
• Write Tag, Tag Name Recipe, Length 4, Value ((steps)) — a parameter holding 10, 20, 30, 40 writes four elements.

Quick Add: Bulk Function Creation

To create many functions at once — onboarding a controller, converting a tag list — use Quick Add Functions on the connection's Functions tab: enter rows in a table or import a CSV.

Columns

Column	Required For	Description	Example
Function Name	All	Unique name within the connection	Read_Temperature
Type	All	ethernetip.read, ethernetip.write, ethernetip.read_tags, ethernetip.write_tags, ethernetip.browse (or the short form read, write, read_tags, write_tags, browse)	ethernetip.read
Tag Name	All except browse	The tag's address	Temperature, Program:Main.Speed, DataArray[0]
Data Type	All except browse	A type from Data types; udt and auto only on read rows	real, dint, udt
Value	Writes	The value, or a ((parameter))	75.5, ((targetTemp))
Filter	Browse	Optional prefix	Motor
Labels	Optional	key=value;key=value, up to 10	area=process;env=prod

Quick Add creates single-element functions (Length 1); set a Length afterwards in the function editor for arrays.

Automatic grouping: rows of type read_tags or write_tags that share a Function Name become one Read/Write Multiple Tags function with one entry per row; their labels are merged. Single-tag and browse rows never group; duplicate names get _2, _3, … Validation flags duplicate tags within a group, conflicting label values across a group's rows, missing values on write rows, unknown data types, and udt/auto on write rows — before anything is created.

CSV format — the header must match the column keys (not case-sensitive); note functionType, not type:

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
Read_Motor,ethernetip.read,Motor1,udt,,,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,

The Example CSV button in the Quick Add dialog downloads this template. Files saved by Excel on Windows (with a byte-order mark) are accepted. Test All and Create build exactly the same functions, so what passes the test is what is created.

Pipeline Integration

Use the functions as nodes in the Pipeline Designer.

EtherNet/IP Node

The EtherNet/IP node runs one function of a connection: pick the connection and the function, bind its parameters to upstream outputs or constants, and set retries or an error branch. The function decides the operation. The node's output is the function's result under result — see the EtherNet/IP node reference for every key.

• A Read/Write Multiple Tags node completes even when some tags failed: branch on result.quality, result.failureCount or each result.tags[i].success.
• An error that cannot succeed on a retry — a tag that does not exist, a wrong data type, a refused value, a read-only tag — is reported as permanent, so store-and-forward does not retry it; a lost connection or an unanswered request is reported as temporary.

EtherNet/IP Read Group Node

The EtherNet/IP Read Group node runs several read functions in one node and returns each function's result under its name — convenient for collecting a set of values at once.

Approach	Use Case
EtherNet/IP Node	One function: a read, a write, a batch or a browse
Read Group Node	Several read functions, results side by side
Read Multiple Tags function	Many tags of one controller read together in as few requests as possible

Configuring through the API or an AI agent

Connections and functions can also be created through the REST API or by an AI agent using MaestroHub's MCP tools. They take the same configuration the forms save.

Connection (type: "ethernetip"):

{
  "host": "192.168.1.10",
  "port": 44818,
  "controllerFamily": "logix",
  "slot": 0,
  "timeout": 5000,
  "keepAlive": true,
  "keepAliveInterval": 10000
}

Key	Type	Notes
host	string	Required
port	integer	Default 44818
controllerFamily	"logix" or "micro800"	Default logix; any other value is refused
slot	integer	0–16; ignored for micro800
timeout	integer, ms	Default 5000
keepAlive	boolean	Default true
keepAliveInterval	integer, ms	Default 10000

Functions — functionType plus functionConfig:

{ "functionType": "ethernetip.read", "functionConfig": { "tagName": "Motor1_Speed", "dataType": "real" } }
{ "functionType": "ethernetip.read", "functionConfig": { "tagName": "Temperature", "dataType": "real", "length": 10 } }
{ "functionType": "ethernetip.read", "functionConfig": { "tagName": "Motor1", "dataType": "udt" } }
{ "functionType": "ethernetip.read", "functionConfig": { "tagName": "((tag))", "dataType": "auto" } }
{ "functionType": "ethernetip.write", "functionConfig": { "tagName": "Setpoint1", "dataType": "real", "value": "25.5" } }
{ "functionType": "ethernetip.write", "functionConfig": { "tagName": "Temperature[7]", "dataType": "real", "length": 3, "value": [71.5, 81.5, 91.5] } }
{ "functionType": "ethernetip.read_tags", "functionConfig": { "tags": [ { "tagName": "ProductCount", "dataType": "dint" }, { "tagName": "Motor1", "dataType": "auto" } ] } }
{ "functionType": "ethernetip.write_tags", "functionConfig": { "tags": [ { "tagName": "Setpoint1", "dataType": "real", "value": "1.5" }, { "tagName": "Mode", "dataType": "usint", "value": "2" } ] } }
{ "functionType": "ethernetip.browse", "functionConfig": { "filter": "Motor" } }

• dataType is required on every read and write entry; use auto when the type is unknown (reads only).
• value may be a number, a boolean, text, or — for an array — a list or its text form ("[1, 2, 3]", "1, 2, 3").
• length is optional (default 1); requestTimeout is optional, a duration such as "10s" (1s–1h, default 30m).
• A good first step for an agent is a Browse Tags call: its address values are the tag names to use, its dataType (in lower case) the data types, and types the members of each structure.

Limits

What	Limit
Elements in one read or write (Length)	10,000
Elements in one read of whole structures (udt)	1,000
Characters stored by a STRING write	82
Nesting depth of a structure read whole	8 levels
Array elements listed by the tag picker	the first 1,000 (type any other index)
Size of an L5X file loaded in the tag picker	100 MB

Troubleshooting

Message	Meaning	What to do
failed to read tag 'X': not found on the controller (CIP status 0x04 …)	No tag of that name — or a program tag without its Program: prefix	Check the spelling and scope; use Browse Tags or the tag picker
the tag is REAL; the function reads it as dint	The data type does not match the tag	Set the data type the message names, or use auto
the controller refused access: the tag is read-only or its External Access forbids it	External Access is Read Only or None, or the tag is a constant	Change External Access in Studio 5000, or write another tag
the position is beyond the end of the tag / the elements asked for reach beyond the end of the tag	An index or a Length past the end of the array	Lower the index or the Length
writing a single bit of an integer is not supported	A write to Tag.3	Write the whole integer, or use a BOOL tag
dataType udt reads a whole structure and cannot be written	A write with data type udt	Write the members, each with its own type
a read of whole UDTs takes at most 1000 elements	A udt read with Length above 1000	Read fewer, or the members you need
value must be an array when length > 1 / value is not a list …	An array write whose value is not a list	Give [1, 2, 3] or 1, 2, 3
value conversion failed: cannot parse string '25.5' to int32	The value does not fit the data type	Fix the value or the data type
… the connection was routed to the CPU in slot N: check the slot …	The controller refused the connection	Check the slot; for a Micro800 set Controller Family to Micro800
not connected	The connection is being re-opened after a failure	Retry after a few seconds; it reconnects by itself
A request fails at its deadline	The controller did not answer within the timeout	Check the network; raise the connection Timeout or the function's request timeout
the controller's keyswitch position prevents the request / the controller is in upload or download mode	The controller is not in a state to serve requests	Retry once the controller is back in Run or Remote Run