EtherNet/IP Emulator (Python)

ethernetip-emulator is a high level binary communications framework built around cpppo (pronounced ‘c’3*’p’‘o’ in Python) that exposes a set of tags and allows for the programatic execution .

Architecture

.
├───example
│   ├───basic_datatypes
│   │   └─── *.py
│   ├───mfg_line
│   │   └─── *.py
│   ├───orange_pi
│   │   └─── *.py
│   └───raspberry_pi
│       └─── *.py
├───src
│   └───ethernetip_emulator
│       ├───client
│       ├───server
│       │   ├───datatypes
│       │   │   ├───templates
│       │   │   │   └─── *.py
│       │   │   └─── *.py
│       │   └─── *.py
│       └─── *.py
└───tests
    └───server
        ├───datatypes
        │   ├───mock
        │   │   └─── test_*.py
        │   ├───templates
        │   │   └─── test_*.py
        │   └─── test_*.py
        └─── test_*.py
        

Requirements

• Python 3.10+
• cpppo (for Ethernet/IP attribute/device behavior)
• black | Development Dependency (for code formatting)
• coverage | Developer Dependency (for coverage reporting)
• RPi.GPIO or OPi.GPIO | Optional Dependency (for gpio i/o)
• web.py | Optional Dependency for WebApi

Getting Started

pip install ethernetip-emulator

A minimal project needs three files:

# __main__.py
from ethernetip_emulator.server.device import AttributeDevice, apidict, device_controller
from ethernetip_emulator.server.tag_specs import tag_registry
import tags    # registers all tags (can also just be imported in __init__.py)
import actions # registers all listeners (can also just be imported in __init__.py)

if __name__ == "__main__":
    server_control = apidict(timeout=1.0)
    AttributeDevice.set_server_control(server_control)

    # To start the web server with web.py:
    # AttributeDevice.build_web(host="0.0.0.0", port=8080)
    # AttributeDevice.start_web()

    with AttributeDevice._actions.bind(AttributeDevice):
        device_controller(
            argv=tag_registry.build_argv(base_args=["--print"]),
            attribute_class=AttributeDevice,
            server={"control": server_control},
        )

Guides

Core

Datatypes

Typical Workflow

┌─────────────────────────────────────────────────────┐
│                    Your Project                     │
│                                                     │
│  tags.py ──────► tag_registry                       │
│                      │                              │
│                       ▼                             │
│  datatypes.py ─► actions.datatype                   │
│                      │                              │
│                       ▼                             │
│  __main__.py ──► device_controller                  │
│                      │                              │
│                       ▼                             │
│              AttributeDevice                        │
│           (intercepts PLC writes)                   │
│                      │                              │
│                       ▼                             │
│  actions.py ──► on_change listeners                 │
│                      │                              │
│                       ▼                             │
│              actions.<type>.set_val / get_val       │
└─────────────────────────────────────────────────────┘

1. Tags are declared once at import time via @tag_registry.register.
2. Custom Datatypes can be declared once at import time via @actions.datatype. Although this is completely optional if you like the built-in datatypes
3. device_controller builds the tag list and starts the EtherNet/IP server.
4. AttributeDevice intercepts every PLC write and fires the matching on_change listeners.
5. Listeners use actions.<type> helpers to read state, write back to tags, or trigger application logic.

Project Layout Convention

your_project/
├── __main__.py          # server entrypoint
├── tags.py              # tag definitions
├── actions.py           # on_change handlers
└── datatypes/           # optional: custom datatype classes
    ├── __init__.py
    └── mytype.py

For larger projects, split tags and actions into sub-modules and import them from a top-level __init__.py so all registrations are triggered before the server starts.

Protecting Attributes

AttributeDevice can make one or more attributes read-only. Protection is applied by attribute name and prevents writes handled by AttributeDevice.__setitem__; blocked writes are ignored and do not trigger on_set actions.

• AttributeDevice.protect(*tag_names) marks the specified attributes as protected.
• AttributeDevice.unprotect(*tag_names) removes protection from the specified attributes.
• AttributeDevice.is_protected(tag_name) returns True when the attribute is currently protected; otherwise, it returns False.

from ethernetip_emulator.server.device import AttributeDevice

# Prevent writes to one or more attributes.
AttributeDevice.protect("Motor.Enabled", "Motor.Speed")

if AttributeDevice.is_protected("Motor.Speed"):
    print("Motor.Speed is read-only")

# Allow writes again when the protected state is no longer needed.
AttributeDevice.unprotect("Motor.Speed", "Motor.Enabled")

Protection is maintained on the AttributeDevice class, so use the class methods to manage the protected attribute names. It remains active until the attributes are explicitly passed to unprotect.

Supporting the Development of EtherNet/IP Emulator

EtherNet/IP Emulator's development depends on your contributions. Right now it is just me working on this, so any contributions are welcome!

License

Copyright 2026 Merck KGaA, Darmstadt, Germany and/or its affiliates. All rights reserved.