WIZnet Ethernet in a Liquid Rocket Pressure Control System — Analyzing UC Berkeley SEB's E-Reg

TL;DR: UC Berkeley's student rocket team, Space Enterprise at Berkeley (SEB), builds an Automatic Electronic Pressure Regulator (E-Reg) that electronically controls propellant tank pressure on their liquid-fuel rockets. Looking at the code, each ESP32-based E-Reg node talks to Ground Station using a hardware UDP socket via the Arduino Ethernet library — a rare case of WIZnet's TOE running not an IoT or industrial protocol, but a real-time distributed control network for rocket propulsion. And this isn't just a class project: the same firmware has already flown.

Overview

Space Enterprise at Berkeley (SEB) is a student-run liquid-fuel rocket team at UC Berkeley. UC Berkeley Engineering describes SEB as a student-run liquid-fuel rocket team founded in 2016, with the long-term goal of crossing the Kármán line using a liquid bipropellant rocket. It isn't an official university lab or a company, but it's recognized as an official student engineering team by both Berkeley Engineering and the Aerospace Engineering department.

https://www.berkeleyse.org/eureka3

The team goes well beyond model rocketry, building real rocket subsystems in-house:

• Liquid propulsion
• Avionics
• Flight data acquisition
• Composite airframe
• Ground support equipment
• Propellant control system

The Automatic Electronic Pressure Regulator repository we analyzed here is a core piece of that last item — the propellant control system. As of this writing, the repository sits at 3 stars, 1 watcher, and 295 commits, and it's still under active development.

What Is the Automatic Electronic Pressure Regulator?

A liquid-fuel rocket needs to keep fuel and oxidizer tank pressures within spec while feeding the engine. SEB does this with several E-Reg controllers:

Fuel Tank E-Reg
LOX Tank E-Reg
Fuel Injector E-Reg
LOX Injector E-Reg

Each E-Reg runs as an independent embedded controller, talking to Ground Station and other subsystems over the network. The PlatformIO configuration even assigns each device its own build environment and IP address — this isn't one MCU trying to do everything, it's closer to a distributed control system with multiple embedded controllers linked over Ethernet.

Why Use Ethernet for Rocket Pressure Control?

In this project, Ethernet isn't there for internet access — it's the control network connecting the propulsion system's controllers to Ground Station.

Each node has its own IP address and exchanges data via UDP packets. For a propulsion system with sensors and actuators physically scattered across the test stand, this makes it easy to develop each controller independently and simply plug them into the network later.

Code-Level Evidence: ESP32 + SPI Ethernet

The ESP32-based E-Reg communication code uses an external SPI Ethernet controller. Here's the core initialization:

EthernetUDP Udp;

Ethernet.init(13);
Ethernet.begin((uint8_t *)mac, ip);
Udp.begin(port);

Ethernet.init(13) sets the SPI Ethernet controller's Chip Select pin, and Ethernet.begin() initializes the interface. The project's Arduino Ethernet library supports the WIZnet W5100, W5200, and W5500 family, and — critically — talks directly to the hardware socket rather than going through a software stack. So the Ethernet path for this E-Reg looks like:

ESP32 Application
       ↓
EthernetUDP
       ↓
WIZnet Hardware UDP Socket
       ↓
SPI
       ↓
Ethernet

That said, the public repository doesn't specify exactly which chip (W5100 / W5200 / W5500) is populated. Rather than assuming a specific model, the most accurate description right now is: "a software architecture that uses a WIZnet W5x00-series Ethernet controller."

Why UDP Instead of TCP

One of the more interesting design choices here is using UDP instead of TCP. Rocket control needs small command and telemetry packets delivered quickly across multiple nodes — the priority is fast, lightweight packet delivery, not the connection-management overhead TCP brings. The E-Reg firmware uses this API:

Udp.parsePacket();
Udp.read();

Udp.beginPacket(...);
Udp.write(...);
Udp.endPacket();

Pressure / Valve / Telemetry
             ↓
       Custom Packet
             ↓
            UDP
             ↓
     EthernetUDP
             ↓
 WIZnet Hardware UDP Socket
             ↓
          Ethernet

Most W5500 projects out there lean on TCP-based web servers or MQTT examples, so from WIZnet's perspective, this is a notable case: a hardware UDP socket doing the control/telemetry job for a rocket propulsion system.

A Custom UDP Protocol Instead of a Standard One

This system doesn't use standard industrial protocols like Modbus or EtherNet/IP. Instead, SEB defined its own application-level packet format:

Custom UDP Packet
├─ Packet ID
├─ Length
├─ Timestamp
├─ Payload
└─ Checksum

Packet ID distinguishes message types and gets routed through callbacks; timestamp and checksum are both managed at the application layer. UDP is purely the transport — figuring out what kind of command or telemetry a packet is, how long it is, when it was created, and whether it's intact are all handled by SEB's own protocol on top. It's a deliberate choice of lightweight, packet-oriented communication over TCP's connection management.

Sending to Two Ground Stations at Once

Another notable detail: the same telemetry packet can be sent to two separate Ground Station IPs.

              ┌─ Ground Station 1
E-Reg ─ UDP ──┤
              └─ Ground Station 2

Because UDP is connectionless, there's no connection state to maintain — the same packet can simply be fired at multiple destinations. That's a practical setup for redundant monitoring or test environments.

A Distributed Rocket Control Network

The real story here isn't "an ESP32 with Ethernet bolted on." It's that different kinds of controllers coexist on a single Ethernet network:

                Ethernet Network
                       │
        ┌──────┼─────┐
        │                        │                     │
      Teensy              ESP32             ESP32
        │                        │                    │
     Main AC              DAQ                E-Reg
                                    │
       ┌──────┼──────┐
       │                        │                        │
  Fuel Tank         LOX Tank              Injectors

Here, the WIZnet Ethernet controller isn't just an internet-connectivity device — it functions as the interface tying together embedded subsystems built on different MCUs (ESP32, Teensy) into a single IP network.

Why This Is Interesting for WIZnet

WIZnet TOE products usually get introduced in contexts like:

• Web Server
• MQTT
• Modbus TCP
• IoT Gateway
• Industrial Ethernet device

This project uses the hardware socket in a very different application from those familiar categories:

Liquid Rocket Propulsion Control

Rocket Control Application
        ↓
Custom UDP Protocol
        ↓
Hardware UDP Socket
        ↓
WIZnet Ethernet

In other words, a WIZnet hardware socket isn't limited to standard application protocols — it can also serve as the transport for a lightweight, user-designed, real-time protocol.

Role Separation, from a WIZnet TOE Perspective

The Arduino Ethernet library's UDP implementation is different from running a software UDP stack directly on the ESP32. EthernetUDP.begin() creates a hardware UDP socket on the WIZnet controller, and packet transmission uses that socket's TX buffer and commands directly.

ESP32
 │
 │ UDP Payload
 ▼
WIZnet Socket TX Buffer
 │
 │ Hardware UDP/IP processing
 ▼
Ethernet

The MCU stays focused on rocket control logic, packet construction, and sensor/actuator handling, while the Ethernet controller owns network transport end to end. That division of labor is a good illustration of what WIZnet's TOE brings to embedded control systems in general.

Real-World Flight Heritage

This isn't a one-off student experiment. According to SEB's official E-Reg project page, E-Reg has a real operational track record:

• Development started in Fall 2021, originally to replace the mechanical dome-loaded pressure regulators used on Eureka-1. Those regulators had a hard ceiling on achievable tank pressure and inconsistent behavior.
• The Quad E-Reg architecture — four ball valves under closed-loop PID control — gives precise tank-pressure regulation and, notably, unlocks engine throttling.
• 2022 static fire campaign — a 5-second hotfire in October (3.0kN, a thrust record at the time), followed by a 14-second burn in November that throttled the engine from 60% to 100% and back.
• Flew on Eureka-2 in 2024 — E-Reg completed a nominal 14-second burn, propelling Eureka-2 to SEB's highest altitude yet.
• Reused on the test stand for Eureka-3, SEB's current rocket aiming for the Kármán line. The Eureka-3 project page explicitly credits "the capacitive fill sensor and electronic regulator (E-Reg)" for the reliable performance that lets the team control the system to a greater degree.
• The work has also been published academically: Vint Lee and Sohom Roy, "Low-cost, Lightweight Electronic Flow Regulators for Throttling Liquid Rocket Engines" (arXiv:2401.07444).

E-Reg (development starts, 2021)
    ↓
Replaces Eureka-1's mechanical regulator
    ↓
2022 static fire campaign (throttling validated)
    ↓
Flies on Eureka-2 (2024, successful)
    ↓
Reused on the Eureka-3 test stand (ongoing)

In other words, the UDP/WIZnet-based firmware analyzed in this post isn't experimental code sitting in a repo — it's a subsystem that has already flown successfully, and it's still being used as SEB works toward its ultimate goal of reaching the Kármán line.

Potential Applications

This software architecture generalizes well beyond liquid rockets to similar distributed control systems:

• Rocket Ground Support Equipment
• Engine Hot-Fire Test Stand
• Propellant Feed System
• High-pressure Gas Control System
• Industrial Fluid Control
• Remote Valve Controller
• Distributed DAQ
• Test & Measurement System

It's particularly well-suited to systems where multiple sensor/actuator nodes need to be networked over Ethernet and monitored from a central Ground Station. That said, porting this pattern into a safety-critical environment — like a rocket propulsion system — requires additional safety design: network redundancy, fail-safe control, watchdogs, emergency shutdown, and so on. This repository alone doesn't let us verify the specifics of any such safety mechanisms.

Conclusion

The Automatic Electronic Pressure Regulator is a very different animal from a typical Arduino Ethernet example. It's a distributed electronic pressure control system built by SEB, UC Berkeley's student-run liquid-fuel rocket team, for real propulsion development — connecting the Fuel Tank, LOX Tank, Injector, and Ground Station over Ethernet, with a custom packet protocol layered on top of UDP to carry commands and telemetry.

Liquid Rocket Propulsion System
              ↓
   Distributed ESP32 Controllers
              ↓
      Custom UDP Protocol
              ↓
    WIZnet Ethernet Socket
              ↓
          Ethernet
              ↓
 Ground Station / DAQ / Controller

We can't confirm the exact W5x00 model from the public repository alone, but the Arduino Ethernet library and external SPI Ethernet setup make it clear, at the code level, that a WIZnet W5x00-series controller's hardware UDP socket is powering the distributed control network of a rocket propulsion system — and that system has already flown.

This project is a compelling example of WIZnet Ethernet controllers doing more than the usual Web/MQTT/Modbus territory — they can also power aerospace control systems and custom real-time UDP networks.

FAQ

Q. Is the Ethernet controller used here definitely a W5500? A. It can't be confirmed. The code uses the Arduino Ethernet library, whose API is shared across the W5100/W5200/W5500 family, so we know for certain it's hardware-socket-based UDP communication — but the exact model isn't stated anywhere in the public source.

Q. Why not use a standard protocol like Modbus or MQTT? A. Rocket telemetry and command traffic needs to move small amounts of data to multiple nodes with low latency. SEB designed a lightweight custom UDP protocol for that — built around Packet ID, Length, Timestamp, and Checksum fields — rather than taking on the overhead of an existing standard.

Q. Can this architecture be reused as-is in an industrial or test setup? A. The software architecture itself generalizes well to valve control, DAQ, and test stands. But for anything safety-critical, you'd need to add network redundancy, fail-safe behavior, watchdogs, and emergency shutdown — none of which is something this repository has been shown to include.

Q. Is this project still actively developed? A. Yes. As of this writing it has 295 commits and open pull requests, suggesting it's still being actively maintained.

Q. Has this firmware actually flown on a real rocket? A. Yes. According to SEB's official site, E-Reg flew on Eureka-2 in 2024 and completed a successful 14-second burn. It's also being reused on the test stand for Eureka-3, SEB's current rocket. This is flight-proven hardware and software, not just experimental code.

Related WIZnet Maker Projects

• PicoArtnet2DMX — Uses the W5500's hardware socket to handle real-time UDP (Art-Net) traffic. Worth comparing against E-Reg's use of a UDP hardware socket for low-latency, real-time control rather than TCP.