Automated lighting consoles are extremely powerful tools with very complex software. No matter how many features a console provides, one of the most essential elements is its fixture library. The library contains unique profile information about fixtures used within our industry. This information becomes the interface between the programmer and the instructions for the light (or other devices). Without proper libraries, most desks will not communicate with fixtures and devices. In some cases, it is important for a programmer to understand the process to create new or modify existing libraries. The method of creating or editing fixture libraries differs greatly between console systems, but all require a basic understanding of how a fixture library functions.
The Fixture
As mentioned earlier, a console will contain unique libraries or profiles for each fixture type. Every DMX controlled device will have a protocol or map that details what each channel controls and what happens with particular DMX values. This document is usually contained either within the fixture user manual or as a separate download from the manufacturer’s website.
Let’s look at an example of a 10 channel LED light that might have a DMX protocol that looks likes like this:
CH1: Dimmer (0-255): No light to full output
CH2: Pan (0-255): Pan 0°-540°
CH3: Pan Fine (0-255): Pan fine adjustment
CH4: Tilt (0-255): Tilt 0°-270°
CH5: Tilt Fine (0-255): Tilt fine adjustment
CH6: Red LED (0-255): Red 0-100%
CH7: Green LED (0-255): Green 0-100%
CH8: Blue LED (0-255): Blue 0-100%
CH9: Strobe —
(0-20): Closed
(21-120): Strobe slow to fast
(121-220): Random strobe slow to fast
(221-255): Open
CH10: Control —
(0-20): Idle
(21-25): Reset
(26-30): Fans on (default)
(31-35): Fans off
(36-250): Reserved
(251-255): Idle
As you can see, the DMX channels are assigned to control particular parameters and then the exact DMX values are mapped to specific values or a range of values. It is important to pay attention to these values, as this will determine what you can do with each specific DMX channel. The example above is a very basic fixture. When you have gobos, framing shutters, iris, zoom, focus and more the DMX protocol can get very complex.
The Console
Some, but not all, automated lighting consoles include a fixture library editor within the console software itself or as a stand-alone application. The primary purpose of this software is to enter the data from the fixture’s DMX protocol/map into the console and assign it to the console’s internal functions. It should be a straightforward process, but unfortunately it is usually rather convoluted. Most consoles have pre-defined terms that they use for parameters and thus you must match these to the parameters in your protocol. Usually it works out well with pan, tilt, dimmer, zoom, gobo and such, but effects, prism, control channels, speed, and other non-standardized features are often difficult to implement into a desk’s system.
Some library editors are very detailed GUI’s that allow you to select a parameter and then simply enter in the DMX value or range and match that with a particular function or name. Other systems may be based on a text editor or some other code-based system that can be more complex to match up parameters and values. Either way, it is essential that you input all the parameters and associated ranges from the protocol into the library you are trying to create.
The Process
As mentioned above, the process of creating a fixture library should be rather straightforward. After all, it is just translating the DMX protocol/map into the console language. Unfortunately however, many programmers have a tough time creating fixture libraries. It is a very tedious process that requires an extreme attention to detail. A fixture with 30 DMX channels, each filled with many different values could take an hour or more to create.
Besides inputting the DMX values into the library editor, you also need to have an understanding of how the parameters function within the light. As an example, let’s look at a fixed color wheel parameter. The DMX protocol for this channel may appear as follows:
CH 10: Fixed Color Wheel —
Continuous scroll
(0): Open
(1-14): Open -> Red
(15): Red
(16-29): Red -> Amber
(30): Amber
(31-44): Amber -> Green
(45): Green
(46-59): Green -> Blue
(60): Blue
(61-74): Blue -> Open
(75-100): Open
Stepped Scroll (snap to full color)
(101-105): Open
(106-110): Red
(111-115): Amber
(116-120): Green
(121-125): Blue
(126-130): Open
Continuous Rotation
(131-200): Clockwise, Fast -> Slow
(201-230): Stop
(231-255): Counter Clockwise, Slow -> Fast
First you must understand the difference between continuous scroll and stepped scroll for this light. Both have values that will get you the same output of color from the light, but in a very different manner. For instance, the red achieved at DMX 15 looks the same as the red from DMX 106. The difference comes when you try to crossfade from red to amber. If you are in the early continuous scroll ranges then the light will turn the color wheel through varying amounts of red and amber until the amber is fully in the aperture (crossfade from DMX 15 to 30). However, if you were to crossfade from DMX 106 to 111 the light would simply snap from red to amber without showing any partial colors between.
When building a library, you must understand the fixture’s functionalities and label or associate them accordingly. Often this means reading the fixture manual to find descriptions of the various actions. Then you can determine how best to associate these with the console’s pre-made function names/types that display the differences as you program the light. Of course, you could choose to not label any of the values and simply create a channel for this color wheel that only displays 0-100%. However this is not advisable as it makes it very difficult to program the light without any information on the console screen (what is the function at DMX 50?).
Each DMX channel or parameter will also need to have a setting that tells the console how to work with DMX value changes. Sometimes this is called “path,” and refers to whether the channel will crossfade or snap between DMX values. In the fixture DMX protocol above you would want to crossfade the dimmer, pan/tilt, and color channels, but snap the control channel. The strobe channel could be used either as a snap or a crossfade, but this is a personal choice. Usually the library’s “path” value can be overridden during programming so a perfect choice during library creation is not essential.
Devious Defaults
Another element of fixture library building that cannot be overlooked is the default value for each channel. When a fixture is patched, but not programmed (or if no playback is active) then every channel must default to a specific DMX value. These values can be very different for each parameter depending upon the function and the DMX protocol. For instance, looking at the protocol examples above, if you default all channels of our fixture to DMX zero, then no light would be emitted when you adjusted the dimmer value to full. Can you determine why?
The color channels (RGB) need to be above zero for output and the Strobe channel also needs to default to DMX 255 in order to allow light output. Many fixture manufacturers will provide suggested default values in their DMX protocols/maps and it is a good idea to always follow these suggestions when building a fixture library. Without doing so, your fixture many not respond correctly. Just imagine if you set the fixed color wheel above to default to DMX 255!
So Much More!
I have only touched on the very basic information you need to create a fixture library in this article. I highly suggest that you take the time to read the user manual of your console to determine the exact method that is required. Then refer to the DMX protocol/map of the fixture you need to create and be meticulous in your efforts to be sure to include all values of all channels as well as the suggested default values. Furthermore, some consoles use a unified fixture library that requires a very complex fixture library creation processes. With these systems, the library attempts to define common elements (colors, gobo rotation directions, real world values), which add more layers of interconnectivity that must be dealt with.
One of the best methods to understand fixture library creation is to study a library that has already been created. Take the time to look at libraries and practice building libraries on your console before you are required to actually create a library for a show. Also remember to check with your console manufacturer prior to creating your own library as they may already have it available to send to you. Libraries truly are the lifeblood of lighting consoles and programmers need to have an understanding of how they are created as well as how to create their own.
