Isolated DMX Driver for Arduino

What would a concert be without a spectacular light show in the background? Would it even work if there were nothing to see?

That’s why today I’ll give you a brief glimpse into the world of light fixtures and, more importantly, how they’re controlled. After all, what’s the point of having lots of different lights if you have no way to control them, right?

The focus of this blog will be DMX (also known as DMX512), the most commonly used protocol for sending commands to lighting equipment. Of course, there are other control methods that are growing in popularity, but DMX is still the go-to solution, especially for small to medium-sized events. Even better, you can control your very own fixture using an inexpensive microcontroller like an Arduino and a simple circuit. It’s a great weekend project and an excellent way to level up your skills in electronics, soldering, and programming.

So, without further ado, let’s make the stage shine!

First of all, you’ll need a DMX-compatible device. Ideally, this will be a light fixture, but you’re not limited to lighting alone, some fog machines and other stage equipment use DMX as well. For this demonstration, I’ll be using my repaired Cameo CLP64RGB10BS.

Make sure to download the manual for your device and familiarize yourself with its menu and navigation system. Knowing how to set the DMX address and operating mode is essential before moving on.

Next, you can decide whether you want to build the circuit on a perfboard or use the PCB I designed. The circuit is electrically isolated up to 1000 V, meaning that even if something goes wrong on the DMX bus, your microcontroller (MCU) will remain protected.

Some of the components are SMD parts, but they can be soldered easily with a fine-tipped soldering iron:

Capacitors

1. 6x 0.1 µF (100 nF) 0805
2. 2x 4.7 µF 0805
3. 2x 10 µF 0805

Power & Indicators (optional)

1. 1x DC power jack
2. 2x LED 0805 (power indication)
3. 2x 1 kΩ 0805 (for LEDs)

Resistors

1. 3x 470 Ω 0805
2. 3x 4.7 kΩ 0805
3. 2x 680 Ω 0805
4. 1x 120 Ω 0805 (optional, termination resistor)

ICs & Modules

1. 1x B0505S-1W (isolated DC-DC converter)
2. 3x 6N137 (optocouplers)
3. 1x MAX485 (RS-485 transceiver)
4. 4x DIP-8 sockets (optional)

Connectors

1. 2x 2-pin screw terminals
2. 2x 3-pin screw terminals

Other Required Components

1. A microcontroller (e.g. Arduino Uno)
2. A DMX device (light fixture, fog machine, etc.)
3. XLR-3 or XLR-5 connector/socket

Before we jump into the build process, let me give you a short introduction to the DMX protocol, as understanding the basics will be very helpful later on. As always, you can find a much more detailed explanation on Wikipedia: https://en.wikipedia.org/wiki/DMX512

DMX stands for Digital Multiplex and is based on the RS-485 unidirectional, differential signaling standard. A DMX network consists of one controller (master) that sends data to multiple slave devices connected in parallel on the bus. Unidirectional means that only the controller is allowed to transmit data.

Such a network is commonly referred to as a DMX Universe, which can contain up to 512 channels of data.

The wiring consists of a differential pair (Data1+ and Data1−) along with a common ground, similar in concept to USB’s D+ and D− lines. Differential signaling is used to reduce the network’s susceptibility to electrical noise.

Common connectors used for DMX include XLR-3, XLR-5, and RJ-45. My circuit only uses the Data1 differential pair. If you are using an XLR-5 connector, simply leave the Data2 pair unconnected.

At the end of the DMX chain, a termination resistor (typically around 120 Ω) should be placed between Data1+ and Data1−. For hobby projects, you can often omit this resistor and the system will still work fine. However, in professional setups, proper termination helps avoid signal reflections and can save you a lot of troubleshooting later ;)

Each channel in a DMX universe carries a value from 0 to 255 (one byte). There is no error correction in the protocol: if a fixture fails to receive a value, it simply waits for the next data frame.

The DMX start address is set directly on the device itself. Most fixtures use multiple consecutive channels, depending on their operating mode. For example, my light can be configured in either 4-channel mode or 6-channel mode, depending on the application.

Each channel controls a specific function of the fixture, such as color brightness, movement, or rotation. In many cases, values follow a simple logic (e.g. 255 = on, 0 = off). Always refer to your device’s manual for the exact channel layout.

If I set the start address to 42 and select 4-channel mode, the channel assignment would look like this:

1. 41 → previous fixture
2. 42 → red channel
3. 43 → green channel
4. 44 → blue channel
5. 45 → brightness channel (don’t forget to enable this one!)
6. 46 → next fixture

Image By Lambtron - Own work, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=25538722

After a quick overview of DMX, it’s time to get our hands dirty and build a circuit that handles the differential signaling and adds electrical isolation for improved safety.

The IC that does most of the heavy lifting is the MAX485, which is responsible for transmitting and receiving the differential RS-485 signal. The RE# (read enable, active low) and DE (driver enable) pins are used to control the data direction, while RO (receiver output) and DI (driver input) handle communication with the microcontroller. On the bus side, the outputs A (also known as Data1+) and B (Data1−) are biased using 680 Ω pull-up and pull-down resistors. As mentioned earlier, the termination resistor only needs to be populated if this board is the last device in the DMX chain.

You could use the circuit in this basic form, but without isolation there would be a direct electrical connection between your MCU and the DMX universe. In worst-case scenarios, voltage spikes or high currents caused by wiring faults or failing devices could damage your microcontroller. To avoid this, I’ve added galvanic isolation using a B0505S DC-DC converter to provide an isolated 5 V supply and three 6N137 optocouplers to isolate the control signals going to the MAX485.

Add a handful of decoupling capacitors, a couple of power-indication LEDs, and optional IC sockets and you’re ready to go. Let’s build it!

If you decide to use the PCB instead of a perfboard, I’ve included the Gerber files (zip them before uploading), the bill of materials (BOM), and the EasyEDA Standard project files below. The board measures 50 × 50 mm and features M3 mounting holes, offset 3.5 mm from each corner.

Soldering: SMD Components

First, we’ll solder the SMD components. I know this part can be a bit finicky, but it makes the circuit look more professional and helps keep the overall footprint nice and compact.

1. Start with the LEDs and resistors. If you prefer, you can skip the LEDs, but they’re very helpful for debugging later on. Make sure to observe the correct LED polarity.
2. Next, solder the input and output capacitors for the DC power jack and the B0505S DC-DC converter.
3. After that, add the remaining resistors and decoupling capacitors for the ICs.

Soldering: Through-Hole Components

At this point, only the through-hole (TH) components remain.

1. Begin with the ICs. You can decide whether to solder them directly or use DIP-8 sockets for easier replacement later on. In either case, pay close attention to the orientation.
2. Next, solder the screw terminals, followed by the B0505S module and, if you’re using it, the DC power jack.

And that’s it! The main isolated DMX transceiver is now assembled and ready to rock!

Before we can start sending data to our lights, we need to build our own DMX connector.

Here’s the standard pinout for a DMX connector (you can find this info from various online references):

1. Pin 1: Ground / Shield
2. Pin 2: Data1−
3. Pin 3: Data1+
4. Pin 4: Data2− (NC)
5. Pin 5: Data2+ (NC)

For this project, I chose to use an XLR-3 connector that I had lying around. I simply soldered three wires to the pins and crimped a ferrule connector onto the other end. Be sure to clearly mark your wires and double-check your connections—mixing up pins may cause damage to your devices!

Alternatively, you could use an XLR socket and a fresh cable if you want a more polished, boxed controller setup. The plain cable approach works perfectly well for testing and quick setups.

When you’re ready, connect:

1. Ground/Shield (Pin 1): to the middle of the screw terminal
2. Data1+ (Pin 3): to the A line / Data+
3. Data1− (Pin 2): to the B line / Data-

Fortunately, we don't have to implement the protocol ourself as some great people already created Arduino libraries which we will just use! You can directly install both libraries through the Library Manager in the Arduino IDE.

1. https://github.com/mathertel/DMXSerial
2. https://github.com/PaulStoffregen/DmxSimple

Both work well, I selected DMXSerial for the following examples and connected the Arduino Uno to the PCB:

Now open the 'DMXSerialSend' example sketch. You can connect LEDs to the Arduino like the sketch suggests, but I left it as is. However, I had to make the following change:

That's actually it, once the sketch is uploaded and the cable connected to the fixture, you should observe a great rainbow color change effect - not that difficult to control right?

And with just a little effort, you now have your very own isolated DMX transceiver ready to go. Feel free to experiment, try out different effects, and bring your lighting projects to life!

Thank you for reading along — I hope this guide inspires you to dive deeper into the exciting world of stage lighting and electronics. Now that I have this small board, I might explore advanced DMX projects, stay tuned and until then, happy tinkering!