Until the advent of fluorescent and LED lights, these were the only lights available. We use incandescent night light bulbs in the candles in our windows because we like the traditional look. Incandescent lights use AC (Alternating Current) as their power source. AC is what you get when you plug into an outlet in your house.
The LED (Light Emitting Diode) was something we saw in a lot of technology items for years and they started appearing in Christmas lights about 15 years ago. The great thing about these was their significantly lower electrical usage. A traditional incandescent Christmas light string with 100 bulbs used about 67 watts and the corresponding 100 bulb LED string used about 7 watts. The LED string cost five to six times more than the incandescent and, in the early sets, the bulbs were not replaceable. That wasn’t a big problem because they didn’t seem to need to be replaced. These days the bulbs are replaceable and the prices have gotten lower. These come in all of the traditional shapes and sizes as shown in the image. While DC (Direct Current) LED light strings are available for use in boating and automotive applications, most of the LED strings you will find for Christmas lights will use a DC power source.
The RGB pixels were primarily used in the sign industry but have been adopted by the Holiday lighting industry in recent years. These are the same light emitting diodes that we talked about above but when three of them (a red, a green and a blue) are put together we call them a pixel. The image shows three common shapes; C9 (left), bullets (center) and ribbon/tape lights (right). Pixels use a DC power source.
The remainder of this page will discuss the structure and function of RGB pixels.
Anatomy of a Pixel
This section will describe the anatomy of two types of pixels; a Bullet and a Tape/Ribbon. An understanding of these should make it possible to understand other pixel types.
Anatomy of an RGB Bullet
As show in in the diagram, a bullet shaped pixel (the ones we use anyway) is composed of the following parts:
Body – a resin filled tube shape that provides a waterproof container for the rest of the components. Note: Other bulb shapes may have different body shapes. For tape/ribbon they may have none.
Chip – A circuit board with a computer chip that provides the intelligence for the pixel. The Chip controls the LEDs. We’ll discuss this more in the How They Work section.
LEDs – Three LEDs; a red a green and a blue.
Lens – The lens covers the LEDs and, because it is opaque, causes the colors to be blended so that you are less likely to see the separate LEDs. Note: Other bulb shapes may have faceted lenses.
Wires – Three wires into this bullet and three wires out to the next as follows:
Positive (P) – This wire carries the positive or live voltage
Ground (G) – This is the ground or negative wire
Data (D) – This wire carries the commands that tell the pixel how to behave. This includes a percentage of brightness for each LED. More about this later in the Making the Colors section.
Anatomy of an RGB Tape/Ribbon
Another shape available is the RGB tape or ribbon. This is a group of pixels connected on a strip. The ones we use for Christmas lights are usually enclosed in a silicone sheath to make them waterproof. There are various configurations for ribbons that include a single pixel per chip or, three pixels per chip (as shown called a triple). For the one shown, Since the chip controls the LEDs, the three pixels will all have to be the same color.
To allow you to customize the length, the ribbon is broken into segments as indicated by the four copper strips. The image shows the third pixel of segment 1, all of segment 2 and the first pixel of segment three. The ribbon can be cut at the segment breaks and wires soldered to the copper leads as indicated.
Smart vs. Dumb Pixels
When looking for pixel strings you may see them called Smart or Dumb. The difference is whether each pixel in the string can be controlled separately or the entire string must be the same color.
Smart strings have a chip in each pixel, dumb strings have a chip in the first pixel only. The image shows two strings of five bullet pixels; the top string is smart, the bottom one is dumb.
Since the chip handles the commands from the controller to activate the LEDs, a smart string provides the ability to control each pixel separately, a dumb string only has one chip that controls all of the pixels in the string so they would all have to be the same color.
If you removed the last two pixels from the top string, they would still work by themselves. If you removed the last two pixels from the bottom string, they would not work unless you appended them to another dumb string that had a lead pixel with a chip.
Note: You cannot append dumb pixels to the end of a smart string as the controlling chip is different.
So why buy dumb pixels? They tend to be cheaper than smart pixels. If you had an application where all of the pixels in the string would always be the same color, dumb pixels would be the right answer and you could save some money. We like the flexibility of controlling every pixel so we have no dumb pixels in our show.
Making the Colors
Colors on electronic devices (like computer and phone screens and televisions) are derived by adding varying amounts (between 0 and 255) of red, green and blue. Black is R/G/B = 0/0/0 and white is R/G/B = 255/255/255. Unlike what you were taught in kindergarten, Yellow is Red + Green (bright yellow would be R/G/B = 255/255/0).
So, it stands to reason that, using different amounts of red, green and blue you could make the lights most any color.
Caution! Be sure to try your colors on the pixels you plan on running in your show because different pixels may show the same RGB combination in a slightly different color.
A main reason for this is the type of lens on the pixel, a more diffuse lens (e.g., C9 faceted) will look lighter than a bullet (with its opaque lens) or a ribbon (with no lens). Bullets from different manufacturers may also look different. Color variations are especially noticeable on full white. The same is true of your computer monitor, so don’t trust that the color you see in your sequencing software is exactly what you will see in the lights.
How Pixels Work
When I tell people that we can control every bulb in a string, they often look puzzled as to how I can do that so here’s a quick explanation of how the process works.
Note: I’m not going to explain channels in this section because that would just make it more complicated. We’ll cover that subject later.
For the explanation, let’s assume you have a smart string of five pixels and we want to light them up as shown in the diagram (white, red, green, off, and white). In our sequencing software we’ll program the lights as described. We’ll configure our smart pixel controller to know that the string contains 5 RGB pixels.
Disclaimer: I have never actually seen what a message looks like and I do not know what is actually passed to each pixel, but the illustration presented is functionally accurate to explain the process.
At the Start of a Sequence
When the sequence starts, the controller sends a message to the light string that contains commands for all five pixels. The diagram shows the message in boxes with a row of commands (R, G and B) for each pixel.
Here’s what happens:
The first pixel receives a message that contains five (5) sets of commands and performs three steps:
Act on the first set of commands – In this case it turns on all three LEDs to full (255) brightness resulting in white.
Reformats the message to exclude the first set of commands.
Sends the reformatted message to the next pixel in the string.
The second, third, fourth and fifth pixels also do the exact same thing (the only variations are what LEDs get turned on based on the RGB values in the message). As each pixel gets the message it is smaller and that pixel’s commands are the first set.
The diagram shows the message as each pixel receives it with the commands for each that pixel in red.
Interestingly, no smart pixel knows, or cares, where it is in the string. When the final pixel forwards the message, it is empty but the pixel just does its job (even if there is no pixel to receive the message).
Changing a Pixel Color
In most sequencing programs, a message is only sent to a string if something needs to change. This is to reduce the amount of information being sent over the network.
So, if we programmed a change for our fourth pixel to red at five seconds into the sequence (no changes for the other pixels) then the message sent to the string would look like something in this diagram.
YIKES! If you have a string that’s making a lot of changes (resulting in a lot of network traffic) it might occasionally miss a command and the pixel(s) will be the wrong color until they receive another command. If it’s a situation where you turn on a pixel and leave it at the same color for an extended time, and it missed the initial command to be on, it can sit there in an OFF state making you think it’s not working, until it finally gets a command. Let’s be real, with the number of commands being sent it’s a miracle that things actually work, so I think we can ignore an occasional missed command. The folks viewing the show are likely to be unaware of the issue.