Van Phu Human Radar

PROJECT DESCRIPTION

Van Phu Human Radar is an open-source interactive sensing project designed for real-time art installations, exhibitions, and TouchDesigner-based visual systems. The project reads human presence data from an AI-Thinker RD-03 24GHz FMCW radar sensor using an ESP32, then transmits the detection result through a WIZnet W5500 wired Ethernet module to a Python desktop application. The Python application works as both a radar configuration GUI and an OSC bridge for TouchDesigner.

Unlike many ESP32 sensor projects that rely on Wi-Fi, this project uses W5500 Ethernet to provide a more stable and low-latency network path. This is especially useful for exhibition environments where the sensor must run continuously and react quickly to visitor movement without unstable wireless behavior. The repository describes this as “Zero-Delay Ethernet Tracking” using SPI-based W5500 instead of Wi-Fi for exhibition-grade stability.

The system is designed to be plug-and-play. The PC application can automatically discover the ESP32 radar device on the local network using a UDP handshake, then receive real-time presence data and forward it to TouchDesigner through OSC. This allows artists and developers to connect human presence detection directly to interactive visuals, lighting, media playback, or installation control.

KEY FEATURES

WIZnet W5500 Ethernet Communication

The project uses a WIZnet W5500 module as the main network interface for the ESP32. The W5500 is connected through SPI, with SCK on GPIO18, MISO on GPIO19, MOSI on GPIO23, and CS on GPIO5. The RD-03 radar sensor is connected to the ESP32 using GPIO4 for presence interrupt and Serial2 pins GPIO16/GPIO17 for configuration.

W5500 is suitable for this project because it provides a hardware TCP/IP stack, SPI interface, 10/100 Ethernet MAC/PHY, 8 sockets, and internal TX/RX buffer memory. This allows the ESP32-based radar node to communicate over wired Ethernet instead of depending on Wi-Fi.

Low-Latency Presence Tracking

The ESP32 reads the RD-03 radar state and sends telemetry to the PC application every 50 ms. In the firmware, the radar presence state is converted into a simple 1 or 0 signal and sent to the target PC through UDP.

This simple binary output makes the system easy to connect to real-time creative software. For example, 1 can mean that a person is detected, while 0 means no person is detected.

Smart Auto Discovery

The system includes an automatic discovery protocol so that the user does not need to manually enter the ESP32 IP address.

The PC application first sends a UDP broadcast message, WHO_IS_RADAR_ESP32, on port 8888. If the ESP32 receives the message, it replies with IAM_RADAR_ESP32. If broadcast discovery fails, the PC application can sweep the local IP range using unicast packets.

This makes the setup easier in exhibition spaces, where the network configuration may change depending on the router, venue, or installation environment.

Python Configuration GUI

The project includes a Python desktop app that acts as a configuration dashboard for the radar hardware. The README explains that the GUI can adjust parameters such as minimum and maximum detection distance, micro-motion sensitivity, hold time delay, and environmental auto-calibration.

These settings are important for interactive installations because radar behavior can vary depending on the space. For example, the detection range can be adjusted to ignore people walking behind the installation, and hold time can prevent flickering when a visitor stands still.

TouchDesigner OSC Bridge

The Python app forwards the radar presence state to TouchDesigner using OSC. The OSC bridge sends the value to 127.0.0.1:10000 using the path /radar/presence.

This means TouchDesigner can directly receive the radar signal through an OSC In CHOP and use it to control visuals, animations, LED effects, projection mapping, or interactive media.

SYSTEM ARCHITECTURE

The system consists of three main parts.

1. ESP32 Radar Node

The ESP32 is connected to the AI-Thinker RD-03 radar sensor and the WIZnet W5500 Ethernet module. The firmware is written as an Arduino sketch and includes separate modules for W5500 networking, RD-03 sensor handling, and LED status indication.

The ESP32 reads the radar presence signal, receives configuration commands from the PC, and sends real-time detection telemetry through Ethernet.

2. W5500 Ethernet Network Layer

The W5500 module handles the wired Ethernet connection. The firmware initializes Ethernet using the Arduino Ethernet library, obtains an IP address through DHCP, opens UDP port 8888 for discovery, and starts a TCP server on port 9001 for configuration commands.

The telemetry data is sent through UDP to the discovered PC application. This makes the radar response fast and lightweight, which is important for real-time interactive systems.

3. Python PC Application

The PC application performs three roles.

First, it discovers the ESP32 radar node on the local network. Second, it provides a GUI for changing radar parameters. Third, it forwards presence data to TouchDesigner through OSC.

The PC app listens for telemetry on UDP port 9000 and sends configuration commands to the ESP32 through TCP port 9001.

HOW IT WORKS

The operation flow is simple.

RD-03 Radar Sensor → ESP32 → W5500 Ethernet → Python PC App → OSC → TouchDesigner

When the system starts, the ESP32 initializes the RD-03 radar sensor and W5500 Ethernet module. The W5500 obtains an IP address using DHCP and waits for discovery messages from the PC app.

When the user opens the Python application and clicks auto-discover, the PC sends a UDP discovery packet. The ESP32 replies, and the PC app stores the ESP32 IP address. After this pairing process, the ESP32 starts sending real-time presence values to the PC.

The Python app receives the value, displays the current state, and forwards it to TouchDesigner as an OSC message. TouchDesigner can then use the radar value as a control signal for interactive visual content.

ROLE OF WIZNET W5500

The WIZnet W5500 is the key networking component in this project. It allows the ESP32 radar node to use wired Ethernet instead of Wi-Fi.

For interactive art and exhibition systems, this is a meaningful design choice. Wi-Fi can be affected by signal interference, crowded venues, router instability, or distance from the access point. Ethernet provides a more predictable connection, which is better for installations that need stable real-time sensing.

This project can be described as a W5500-based Ethernet sensor gateway. The ESP32 collects radar data locally, while the W5500 provides the wired network path to the PC-based creative software.

TOE / Hardwired TCP/IP Point

This project can reasonably be introduced as using WIZnet’s hardware TCP/IP advantage, because W5500 itself includes a hardwired TCP/IP stack and supports TCP/UDP communication. The firmware also uses Ethernet UDP and TCP server functions for discovery, telemetry, and configuration.

However, it is better to describe it as “W5500 Ethernet communication using Arduino Ethernet library” rather than claiming that the project directly implements low-level WIZnet socket control.

Hybrid Network Check

This project is not a hybrid Wi-Fi + Ethernet network project. The README specifically emphasizes using SPI-based W5500 instead of Wi-Fi for stability.

So the safe classification is:

WIZnet product used: Yes, W5500
TOE / hardwired TCP/IP relevance: Yes, through W5500 Ethernet TCP/UDP communication
Hybrid network: No, mainly wired Ethernet-based

WHY THIS PROJECT IS INTERESTING

Van Phu Human Radar is not just a basic ESP32 sensor example. It connects a radar sensor, Ethernet networking, PC-side configuration, and TouchDesigner integration into one practical pipeline.

This makes it useful for:

Interactive media art
Exhibition sensing
Presence-based lighting control
TouchDesigner installations
Real-time visitor detection
Digital signage interaction
Museum and gallery installations
Human-triggered projection mapping
Low-latency Ethernet sensor systems

The use of W5500 makes the project more reliable for fixed installations, where stable operation is more important than wireless convenience.

CONCLUSION

Van Phu Human Radar is a practical interactive sensing project that combines an ESP32, AI-Thinker RD-03 24GHz radar sensor, WIZnet W5500 Ethernet module, Python desktop GUI, and TouchDesigner OSC bridge.

The project is valuable because it shows how W5500 Ethernet can improve the stability of real-time interactive systems. Instead of sending radar data over Wi-Fi, the ESP32 uses wired Ethernet to deliver fast and reliable presence data to a PC application. The PC app then forwards the signal to TouchDesigner, making it easy to build responsive art installations and exhibition systems.

From a WIZnet perspective, this is a strong example of using W5500 as a reliable Ethernet interface for an ESP32-based sensor gateway. It demonstrates how WIZnet Ethernet can be applied not only to industrial IoT or data logging, but also to creative technology, media art, and interactive installation projects.