ARC: Building Deterministic Ethernet Applications with ESP32-S3 and W5500 MACRAW

ARC: Building Deterministic Ethernet Applications with ESP32-S3 and W5500 MACRAW

Explore low-level Ethernet frame processing, predictable memory management, and security-oriented firmware development using the WIZnet W5500.

Overview

Developing reliable embedded systems requires more than connecting a microcontroller to a network.

Applications involving real-time processing, network monitoring, and industrial control must carefully manage memory, peripheral access, and communication tasks.

ARC, developed by Dhimas Ardinata, is an open-source embedded firmware framework built on ESP-IDF for the ESP32-S3.

The project focuses on deterministic execution, explicit hardware resource management, and predictable data processing.

Among its networking capabilities, ARC includes support for WIZnet W5500 raw Ethernet frame processing, providing developers with a foundation for low-level network applications.

What Is ARC?

ARC is designed for embedded applications that need precise control over how hardware resources and software tasks interact.

Unlike general-purpose application frameworks, ARC emphasizes predictable execution behavior and explicit ownership of memory and peripherals.

Its architecture separates responsibilities between the ESP32-S3's two CPU cores:

Core 0: Networking, storage, system management, logging, and other framework operations

Core 1: Deterministic computation and time-sensitive GPIO operations

This separation is intended to reduce interference between real-time processing and communication workloads.

Key Features

1. W5500 Raw Ethernet Frame Support

One of ARC's interesting networking features is arc::net::W5500Raw.

This component provides a policy-driven SPI Ethernet path for processing raw Ethernet frames using the WIZnet W5500.

Rather than relying on the standard TCP/IP socket interface, this approach allows developers to build applications that operate directly on Ethernet frames.

This can be useful for applications requiring customized frame handling, proprietary Ethernet protocols, or network traffic inspection.

The W5500 provides the Ethernet hardware interface, while the ESP32-S3 application determines how the frames are processed.

2. Fixed-Size Ethernet Frame Buffers

ARC also provides arc::net::EthernetRing, a fixed-size ring buffer for raw Layer 2 Ethernet frames.

This approach allows applications to manage frame storage using predefined memory resources.

For embedded systems, predictable memory usage is particularly valuable because uncontrolled dynamic allocation can introduce latency and resource-management problems.

Fixed-buffer processing can provide a useful foundation for network monitoring and specialized communication systems.

3. Deterministic Task Execution

ARC separates time-sensitive tasks from general networking and system-management activities.

Core 0 handles communication and framework operations, while Core 1 is reserved for deterministic processing.

The framework also provides statically allocated tasks, typed hardware interfaces, and lock-free communication mechanisms.

These features help developers build applications where execution timing and resource ownership need to be carefully controlled.

4. Security-Related Software Components

In addition to raw Ethernet processing, ARC includes several security-oriented software interfaces.

These include:

AES and AES-GCM cryptographic operations

SHA hashing and HMAC support

TLS client transport

Secure firmware update interfaces

Secure Boot policy integration

Certificate and encrypted-storage utilities

These capabilities are provided through the ESP32 platform, ESP-IDF, and ARC's software abstractions.

They are not hardware security functions implemented inside the W5500.

This distinction allows developers to use the W5500 for Ethernet connectivity while implementing security policies at the application or host-processor level.

5. Explicit Resource Management

ARC emphasizes controlled memory allocation, peripheral ownership, and DMA buffer handling.

For example, its hardware resource interfaces can help identify conflicting peripheral assignments and incorrect resource usage.

This approach is useful for complex embedded applications where networking, sensor processing, and real-time control must operate together.

How W5500 Fits into ARC

The W5500 is used as an external SPI Ethernet controller.

A raw Ethernet application can be organized around the following architecture:

Ethernet Network

↓

WIZnet W5500

Ethernet frame reception and transmission

↓

SPI Interface

↓

ESP32-S3 / ARC Networking Components

Raw frame handling, fixed-size buffers, and application-defined processing policies

↓

Application Layer

Custom network protocols, monitoring logic, or specialized Ethernet applications

ARC provides reusable building blocks for this architecture, while application developers remain responsible for implementing the required network policies.

Potential Security Applications

ARC's W5500 raw Ethernet capabilities create opportunities for several security-related applications.

Ethernet Traffic Monitoring

Developers can use raw Ethernet frame processing to build custom traffic monitoring tools.

Such applications could inspect selected packet headers, classify traffic, or collect network diagnostics.

However, packet capture scope depends on the physical network topology and the frames delivered to the Ethernet interface.

Industrial Network Diagnostics

Industrial control systems often use specialized communication protocols.

ARC's raw frame handling may help developers investigate or implement Ethernet-based diagnostic applications with predictable memory usage.

Custom Network Access Policies

Applications can implement their own frame validation or filtering logic on top of the raw Ethernet interface.

This may be useful for experimental network isolation systems or protocol-specific communication gateways.

These are potential applications of the framework, not complete security products supplied by ARC.

Why the W5500 Matters

The WIZnet W5500 is widely used for embedded Ethernet connectivity through SPI.

While the chip is known for its hardware TCP/IP engine, it also supports MACRAW operation, allowing applications to transmit and receive raw Ethernet frames.

ARC demonstrates an alternative way to use the W5500 beyond conventional TCP or UDP socket communication.

With direct frame access, developers can implement custom Ethernet processing pipelines while taking advantage of the W5500's integrated Ethernet interface.

This makes the project particularly interesting for developers exploring low-level networking on ESP32-S3 systems.

Getting Started

Developers can explore ARC through its public GitHub repository and project documentation.

The repository provides the ESP-IDF-based framework, component headers, examples, tests, and development tools.

For W5500-related development, the arc::net::W5500Raw and arc::net::EthernetRing components are useful starting points.

Developers should review the hardware-specific SPI implementation and board integration requirements before building a complete Ethernet application.

ARC is distributed under the AGPL-3.0-only license, with separate commercial licensing available from the project author.

Project: ARC
Developer: Dhimas Ardinata
Platform: ESP32-S3 / ESP-IDF
Ethernet: WIZnet W5500 (MACRAW)
GitHub: https://github.com/dhimasardinata/arc
Documentation: https://dhimasardinata.github.io/arc/

Conclusion

ARC introduces a different approach to embedded Ethernet development by combining deterministic firmware design with low-level networking capabilities.

Its W5500 raw Ethernet interface provides developers with a foundation for custom frame processing, while the broader framework supports predictable memory usage, real-time execution, and security-oriented software components.

For the WIZnet maker community, ARC is an interesting example of how the W5500 can be used beyond conventional TCP/IP applications to explore custom Ethernet processing, industrial diagnostics, and security-related embedded systems.