picoArtnet2DMX

picoArtnet2DMX is an open-source gateway that converts Art-Net lighting data from Ethernet into DMX512 signals using a Raspberry Pi Pico and the WIZnet W5500.

COMPONENTS Hardware components

WIZnet - W5500

x 1

Raspberry Pi - RP2040

x 1

PROJECT DESCRIPTION

Direct answer: picoArtnet2DMX is a compact Art-Net-to-DMX512 gateway. It receives lighting channel data from software running on a computer, extracts the selected Art-Net universe, stores the channel values in memory, and continuously regenerates them as a physical DMX512 signal.

The input is Art-Net over UDP port 6454. The output is a DMX512 waveform carried through an RS-485 transceiver and XLR connector to fixtures such as dimmers, LED bars, moving lights, and other DMX-compatible equipment.

This places the project between digital content and a physical environment. Software determines brightness, color, motion, and timing, while the Pico-based node translates those decisions into the electrical signal expected by real lighting hardware.

The repository includes more than firmware. It also provides a KiCad board design, RS-485 reference material, a parameterized OpenSCAD enclosure, and printable STL files.

What Problem Is It Solving?

DMX512 remains widely used for physical lighting equipment, but modern control software often distributes lighting data through Ethernet.

Directly generating DMX512 from a computer is inconvenient because DMX has strict electrical and timing requirements. A computer can produce the lighting sequence, but an external interface is still needed to convert network data into an RS-485-based DMX output.

picoArtnet2DMX performs that conversion:

Lighting software sends Art-Net packets over the local network.
The W5500 receives the UDP traffic.
The RP2040 extracts the channel values.
RP2040 PIO generates the DMX512 timing.
An RS-485 transceiver drives the physical fixture chain.

This allows lighting data created in software to leave the screen and affect a stage, room, display, façade, installation, or interactive environment.

System Architecture

Lighting Software / Media Server
QLC+ · Resolume · MadMapper · Lighting Console
                    ↓
             Art-Net / UDP 6454
                    ↓
           WIZnet W5500 Ethernet
                    ↓ SPI
             Raspberry Pi Pico
       Core 0: Art-Net and Display
       Core 1: DMX Output Control
                    ↓
               RP2040 PIO
                    ↓
           RS-485 Transceiver
                    ↓
              XLR / DMX512
                    ↓
       Lighting Fixtures and Effects

The project does not simply forward Ethernet frames to an output pin. It crosses several technical boundaries:

Ethernet to SPI
UDP to Art-Net
Art-Net universes to channel buffers
Channel buffers to DMX512 frames
TTL logic to differential RS-485 signaling

Role of the WIZnet W5500

Ethernet Connection

The W5500 provides the wired Ethernet connection between the lighting-control network and the embedded node.

A wired connection is useful where lighting changes must remain synchronized and continuously available. It avoids the association process, radio congestion, and power-management behavior that can affect wireless links.

TCP/UDP Processing

Art-Net transports lighting data through UDP, normally using port 6454. The W5500 implements Ethernet, IP, and UDP socket processing in hardware.

The RP2040 therefore does not need to run a full software TCP/IP stack for this application. It interacts with the W5500 through a socket-oriented API provided by the Arduino Ethernet library.

MCU Interface

The W5500 communicates with the RP2040 through SPI. The firmware selects the Ethernet controller using GPIO17 and attempts to obtain an IP address through DHCP.

Once initialized, the ArtNet library reads incoming UDP data through the Ethernet interface and invokes a callback when the configured universe is received.

Why W5500 Is Important

The W5500 is not a passive RJ45 adapter. It is the network-processing engine responsible for receiving and buffering the Art-Net packets that feed the lighting output.

This separation is valuable because DMX512 transmission is timing-sensitive. Network processing should not disturb the generation of the physical DMX waveform.

By assigning Ethernet and UDP handling to the W5500, the RP2040 can reserve more processing time and memory for packet parsing, display updates, shared-channel data, and DMX generation.

How the Firmware Works

1. Ethernet Initialization

The firmware initializes the W5500 SPI chip-select pin and calls the Ethernet library to request an address through DHCP.

It also checks whether the Ethernet hardware and cable link are available. If initialization fails, the program reports the condition instead of proceeding with an invalid network state.

2. Art-Net Receiver Setup

The firmware creates an Art-Net receiver and subscribes to a selected universe, configured as universe 1 in the provided source.

When an ArtDMX packet for that universe arrives, the callback copies the received channel values into a shared buffer.

3. Shared Channel Buffer

The universe[] array stores the current DMX start code and channel values.

The buffer is declared volatile because one RP2040 core updates it while the other core reads it for DMX transmission.

4. Network Processing on Core 0

The primary loop repeatedly calls the Art-Net parser.

Core 0 also updates the OLED with information such as:

Assigned IP address
Received frame count
Art-Net timeout state
A small visualization of channel values

This display gives the node a useful local status interface without requiring a separate computer for basic diagnostics.

5. DMX Generation on Core 1

The RP2040 Arduino core supports separate setup1() and loop1() functions for the second processor core.

The project uses Core 1 for DMX output. This separates continuous signal generation from Ethernet parsing and OLED updates.

6. PIO-Based Timing

DMX512 requires a break condition, mark-after-break timing, a start code, and serial channel data at 250 kbit/s.

Instead of generating this waveform through software delays, the project uses RP2040 PIO. PIO is a programmable hardware block designed for deterministic digital I/O.

This allows the DMX signal to continue with consistent timing even while the CPU handles network and display activity.

Hardware Design

The repository includes a KiCad project containing schematic and PCB files for the Art-Net-to-DMX node.

The output side uses a TTL-to-RS-485 stage. RP2040 GPIO0 provides the DMX transmit data, and the RS-485 transceiver converts it into the differential signal required by a DMX cable.

The design also includes an XLR-compatible enclosure concept. The OpenSCAD files define a parameterized box with a Neutrik-style circular connector opening and mounting holes.

This is an important practical detail. Lighting interfaces are frequently installed near equipment, cables, fixtures, or temporary structures. A usable connector and enclosure make the project more relevant than a breadboard-only demonstration.

Why This Project Is Interesting

Many Ethernet examples end with data displayed in a browser, terminal, or dashboard. picoArtnet2DMX produces a visible physical result.

A software value between 0 and 255 may become:

The brightness of a lamp
The red, green, or blue intensity of an LED fixture
The pan or tilt position of a moving head
The speed of a programmed effect
A transition synchronized with audio or video
A change across several fixtures in a shared space

The project therefore demonstrates how embedded networking can participate in a larger creative-control chain.

The computer is responsible for composition and sequencing. Ethernet distributes the data. The W5500 receives it. The RP2040 preserves the required real-time timing. The DMX line delivers the final values to the fixtures.

This makes the project distinct from a generic protocol converter. It is a small endpoint through which digital timelines, interactive software, and programmed scenes can become light, movement, and atmosphere.

Limits and Upgrade Ideas

Only one Art-Net universe is subscribed. Multiple subscriptions and additional DMX outputs would allow the node to control larger fixture groups.
The source currently transmits 32 channels. The DMX write length can be expanded after verifying channel-buffer indexing and timing.
Network settings rely on DHCP. A static-IP option would be useful in fixed installations and temporary production networks.
ArtPollReply is not documented as implemented. Adding it would allow compatible controllers to discover the node automatically.
The channel-copy loop needs validation. The source-backed analysis identifies a possible indexing issue between the received Art-Net buffer and the DMX universe buffer.
No browser configuration interface is included. A small local page could expose universe number, IP mode, channel count, and output status.
Additional protocols could be supported. sACN/E1.31 would improve compatibility with other controllers and lighting workflows.
Output-loss behavior should be defined. The firmware could hold the last frame, fade to zero, or enter a configured safe scene when Art-Net data stops.

Source-Backed Summary

picoArtnet2DMX is an open-source Art-Net-to-DMX512 node built around a Raspberry Pi Pico and WIZnet W5500. The W5500 receives Art-Net UDP traffic through a hardware-offloaded Ethernet socket, while the RP2040 parses the selected universe and shares the channel data with a second core. RP2040 PIO generates the time-sensitive DMX512 signal, and an RS-485 transceiver delivers it to physical fixtures through an XLR connection. The included PCB and enclosure files make the project more reproducible than a firmware-only example, although its limited documentation, single-universe configuration, 32-channel output setting, and possible buffer-index issue should be reviewed before field use.

FAQ

What is Art-Net?

Art-Net is a protocol used to transport lighting-control data over Ethernet using UDP. It organizes DMX-style channel values into network-addressable universes.

What is DMX512?

DMX512 is a control protocol commonly used by lighting fixtures, dimmers, and effects equipment. One universe can contain up to 512 channel values, each ranging from 0 to 255.

What exactly does the W5500 do?

The W5500 handles the Ethernet and UDP socket functions needed to receive Art-Net packets. It delivers the packet data to the RP2040 through SPI but does not generate the DMX512 waveform.

Why does the project use RP2040 PIO?

DMX512 has strict serial timing requirements. PIO generates the waveform independently from normal CPU tasks, reducing timing variation caused by network parsing or display updates.

Can it work with commercial lighting equipment?

The architecture targets standard Art-Net input and DMX512 output. Compatibility still depends on correct RS-485 wiring, connector pinout, universe configuration, channel mapping, and validation with the intended fixtures.

Documents

Original GitHub Repository — Firmware, project structure, and source README
Firmware Source — Art-Net receiver, Ethernet initialization, OLED status, and DMX output logic
PlatformIO Configuration — Framework, board settings, and library dependencies
KiCad PCB Files — Schematic and board layout for the node
RS-485 Adapter Reference — Supporting material for the physical DMX output stage
OpenSCAD Enclosure Source — Parameterized case with connector cutouts
STL Enclosure Files — Printable enclosure components
WIZnet W5500 Documentation — Hardware socket, SPI, Ethernet, and UDP reference
Art-Net Specification — Network lighting protocol reference
DMX512 Specification — Channel, timing, and physical-layer reference

Related Maker Projects

ArtNet to ESP-NOW DMX512 — An ESP32 + W5500 master receives Art-Net and wirelessly relays DMX512 data to up to 20 ESP-NOW lighting nodes.
M5AtomPoeArtnet2DMX — A palm-sized W5500 PoE bridge that converts Art-Net and DMX512 in both directions over a single Ethernet cable.

Wiznet makers