Pushing Pixels with Resolume Arena

Addressable Full Color LED Pixels have opened up amazing possibilities. We live in a time where both technology and the knowledge to use it are openly accessible. Sometimes the amount of how-to’s, DIYs, guides, lists, etc.. can be overwhelming and getting a basic starting point seems out of reach. My aim is to create a deep-dive guide on how to get your media from computer screen to LED Pixels.

This guide is designed with 2 parts each aimed a slightly different audience. The 1st part, the “DIY Lab” is aimed at the DIY crowd. If you want to get into this field, learn a bit of coding, some electronics and networking, this is for you! The second part, the “Off the shelf Lab” is based on off the shelf tech that requires no coding and minimal electronics knowledge

Table of Contents

What is the Addressable Pixel

For the last 5 years a wide verity of LEDs and associated technologies have been available to the public. In the past, If you wanted some LEDs you could grab individual LEDs and drive them using a micro controller. Simple RGB pixels and controllers have been available for a long time. These allow you to drive a long length of full colour pixels with amazing colour animations. These are great for decorative lighting, strip lighting, etc.. However you could only control 1 segment of strips at any one time. Say you want to create a grid of pixels and control each one individually?

The APA102 / SK9822  Addressable Pixel

These amazing little devices come in many variations , sizes, layouts, driving mechanisms, colour configurations etc… but they all share some key aspects:

Each one has 3 x Ultra Bright LEDs inside. A RED, Green and Blue (there are also RGBWhite variants which ill discuss later)

Each has a tiny IC (Integrated Circuit) built into the pixel that controls hos the individual lights are activated.

They can be daisy chained to create long complex systems

And more importantly can be individual addressed.

Now you can have a long strip of pixels where each one can be told what to do and how at very high frame rates. These usually come on a semi flexible copper  strip in multiple configurations and widths. They can also be purchased on any size PCB in grids, circles, pretty much any configuration you can think of. Or individual !

An example of some WS2812 pixels on a 12mm strip in 144 pixels per meter density

The many different types of Pixels

Within this category of addressable pixels, come a whole bunch of different technologies. They differ in certain specific ways, and all have a use case

The rate and method of physically controlling the individual RGB LEDs within the pixel

The communication protocol used by a control device to speak to the pixels IC

Levels of Reduncancy

Level of individual color and brightness control

For brevity I will describe the 2 most popular types of pixels. The end use case for this guide will then work with one specific type.

The Neopixel / WS2812 / SK6812 – 4 pin Addressable Pixel

These are 3 models of exactly the same technology. The pixels have 4 pins.

Ground – connected to common ground on the power supply rail

Data IN – connected to either your control device or to the data out of the previous pixel

Data OUT – connected to the DATA IN of the next pixel

+5V – Connected to common +5V on the power supply rail

These pixels use a protocol based on PWM(pulse width modulation) to speak to one another. Your control device sends a serial signal at a predefined speed (of around 800Khz, but this is slightly different for different models). The signal is an ordered list of bytes each representing the brightness level of each pixels RGB value. The order in which the bytes are sent control the pixel that you plan to light up. For example if you had 3 pixels in a chain, in order to light up the pattern R G B, so that pixel 1 is Red, Pixel 2 is Green, Pixel 3 is Blue. you would send the following block of data

255 0 0 0 255 0 0 0 255

These type of pixels are the cheaper variant of what can be purchased. They have a maximum transfer rate of 800Khz which becomes a limiting factor on large scale installations, specifically when your control device is having to transmit data to a very long chain of pixels. The work around for this is to break up your installation into group of paralel output frame. For example. If you had a grid of pixels 100 strips wide by 100 pixel tall connected in a long daisy chain, it would take some time for all pixels to be updated and your refresh rate would be low. If you have a driver that was capable 10 x parallel output you could split your installation up into 10 blocks therefore increasing your frame rate.

Range of Available pixels in this family:

These can be purchase in a range of densities, width of strip and waterproofing level. Here are some generally used densities in NON Waterproof productions.

30 Pixels Per meter 60 Pixels Per Meter 74 Pixels Per Meter 96 Pixels Per Meter 144 Pixels Per Meter

The Dotstar / APA102 / SK9822 – 6 Pin (SPI Driven) Addressable Pixel

These are high performance pixels that have high grain control of colour and brightens settings. Please note the 3 models above are all the exact same pixel but made.trademarked by different companies. The APA102 was the original of these. Adafruit trademarked the name “Dotstar” to mean any of the above, whilst the SK9822 is a recent model made by another company. I prefer these as they are higher performance. These pixels have 6 pins labeled as follows

Ground – connected to common ground on the power supply rail

Clock IN – Serial CLK signal input

Data IN – Serial DAT signal input

Clock Out – Serial CLK output INVERTED

Data Out – Serial DAT signal output

+5V – Connected to common +5V on the power supply rail

Driving these pixels requires a serial protocol that can be implemented easily in most programming languages. There are also a huge range of off the shelf drivers that we can use for this, I will talk about this later on. Talking to these pixels involves the creation of a string of bytes like so:

Start Frame Pix 1 GB Frame Pix 1 Blue Pix 1 Green Pix 1 Red NEXT 4 bytes PIXEL DATA END Frame

Start Frame (32 bits): This frame tells the pixels that data is incoming. Its set to 32 x 0’s

Pix 1 GB Frame (8 bits): This frame allows you to control the global brightness level of this particular pixel win 32 increments. 223 = is the lowest brightness value and 255 is the highest

Pix 1 Blue (8 bits): a value of 0 to 255 controlling this pixels BLUE level

Pix 1 Green (8 Bits): a value of 0 to 255 controlling this pixels GREEN level

Pix 1 Red (8 Bits): a value of 0 to 255 controlling this pixels RED level

End Frame (32 bits): This frame of 32 x 1s is sent to indicate that all pixels need to apply the received data! This block is sent after all pixels have been addressed.

These pixels can be used for HUGE installations as they can be driven at very high frequencies. You can send data to the SK9822 pixel at a maximum of 30Mhz (30Mbit). However in reality, this rate is often far slower because it depends on a range of technical requirements. You need to make sure you have adequate power distributed to all your pixels, proper grounding and noise shielding, appropriate power buffering etc… Here are a a few links with the different densities. These come in pretty much the same densities as the Neopixel:

60 Pixels Per Meter       144 Pixels Per Meter

What I will use for the rest of this article

For the rest of this guide, we will be be using the SK9822 pixel, to keep it simple. Its works for all use cases described. Specifically we will be using the SK9822 5050 (5x5mm) pixel

Powering your pixels

Whilst modern LEDs are very bright for the amount of power they consume, these pixels are still power hungry. If your power supply is underweight you will start to see a whole plethora of problems. Your pixels will not just be dimmer, they will start failing after a certain point. As an example a single SK9822 pixel will consume 20mA per LED. Take note that each of these pixels have 3 LEDs inside. So each PIXEL can consume a total of 60mA at full brightness. How does this convert into usable numbers:

For this example we would like to power a small matrix of pixels. Its built out of 5 x strips of 10 pixels each. In total we have 50 pixels to power.
Total power usage in mA = Number of Pixels x Power Usage Per Pixel
50 x 60 = 3,000mA … 3000/1000 = 3 Amps
Because these pixels require 5V the total power draw in watts will be .. Volts x Amps
3 x 5 = 15W

This means that to adequately power the above matrix, we will need a power supply that can push 5V at 3A. Any less and you will run into problems driving the pixels.

Common Ground

It is important to connect the GROUND pins of every strip you use in your project to the same Ground strip of your Driver, weather it be a micro controller of an off the shelf device. When building large installations often you will have more than 1 power supply powering your strips. It is important to have a common ground plane between all power supplies. Never connect the +V terminals of any power supplies together!

Power Buffering

Best practice is to place a capacitor in parallel with the power supply of each large segment of LEDs you plan to drive. This will buffer spikes of power when your pixels go from 0 to full blast. Here is an example of our grid:

Above we have laid out 5 strips with 10 pixels each. The power is chained form one strip to the next. Notice the 1000uf Electrolytic capacitor on the input power rails. Also Note that we have looped our power from the END of the chain back to the power supply. This will ensure that power is delivered relatively equally for our system. When we start getting into larger installations with hundreds and even thousands of pixels, using multiple power supplies, this stuff gets super important. The longer a chain of pixels is, the higher the resistance of the power rails embedded inside the copper strip. Depending on your installation it is wise to insert power at regular intervals, either from the same of from multiple power supplies. Using high quality appropriate gauge power cables also becomes important when you have more than 1 meter lengths.

Getting your media content onto the pixels

Lets move away from the hardware for now and start talking about your media

This guide will deal with using Resolume Arena as the primary media server, content manager and VJ suite. It is an awesome full featured application that has excellent support, for both, off the shelf of fully custom LED systems.

We can break down the entire system into the following functions:

Video/Animation Any media file that Resolume Arena can Play. This can me a movie file, gif, shader, effect etc…
Pixel Map A virtual representation of the physical layout of your pixels. In Resolume this is made using the Advanced Output system by combining Fixture elements. This creates a virtual map that allows your media to be projected onto the physical layout of your pixels. This map is overlaid onto your media, like a mask in Photoshop, to allow it to render what it covers.
ArtNet Data  The pixel map is then turned into a series of data blocks using the ArtNet protocol. ArtNet is a modern implementation of DMX512 adapted to work on Wired and Wireless Ethernet networks. The protocol uses blocks of 512 Channels (each Chanel being 1 byte or 8 bits). These bytes can be utilized by our pixels. The Pixel Map, Maps what Channel is used for what pixel and creates an ordered stream of ArtNet packets that are sent to the pixel driver. For example, 1 ArtNet universe can address 170 RGB pixels (with 2 channels left over)
Pixel Driver  A device that can receive ArtNet Data (over a wired or wireless network), translate it to the communications protocol of the pixel you wish to drive and send that data to the Pixels
Pixels  The array of pixels you plan to use

A note on our physical Lab set up

I will break this guide into 2 separate labs so as to cater to a wide audience. Please note this will not be a “DIY VS Off the Shelf”, but rather a full featured write up of both to let you choose a direction. Both implementations will achieve similar results, some will require more time, more money, or more involvement from you

DIY Lab We will focus on building the “Pixel Driver” using Open Source hardware and software. We will be taking an in depth look at writing our own software using the Arduino platform on the ESP32 Micro Controller. The ESP32 is a full featured WIFI and BT enabled Micro. It powerful and super cheap, $10,  for its capabilities.
Off the Shelf Lab This lab will focus on using an OFF THE SHELF solution with no programming and very little electronics knowledge. For this we will be using the PixLite MK2Lighting Controller. Its a relative cheap and very well featured device that can be used in massive instalations. Specifically we will be using the PixLite 4 MkII that has been supplied to us by the awesome crew at Advatek Lighting Australia
Hardware & Software used in both labs
LED Matrix For both systems we will be using an off the shelf matrix of pixels. The matrix is a 14 x 14 array using SK9822 5050 RGB pixels. It has a rigid PCB and very well laid out power traces. It also has a separate power and ground connector for injecting power for large scale systems. The pixels in this panel are connected in a Zig Zag pattern. see the green lines marked up on the second image. This indicates how the pixels are physically connected to each other
Software We will be using Resolume Arena 6.0.6 for all demos, graciously provided by the Resolume team
Power Supply We will need a maximum of 11.7A (5×11.7=58W) to drive this matrix at full power, for this reason we will be using an off the shelf power supply. This particular model is overkill for our demos, but it is a very good quality low noise switching power supply with active cooling built in.

The DIY Lab

Pixel Map – For the DIY ESP32 Driver

I’m going to assume that we already have some media that we want to play on our little LED Matrix. Lets begin by setting up Resolume 6 by creating a custom Advanced output for our pixel map. The first thing we need to do is create a custom Fixture for our LED Matrix Screen. Resolume lets you create any variation of layouts using its Fixture editor. Inside Resolume, click on Application, and select Fixture Editor:

The Fixture editor is split into 3 panes:

Fixtures  A list of all your Fixtures, you can add and remove them at will, rename them etc…
Fixture Parameters  This pane allows you to set parameters for the fixture you are editing. Things like what kind of channels it will have, the width and height of your fixture, its direction, colour space etc…
Pixels  A visual and numerical representation of the fixture we create

Our 14 x 14 pixel matrix has a total 196 pixels. If you remember above, about how many channels a single DMX Universe has, you will note that we can not fit this matrix into 1 DMX universe as we can only fit 170 pixels worth of RGB data into 512 bytes! We must then create 2 fixtures that split the panel into 2 sections. For simplicity, we are going to create 2 fixture that are the left and right parts of the matrix. We will then use these fixture in 2 universes. The Driver device will then be tasked with compiling the DMX data from both universes and appropriately rendering it to the LEDs, but this will be discuss later.

Above is the physical layout of all the pixels on our 14×14 matrix. We will create 2 fixtures called “14x14_LEFT” and “14×14 _Right”. Note they will differ only in the “distribution” atribute:

Clicking on the “+” button in the Fixtures panel, creates  anew fixture for us. Scroll down to it on the left pane and double click on it to rename it. I have named it “14x14_LEFT”

Lets go over the Fixture Parameters for this ficture:

Width & Height This allows us to set the width and height of the fixture. We will set this one to 7 pixels wide by 14 pixels tall
Color Space The colour space attribute tells Resolume how to organize each pixels colour data and in what order the colours appear. Our pixels have RGB leds inside BUT, and a big BUT, the actual order the LEDs translate data sent to them can vary from pixel models. For simplicity I will be using RGB and filtering the actual layout of data in the Driver Device later on. Note that you could also drive pixels that are RBGW(white) or just White. There are a tons of different configurations to choose from.
Gamma We can leave this as is at 2.5
Distribution Probably the most important attribute, this tells Resolume the physical placement of each pixel. Our panel is oriented so that the 1st pixel is at the bottom left corner, data then flows up, turns RIGHT to the next row, DOWN, then RIGHT then UP etc… as indicated by the icon we have selected.

Now create a second fixture, you can do it quickly by RIGHT CLICKING on the current fixture “14x14_LEFT” and selecting DUPLICATE. Then rename it to “14x14_RIGHT”

This fixtures parameters are the same, BUT we need to change the Distribution as this part of the panel starts at the top

Now that we have our custom Fixtures set up click Close to save them! The next step is to insert them into the Advanced Output system of Resolume, adjust the virtual mapping and position over your actual media. Back in the main window of Resolume, click on the Output Menu and select Advanced

Click on the PRESETS menu at the top LEFT and click on NEW to get the same blank layout. Note the colour gradient I have in the screenshot is the media I have selected. Its a simple shader called “Gradient” that is included within Resolume.

Next we need to Add a new “DMX Lumiverse”. Resolume treats a Lumiverse as 1 DMX Universe with a unique DMX Universe ID and Subnet ID. Each Lumiverse can have a maximum of 512 channels, just like a regular DMX Universe. Click on the big “+” icon  on the top left and select “DMX Lumiverse”

Next we need to remove the “Screen 1” section from the layout. We are setting up a DMX output only system and don’t need anything other outputs for this demo. Click on “Screen 1” and click on the “X” to remove it from the layout. You will be left with “Lumiverse 1”. Duplicate this Lumiverse by Right Clicking on it and selecting Duplicate. Now we must make sure we have the correct fixtures in each lumiverse. By Default, when you create a new lumiverse it adds whatever fixture you were last working with. If its not the correct one, click on it on the left panel and select the correct one form the drop down on the bottom right:

Our advanced output layout will have 2 lumiverses. Lumiverse 1 will have “14x14_LEFT” and Lumiverse 2 will have “14x14_RIGHT”

In the Center panel you can click on any fixture and move it around to position it onto the screen in any way you like. The screencap above has the 2 fixtures split so you can see what I’m doing. We need to do 2 things. Push them together and resize them to scale.

Lets talk about scale. As you can see above, the fixtures are inserted as equal squares. But these specific fixtures are more rectangular as they are 7px wide and 14px tall. Lets click on the Left Fixture and adjust it using the Width and Height attributes on the right panel.

For ease and visibility we will say that 1 LED pixels is equal to 50PX on the screen of your computer. So that the left fixture will have a width of 7×50=350px and a height of 14×50=700px

We set the same atributes for the right fixture and then push them together

We have created a virtual PixelMap for our panel. Now save your layout. Click on the PRESETS drop down at the top left and select SAVE AS. Name it “14 x 14 Panel”. back to universe IDS, we now need to assign each fixture to their appropriate universe so that the Driver device can work out what universe is meant to be rendered into what part of the panel. Click on “Lumiverse 1” and on the left hand side you will see Subnet and Universe. We will leave these at 0:0. Now Click on “Lumiverse 2” and set it to be in Universe 1. Resolume will send out 2 blocks of data each time a single frame is rendered from its output. Block one will have all the data for Lumiverse 1 and block 2 will have all the data form Lumiverse 2. Your Driver device will then receive these 2 blocks and will be able to identify what block of data needs to be copied into what side of the matrix.

The DIY Pixel Driver

In this section we will be build a device that will allow you to received ArtNet data via WiFi and push it to our 14×14 LED Matrix. I have prepared a simple bit of code that has all the elements necessary to do this. If you are heading down the path of doing this work from scratch, its imperative you understand most of this code as its designed to be modular and expandable to very large installations. We will be working with the following pieces of hardware and software. Ill try and provide links to the exact devices I’m using if you want to follow along at Home. (This guide is written for a Windows PC). The assumption here is that your pc is connected to a wireless or wired network and that you have a WIFI network to connect the ESP32 (read on later for network layout). You will need the Wifi SSD and Key. Your PC needs to be able to speak to the wifi network freely.

Hardware

Software

Installing the Arduino IDE and setting up the ESP32 API

Download the Arduino IDE from arduino.cc install it as per usual then do the wollofinw in this exact order:

  1.  Go to the Espressif GitHub for the ESP32 Arduino API 
  2. Top right, click on “Clone or Download” and select Download ZIP save this to your desktop
  3. Go to your local computers Documents folder and locate the Arduino folder “C:\Users\USERNAME\Documents\Arduino”
  4. Create a folder called “Hardware” if its not already there
  5. Inside the “Hardware” create a folder called “espressif”
  6. Inside this folder Extract the contents of the ZIP file from step 2 then rename the extracted folder to “esp32”
  7. Go into the “esp32\tools” folder and locate the executable “get.exe” double click on it and wait for the command prompt to disappear. This will download the latest API from Espressif servers and may take 5-10 minutes depending on your internet connection. Once the command prompt disappears you can proceed to the next step
  8. Open the Arduino IDE. Click on the Tools menu, select Board and scroll down. If you installed everything correctly above, you will see a whole bunch of ESP32 boards like this

Next download the project source code from my GitHub save the folder to your desktop, and open the project file “ESP32ArtNetDriver.ino”. Click on the Tools Menu and select Boards. Then find the “Node32S” board and select that. Connect the ESP32 to your PC via the USB cable, wait for the drivers to install. Then in the Arduino IDE, slick on tools, PORT and select the port the EPS32 is connected to. You are now ready to compile and upload the code to the micro controller, but do read on as there are things we need to change.

On lines 22 and 23:

//Networking 
const char * ssid = "ArtNet";
const char * password = "megapixels";

Change the SSID and Password to whatever your wifi network name is (the SSID) and the password to whatever your wifi password is. Once done click on the UPLOAD button, wait a few seconds for the code to compile and then upload to the ESP32. At this point your DevBoard is reasy to rock! Lets hook up all the hardware!

Notes on Networking for this lab

To get the best performance for this hardware set up, its best to hook up the computer running Resolume to your network via a wired network port. You can definitely stream ArtNet via WIFI from Resolume but you WILL notice a lag and a lot of packet loss due to the nature of the UDP protocol. Here is an example of our preferred network set up for this lab

I will be using a relatively cheap consumer grade WIFI Enabled Router made by TP-LINK. But you can use any router you like, as long as you have DHCP enabled

Hardware Hookup

Grab all your hardware and set it up as above. We are using the SN74HCT245 for level shifting. The DATA and CLOCK lines on the SK9822 pixels assume a logic level of 5V, where 0v = 0 and 5v = 1. The ESP32 has logic levels of 3.3V, where 0v = 0 and 3.3v = 1! Once hooked up, power on your power supply and get ready to see nothing (read on)!

Enabling Output in Resolume

At this stage, even if you had Resolume open you wont see anything on the panel because we are not outputting any data from Resolume yet! Open Resolume and go to the Advanced Output. For this demo we are going to be using the “Broadcast” method to send data to the ESP32. Broadcasting UDP packets comes with a lot of challenges, especially over WiFi, so for anything you work on in the future, try not to use this method unless you have a small controlled lab set up.

Click on “Lumiverse 1” and on the “TargetIP” attribute on the right select “Broadcast”, do the same for “Lumiverse 2” you should start seeing stuff appear on your matrix display

The Off the Shelf Lab

Pixel Map – For the Advatek PixLite 4Mk II

I’m going to assume that we already have some media that we want to play on our little LED Screen. Lets begin by setting up Resolume 6 by creating a custom Advanced output for our pixel map. The first thing we need to do is create a bunch of custom Fixtures for our LED Matrix Screen. Resolume lets you create any variation of layouts using its Fixture editor. Inside Resolume, click on Application, and select Fixture Editor:

The Fixture editor is split into 3 panes:

Fixtures  A list of all your Fixtures, you can add and remove them at will, rename them etc…
Fixture Parameters  This pane allows you to set parameters for the fixture you are editing. Things like what kind of channels it will have, the width and height of your pixel array, its direction, colour space etc…
Pixels  A visual and numerical representation of the fixture we create

Our 14 x 14 pixel matrix has a total 196 pixels. If you remember above, about how many channels a single DMX Universe has, you will note that we can not fit this matrix into 1 DMX universe as we can only fit 170 pixels worth of RGB data into 512 bytes!

The PixLite splits each Universe into 510 usable channels (discarding 2 so there is no overlap). Our pixel map for this simple matrix will consist of 4 fixtures to accommodate this. Here is the layout of our matrix note each colour block as an independent fixture:

Fixture Name  Universe  Number Of pixels Start Px End Px
Matrix_P1of4 1 168 0 167
Matrix_P2of4 1 2 168 169
Matrix_P3of4 2 12 170 181
Matrix_P4of4 2 14 182 195

Clicking on the “+” button in the Fixtures panel, creates  anew fixture for us. Scroll down to it on the left pane and double click on it to rename it. The 1st Fixture will be named “Matrix_P1of4”

Lets go over the Fixture Parameters for this ficture:

Width & Height This allows us to set the width and height of the fixture. We will set this one to 12 pixels wide by 14 pixels tall
Color Space The colour space attribute tells Resolume how to organize each pixels colour data and in what order the colours appear. Our pixels have RGB leds inside BUT, and a big BUT, the actual order the LEDs translate data sent to them can vary from pixel models. We are fine to use RGB
Gamma We can leave this as is at 2.5
Distribution Probably the most important attribute, this tells Resolume the physical placement of each pixel. Our panel is oriented so that the 1st pixel is at the bottom left corner, data then flows up, turns RIGHT to the next row, DOWN, then RIGHT then UP etc… as indicated by the icon we have selected.

Now Lets create the other 3 fixtures…. Note the different Width & height attributes for each and the different Distribution of pixels by matching their pixel order in the table above:

Matrix_P2of4: Width 1 Height 2 Distribution UP

Matrix_P3of4: Width 1 Height 12 Distribution UP

Matrix_P4of4: Width 1 Height 14 Distribution DOWN

Now that we have our custom Fixtures set up click Close to save them! The next step is to insert them into the Advanced Output system of Resolume, adjust the virtual mapping and position over your actual media. Back in the main window of Resolume, click on the Output Menu and select Advanced

Click on the PRESETS menu at the top LEFT and click on NEW to get the same blank layout. Note the colour gradient I have in the screenshot is the media I have selected. Its a simple shader called “Gradient” that is included within Resolume.

Next we need to Add a new “DMX Lumiverse”. Resolume treats a Lumiverse as 1 DMX Universe with a unique DMX Universe ID and Subnet ID. Each Lumiverse can have a maximum of 512 channels, just like a regular DMX Universe. Click on the big “+” icon  on the top left and select “DMX Lumiverse”

Next we need to remove the “Screen 1” section from the layout. We are setting up a DMX output only system and don’t need anything other outputs for this demo. Click on “Screen 1” and click on the “X” to remove it from the layout. You will be left with “Lumiverse 1”. By Default, when you create a new lumiverse it adds whatever fixture you were last working with. If its not the correct one, click on it on the left panel and select the correct one form the drop down on the bottom right and select the 1st Fixture we need “Matrix_P1of4”:

Next we insert our 2nd fixture into the same Limuverse. Click on the big “+” icon on the top left and select insert DMX Fixture. Once inserted, set this fixture to be “Matrix_P2of4
” On the FIXTURE attribute at the bottom right:

At this point we have exhausted all 510 chanel for this Universe and need to create a second one for the rest of the panel…To make it easy, simply right click on Lumiverse 1 and duplicate it. It will create a duplicate Lumiverse and duplicate Fixtures. You will then need to change the fixtures in the second Lumiverse to “Matrix_P3of4” and “Matrix_P4of4” like so:

In the Center panel you can click on any fixture and move it around to position it onto the screen in any way you like. The screencap above has all 4 fixtures split so you can see what I’m doing. We need to do 2 things. Push them together to resemble the 14x14px panel and resize them to scale so that our map is appropriately projected from our media.

Lets talk about scale. I want to make sure that each physical pixel is represented by 50 onscreen pixels wide and 50 onscreen pixels tall. Lets change each fixtures scale as follows:

Fixture Screen Pixels Per Physical LED Virtual Fixture Width Virtual Fixture Height
Matrix_P1of4 50 12 x 50 = 600px 14 x 50 = 700px
Matrix_P2of4 50 1 x 50 = 50px 2 x 50 = 100px
Matrix_P3of4 50 1 x 50 = 50px 12 x 50 = 600px
Matrix_P4of4 50 1 x 50 – 50px 14 x 50 – 700px

You can adjust each fixtures width and height by clicking on the fixture and using the Width and Height attribute son the right panel:

Lastly we put all the fixtures together to resemble the perfect 14×14 matrix, You can click and drag each fixture into place. Resolume has built in object snapping to make alignment easier as well, its the MAGNET icon at the top of the screen:

 We are almost done. The last step is to assign each lumiverse to a Unique Universe ID. Click on “Lumiverse 1” and on the right hand panel make sure it says Subnet 0 Universe 0. Then click on “Lumiverse 2” and set that to Subnet 0 Universe 1

The PixLite4 MII LED Driver

In this section we will go through all the steps required to connect the driver to your pixels, power and the network. To configure it to receive appropriate data and to set it up to talk to your pixels correctly.

Hardware

Software

Notes on Networking for this lab

The PixLite has a single Ethernet port that is used to received data from Resolume. In order to get the best possible performance and easiest set up, out of the box, we need to have our network set up properly. Here is a simple diagram of what we need to achieve:

I will be using a relatively cheap consumer grade WIFI Enabled Router made by TP-LINK. But you can use any router you like, as long as you have DHCP enabled and have 2 spare Ethernet ports on the LAN side of the device. You CAN connect your laptop to the router using WIFI however your performance will drop depending on the quality of WIFI you have set up. If you have Ethernet ports use them!

Hardware Setup for the PixLite

The PixLite has 4 output ports and can support thousands of pixels in total. However we are only going to use 1 port for simplicity. Once you have everything connected and powered up, download the Advatek Assistant software and run it. Once opened click on the Search button to fine your PixLite

If you have everything hooked up properly, you should see the PixLite in your list. Double click on it and it will open up the configuration dialog. Here is a description of each Tab and what we need to do:

Network This tab allows you to control the PixLite network system. We will leave this untouched for this demo
Control This Tab hosts all the nity gritty stuff details about how Resolume data is received, processed and sent to the Pixels
LEDs This tab will allow us to tell the PixLite what type of pixels we are using, their data rate, colour preferences etc..
Test This tab allows us to test that the pixels are correctly plugged into the board, we will use this as a 1st run test
Misc This tab is for advanced settings and firmware update

The 1st thing we need to do is tell the PixLite what kind of pixels we are using and set up all the settings so its working properly. Click on the LEDs tab and set everything as follows:

Pixel IC This sets the exact Pixel type, we are using the SK9822
Clock Speed This is the rate at which the controller talks to the Pixels. For this demo we can set this to the maximum which is preferred
RGB Order The SK9822 pixels protocol expects color data in the order RGB

Next we set up how the PixLite interprets the ArtNet data that Resolume send it and how it then translates it to the panel we are using. Click on the “Control” tab. In the Ethernet Protocol select “ArtNet” and then tick the “Advanced” tick box and click Advanced:

In the advanced settings, we will configure how the data is interpreted. We only need ot configure Output 1, and ignore all the other outputs for this lab. Set Output 1 to the following

Start Universe Our fixture set up starts at Universe 0 (this is treated by the PixLite as Universe 1)
Start Channel We start at Channel 1
End Universe Our fixture set up ends at Universe 1 (this is treated by the PixLite as Universe 2) . This is automatically set for us when we enter the number of pixel sin our set up.
End Channel This is automatically set for us when we enter the number of pixel sin our set up
Num Pixels The total number of pixels on our matrix panel is 14 x 14 = 196
NULL Pixels We can leave this at 0 as the PixLite has its own voltage level converter
ZIG ZAG Not used
Group Not used
Intensity Limit Useful if you want to limit the total power output of your pixels to use less power
Reversed Not used

Now click OK, and exit the application. The device is now ready to go. We now need to enable output in Resolume to the PixLite and start playing our content

Enabling Output in Resolume

Open Resolume and go to the Advanced Output. For this demo we are going to be using the “Broadcast” method to send data to the PixLite. For large installations where you have many controllers and many more pixels, its best to use “IP Address” (Unicast UDP).

Click on “Lumiverse 1” and on the “TargetIP” attribute on the right select “Broadcast”, do the same for “Lumiverse 2” you should start seeing stuff appear on your matrix display