User Guide

Overview

EthernetIPForUE v1.0.1.1 is a plugin that implements the EtherNet/IP (CIP) protocol for Unreal Engine 5.0~5.7. It enables UE projects to communicate with industrial PLCs, robot controllers, and EIP-compatible devices over standard TCP/IP networks.

The plugin provides two manager subsystems, each capable of creating multiple named instances for simultaneous connections to different devices:

Adapter (Server)

UE acts as an EIP device, waiting for external Scanner connections. Supports two protocols:

Protocol	Instance Class	Description
Assembly	`UEIPAssemblyAdapter`	Exposes a fixed-length Assembly data buffer
Tag	`UEIPTagAdapter`	Exposes named tags (CIP Symbol service)

Scanner (Client)

UE connects to remote EIP devices as a scanner. Supports two protocols:

Protocol	Instance Class	Description
Assembly	`UEIPAssemblyScanner`	Cyclic read/write via Assembly instance numbers
Tag	`UEIPTagScanner`	Reads/writes tags by name via CIP Symbol service

Quick Start

1. Enable the Plugin

Open your UE project.
Go to Edit → Plugins.
Search for "EthernetIPForUE" and check Enabled.
Restart the editor.

2. Start an Adapter (UE as Server)

Create and start an Adapter instance through UEIPAdapterManager:

Event BeginPlay
    → GetGameInstance → Get EIP Adapter Manager
    → GetAssemblyAdapter("MyAdapter")
    → Start(Port: 44818)

The adapter begins listening on port 44818. External EIP scanners can now connect.

Start multiple adapters on different ports:

→ GetAssemblyAdapter("RobotArm")   → Start(44818)
→ GetTagAdapter("SensorHub")       → Start(44819)

3. Start a Scanner (UE as Client)

Connect to a remote device through UEIPScannerManager:

→ GetGameInstance → Get EIP Scanner Manager
→ GetAssemblyScanner("PLCMain")
→ SetConnectionParams("192.168.1.100", 44818)
→ Start()

4. Instance Management

Method	Description
`GetAssemblyAdapter(Name)`	Get or create an Assembly Adapter
`GetTagAdapter(Name)`	Get or create a Tag Adapter
`GetAssemblyScanner(Name)`	Get or create an Assembly Scanner
`GetTagScanner(Name)`	Get or create a Tag Scanner
`Del(Name)`	Delete a named instance
`DelAll()`	Delete all instances
`GetActiveNames()`	Get names of all active instances
`GetActiveCount()`	Get total active instance count

Instances are held via UPROPERTY references — safe from GC. Del(Name) removes them from the manager, and GC collects them automatically.

5. Data Access

All instance names (Name/TagName) are FName type.

Assembly Adapter (Server) — Read/Write buffers used by the remote Scanner:

Method	Description
`ReadFloat(ByteOffset)`	Read a float from the input buffer (data written by Scanner)
`ReadFloat16(ByteOffset)`	Read a half-float from the input buffer
`ReadInt32(ByteOffset)`	Read an int32 from the input buffer
`ReadInt16(ByteOffset)`	Read an int16 from the input buffer
`ReadByte(ByteOffset)`	Read a byte from the input buffer
`ReadBool(ByteOffset, BitIndex)`	Read a bool from the input buffer
`ReadRaw(ByteOffset, Count)`	Read raw bytes from the input buffer
`WriteFloat(ByteOffset, Value)`	Write a float to the output buffer (what Scanner reads)
`WriteFloat16(ByteOffset, Value)`	Write a half-float to the output buffer
`WriteInt32(ByteOffset, Value)`	Write an int32 to the output buffer
`WriteInt16(ByteOffset, Value)`	Write an int16 to the output buffer
`WriteByte(ByteOffset, Value)`	Write a byte to the output buffer
`WriteBool(ByteOffset, BitIndex, Value)`	Write a bool to the output buffer

Assembly Scanner (Client) — Read/Write remote device Assembly buffers:

Method	Description
`WriteFloat(ByteOffset, Value)`	Write a float to the remote device
`WriteFloat16(ByteOffset, Value)`	Write a half-float to the remote device
`WriteInt32(ByteOffset, Value)`	Write an int32 to the remote device
`WriteInt16(ByteOffset, Value)`	Write an int16 to the remote device
`WriteByte(ByteOffset, Value)`	Write a byte to the remote device
`WriteBool(ByteOffset, BitIndex, Value)`	Write a bool to the remote device
`ReadFloat(ByteOffset)`	Read a float from the remote device
`ReadFloat16(ByteOffset)`	Read a half-float from the remote device
`ReadInt32(ByteOffset)`	Read an int32 from the remote device
`ReadInt16(ByteOffset)`	Read an int16 from the remote device
`ReadByte(ByteOffset)`	Read a byte from the remote device
`ReadBool(ByteOffset, BitIndex)`	Read a bool from the remote device
`ReadRaw(ByteOffset, Count)`	Read raw bytes from the remote device

Tag Scanner (Client):

Method	Description
`ReadTag(TagName)`	Read a tag by name (`FName`)
`WriteTag(TagName, Value)`	Write a tag by name (`FName`)

Tag Adapter (Server):

Method	Description
`RegisterTag(TagName, InitialValue)`	Register a tag accessible from external Scanners (`FName`)
`SetTagValue(TagName, Value)`	Set a tag value (`FName`)
`GetTagValue(TagName)`	Get a tag value (`FName`)

Manager Reference

UEIPAdapterManager

Manages all Adapter instances.

Method	Return Type	Description
`GetAssemblyAdapter(Name)`	`UEIPAssemblyAdapter*`	Get or create an Assembly Adapter instance
`GetTagAdapter(Name)`	`UEIPTagAdapter*`	Get or create a Tag Adapter instance
`Del(Name)`	void	Stop and delete the named instance
`DelAll()`	void	Stop and delete all instances
`GetActiveNames()`	`TArray<FName>`	Get all active instance names
`GetActiveCount()`	int32	Get active instance count

All instance name parameters (Name) are FName type.

UEIPScannerManager

Manages all Scanner instances.

Method	Return Type	Description
`GetAssemblyScanner(Name)`	`UEIPAssemblyScanner*`	Get or create an Assembly Scanner instance
`GetTagScanner(Name)`	`UEIPTagScanner*`	Get or create a Tag Scanner instance
`Del(Name)`	void	Stop and delete the named instance
`DelAll()`	void	Stop and delete all instances
`GetActiveNames()`	`TArray<FName>`	Get all active instance names
`GetActiveCount()`	int32	Get active instance count

All instance name parameters (Name) are FName type.

Components Reference

UEIPLinkComponent

Attach to any Actor. Reads/writes bound Scanner instance by ByteOffset or DataBind index.

Properties:

Property	Default	Description
`ScannerName`	`Default`	Bound Scanner instance name (passed to `GetAssemblyScanner`/`GetTagScanner`), `FName` type
`SubsystemType`	Assembly	Bound subsystem type (Assembly / Tag)
`ReadInstance`	100	Instance number for reads
`WriteInstance`	101	Instance number for writes
`UpdateInterval`	0.0	Data update interval in seconds (0 = every tick)
`DataBinds`	—	Array of data bind entries (ByteOffset + DataType + Scale + Offset), auto-read each tick
`InitialBufferSize`	24	Initial size of the raw value buffer, auto-grows when DataBinds exceed it

Events:

Event	Description
`OnEIPConnected`	Fires when a connection is established
`OnEIPDisconnected`	Fires when connection is lost
`OnDataUpdated`	Fires when data is updated
`OnEIPError`	Fires when an error occurs

Per-ByteOffset Read Methods:

GetFloatValue(ByteOffset)
GetFloat16Value(ByteOffset)
GetIntValue(ByteOffset)
GetInt16Value(ByteOffset)
GetBoolValue(ByteOffset, BitIndex)
GetByteValue(ByteOffset)

Per-ByteOffset Write Methods:

WriteFloatValue(ByteOffset, Value)
WriteFloat16Value(ByteOffset, Value)
WriteIntValue(ByteOffset, Value)
WriteInt16Value(ByteOffset, Value)
WriteByteValue(ByteOffset, Value)
WriteBoolValue(ByteOffset, BitIndex, Value)

DataBind Index Read Methods:

Method	Description
`GetItem(Index)`	Get raw byte buffer for a single DataBind entry
`GetItems()`	Get all DataBind entries as raw byte buffers
`GetValueAsFloat(Index)`	Get the value at DataBind Index as float (with Scale/Offset applied)
`GetValueAsInt(Index)`	Get the value at DataBind Index as int32
`GetValueAsInt64(Index)`	Get the value at DataBind Index as int64
`GetValuesAsFloat()`	Get all values as float array (aligned with DataBinds)
`GetValuesAsInt()`	Get all values as int32 array

Internally delegates to UEIPScannerManager via GetAssemblyScanner(ScannerName) or GetTagScanner(ScannerName).

UEIPAnimLinkComponent

Inherits from UEIPLinkComponent. Adds per-frame smoothed value caching with configurable interpolation.

Property	Default	Description
`MonitorLinks`	—	Array of link entries (ByteOffset + DataType + Scale + Offset)
`InterpSpeed`	10.0	`FInterpTo` speed (0 = no smoothing)
`CachedValues`	—	(ReadOnly) Smoothed value buffer

Global Configuration (v1.0.1.1+ Flexible Mode)

Starting with v1.0.1.1, the configuration system offers a more flexible approach. UEIPGlobalConfig is a BlueprintType UObject — you can create and modify config objects in Blueprints, then pass them to Scanner/Adapter instances at runtime.

Core Class: UEIPGlobalConfig

Config objects are retrieved via GetEipConfig(Key) (Key defaults to "Default"), which automatically loads/saves from Config/EIPConfig.ini.

Blueprint Method	Description
`GetEipConfig(Key)`	Get or create a named config singleton
`LoadFromFile()`	Load from `EIPConfig.ini` (missing fields keep defaults)
`SaveToFile()`	Save to `EIPConfig.ini`

All fields are BlueprintReadWrite and can be edited directly in the Blueprint editor.

Scanner Usage (Recommended)

Two approaches:

Approach 1 — Load config in Blueprint and pass to Scanner:

→ GetEipConfig("PLC1")                     // Get named config
→ Set AssemblyIPAddress / AssemblyPort / ...  // Optional: modify in Blueprint
→ GetAssemblyScanner("PLCMain")
→ LoadConfig("PLC1")                        // Load params from Config
→ Start()                                   // Start the connection

LoadConfig(Key) reads the corresponding config object's Assembly connection parameters (IP, port, Assembly IDs, buffer sizes, etc.). If no preset is found, it writes the current scanner settings to the config file.

Approach 2 — Set manually (simple scenarios):

→ GetAssemblyScanner("PLCMain")
→ SetConnectionParams("192.168.1.100", 44818, 100, 101)
→ Start()

Adapter Usage

Adapter instances start directly on a port:

→ GetAssemblyAdapter("RobotArm")
→ Start(44818)

Tag Adapter works the same way:

→ GetTagAdapter("SensorHub")
→ Start(44819)

The Adapter port can also be managed via UEIPGlobalConfig.AdapterPort, but this is optional.

Managing Config Yourself

UEIPGlobalConfig is a regular UObject — you have full control:

Create one, set fields manually, call SaveToFile() to persist
On next run, call GetEipConfig(Key) to auto-load
Multiple named configs map to different INI sections ([EIPGlobalConfig_PLC1], [EIPGlobalConfig_PLC2])

Configuration Fields

Category	Field	Default	Description
Assembly	`AssemblyIPAddress`	`127.0.0.1`	Target device IP
Assembly	`AssemblyPort`	`44818`	Target port
Assembly	`ReadAssemblyID`	`100`	Read instance number
Assembly	`WriteAssemblyID`	`101`	Write instance number
Assembly	`AssemblyBlockSize`	`256`	Data block size
Assembly	`AssemblyOutBufSize`	`256`	Output buffer size
Assembly	`AssemblyInBufSize`	`256`	Input buffer size
Assembly	`bAssemblyAutoReconnect`	`true`	Auto reconnect
Assembly	`AssemblyReconnectDelay`	`3.0`	Reconnect delay (seconds)
Assembly	`AssemblySyncPeriod`	`0.1`	Sync period (seconds)
Adapter	`AdapterPort`	`44818`	Listen port
Adapter	`AdapterBlockSize`	`512`	Data block size
Adapter	`bAdapterAutoStart`	`false`	Auto start
Tag	`TagIPAddress`	`192.168.1.1`	Target device IP
Tag	`TagPort`	`44818`	Target port
Tag	`bTagAutoReconnect`	`true`	Auto reconnect
Tag	`TagSyncFrequencyHz`	`10.0`	Sync frequency (Hz)
Tag	`TagRequestTimeout`	`5.0`	Request timeout (seconds)

Config file location: <Project>/Config/EIPConfig.ini. Each named config uses its own INI section ([EIPGlobalConfig_<Key>]). Backward compatible with the legacy [EIPGlobalConfig] section.

Version History

Version	Changes
1.0.1.1	⚠️ NOT backward compatible with 1.0.0.x!
	Added multi-Adapter, multi-Scanner support
	Refactored to multi-instance architecture: managers manage multiple named instances, `FString` replaced wholesale with `FName`
	New Tag Adapter support (`UEIPTagAdapter`)
	Removed old single-instance subsystems (legacy `GetEIP*Subsystem` methods are gone)
	Adapter data API: `SetBufferData`/`ReadBufferData` → typed methods (`ReadFloat`/`WriteFloat` etc.)
	Scanner data API: `WriteValue`/`ReadValue` → typed methods (`WriteFloat`/`ReadFloat` etc.)
	`GetActiveNames()` return type changed from `TArray<FString>` to `TArray<FName>`
	`InstanceName` on Scanner/Adapter/Tag instances changed to `FName`
	Added bit-level read/write (`ReadBool`/`WriteBool` with BitIndex)
	`UEIPLinkComponent` new: `ScannerName` (`FName`, default `"Default"`), `DataBinds`, events, DataBind index reads
	Config decoupled from subsystems, giving users more flexible control
	`UEIPGlobalConfig` as `BlueprintType` UObject, multi-named config via `GetEipConfig(Key)`, `LoadFromFile()`/`SaveToFile()`
	`GetEipConfig` parameter changed from `FString` to `FName`
	Scanner startup: `SetConnectionParams(...)` → `Start()` (`Start()` no longer accepts parameters)
1.0.0.6	Fixed FSocket cross-platform compatibility (WinSock2 → UE Socket API)
1.0.0.5	Initial Fab release

Important Notes

Port Conflict: Each listening instance requires a unique port. Ensure no other service uses the target port.
Firewall: Windows Firewall may block incoming connections. Add an inbound rule for the UE editor process if needed.
Assembly Instance Convention: Scanner reads from instance 100 (default), writes to instance 101 (default).
Thread Safety: All read APIs are thread-safe. Blueprint calls execute on the game thread.
Platform: Windows only (Win64). Uses UE5 Socket API, cross-platform compatible.
GC Safety: Instances are held via UPROPERTY references in the manager — guaranteed not to be garbage collected while active.