A high-performance EtherCAT SDK for industrial control, edge computing, and device manufacturers. Provides a complete toolchain from ESI parsing, master communication, and slave simulation to test validation. Pure Go — zero external runtime dependencies, deployable on x86-64 / ARM64 platforms.

中文文档 | API Docs | Performance Report | Refactoring Report | Roadmap

• Industrial Gateways — Parse EtherCAT frames at the edge, bridge to MQTT / OPC UA / HTTP
• EtherCAT Master — Build a pure Go master runtime to drive servo drives, I/O, sensors
• Slave Simulation — Simulate EtherCAT slave behavior in automated testing without real hardware
• Automated Testing — Integrate slave simulation into CI for correctness and performance validation
• Protocol Analysis — Parse, construct, and validate EtherCAT frames and datagrams for debugging
• CI Simulation — Run protocol-level regression tests in GitHub Actions and other CI environments

• Pure Go — zero CGo, zero kernel modules, cross-platform compilation and deployment
• Zero-Allocation Hot Paths — 0 B/op, 0 allocs/op on all encode/decode paths
• 225+ Test Cases — 74%–92% coverage, including race detection and stress tests
• ESI XML Parser — complete EtherCAT Slave Information file parsing
• Frame / Datagram Codec — high-performance Frame, Datagram, and Ethernet frame handling
• Command Execution Engine — goroutine-safe multiplexed command scheduling
• EEPROM Access — ESC EEPROM read/write operations
• L2 Slave / Bus Simulation — protocol-level testing without real hardware
• UDP Multicast Transport — UDP-based EtherCAT transport layer
• CLI Tool — command-line parsing, scanning, read/write operations
• GitHub Actions CI — multi-version Go matrix test + benchmark + lint
• Bilingual Documentation — README + API docs + performance report + roadmap

ecad (ESC register address constants)
  ↓
ecfr (frame/datagram encoding) ← internal/marshalling (shared codec)
  ↓
ecmd (command execution, frame scheduling, concurrent multiplexing)
  ↓
┌──────────┬──────────┬──────────────────┐
│ etransport│  ecee    │  internal/sim    │
│ (UDP)     │ (EEPROM) │  (slave sim)     │
└──────────┴──────────┴──────────────────┘
eni (ESI XML parser) — standalone

┌─────────────────────────────────────┐
│        Industrial Application        │
│    PLC Runtime / Motion / Safety    │
├─────────────────────────────────────┤
│         EtherCAT Master             │  ← Next milestone
│   AL State Machine / DC / Mailbox   │
├─────────────────────────────────────┤
│      EtherCAT Protocol SDK          │  ← Current (v1.0.3)
│   Frame / Command / ESI / EEPROM    │
├─────────────────────────────────────┤
│  Edge Gateway / Protocol Bridge /   │
│         Simulation & Testing        │
└─────────────────────────────────────┘

├── cmd/ethercat/          # CLI tool
├── docs/                  # GitHub Pages + API documentation
│   ├── api/               # Generated Go package docs
│   └── index.html         # Refactoring report
├── ecad/                  # ESC register address constants
├── ecee/                  # EEPROM access
├── ecfr/                  # Frame/datagram encoding
├── ecmd/                  # Command execution
├── eni/                   # ESI XML parser
├── etransport/            # UDP multicast transport layer
├── internal/              # Private packages
│   ├── marshalling/       # LE/BE binary helpers
│   └── sim/               # L2 slave/bus simulation
├── .github/workflows/     # CI (test + deploy Pages)
├── go.mod
├── Makefile
├── README.md
└── README.zh-CN.md

go get github.com/anviod/EtherCAT@v1.0.3

import "github.com/anviod/EtherCAT/eni"

info, err := eni.ReadEtherCATInfoFromFile("slave.xml")
if err != nil {
    panic(err)
}
fmt.Printf("Vendor: %s\n", info.Vendor.Name)

import "github.com/anviod/EtherCAT/ecfr"

buf := make([]byte, 128)
frame, _ := ecfr.PointFrameTo(buf)

dg, _ := frame.NewDatagram(4)
dg.Header.Command = uint8(ecfr.APRD)
addr := ecfr.PositionalAddr(0, 0x1000)
dg.Header.Addr32 = addr.Addr32()
dg.Header.SetLast(true)

frame.Commit()

import (
    "github.com/anviod/EtherCAT/ecfr"
    "github.com/anviod/EtherCAT/ecmd"
)

cf := ecmd.NewCommandFramer(framer)
addr := ecfr.PositionalAddr(0, 0x0000)
typ, err := ecmd.ExecuteRead16(cf, addr, 1)

# All unit tests
make test

# With coverage
make test-cover

# Race detection
make test-race

# Benchmarks
make bench

# Stress tests
make bench-stress

Note: The numbers below represent software-internal processing performance (encode/decode, frame ops, command execution), not end-to-end EtherCAT network real-time cycle time. Actual system cycle time also depends on NIC driver, IRQ latency, DMA transfer, OS scheduling, and other factors. See the performance report for full methodology and data.

Test environment: x86-64 on Intel i5-13500H + Go 1.23 + Windows 11; ARM64 on Rockchip RK3588s + Go 1.23 + Linux (ARMBIAN). All encoding/decoding hot paths are zero-allocation (0 B/op, 0 allocs/op).

Software floor is New→fill→Cycle with a pre-created bus/slave (no NIC / OS scheduling).

EtherCAT typical cycle time requirements range from 100μs to 1ms. The end-to-end processing pipeline performance:

Core hot path (encode/decode + frame ops + command execution) consumes < 0.5% of a 100μs EtherCAT cycle. The 10-byte datagram header — the highest-frequency operation in the system — uses only 2 memory operations (one uint64 8-byte + one uint16 2-byte) instead of 10 byte-by-byte accesses, achieving a 21% improvement on the Commit path.

Currently positioned as a Pure Go EtherCAT Protocol Library, with the next milestone being an ETG-compliant industrial-grade EtherCAT Master. See the roadmap for details.

See the performance limits report and refactoring report for architecture analysis, shortest cycle/jitter numbers, and code examples. See the roadmap for project planning.

MIT — see LICENSE for details.