Latest news Social Media





Tweet



Amblone Amblone stands for Ambilight Clone, and it is an open source 'Do It Yourself' solution for imitating Philips Ambient Lighting Technology. It projects light on the wall behind your TV or monitor in the colours that are currently on the screen.

How-to Guide

In this section we will explain exactly how you can create your own Amblone setup, consisting of 3 RGB LED strips and an Arduino Mega.

What do I need?

To create the Amblone setup described in this guide, you will need the following:

Amblone software

An Arduino microcontroller, for example the Arduino Mega

A USB A to B cable

RGB LED strips that can be manually controlled (make sure you are not buying some automatically coloursweeping strips!)

Some transistors and resistors (probably 3x the amount of LED strips you have)

A 12V adapter (or whatever your LED strips require)

Some electrical wires

Doublesided tape, or some other equipment to mount the LED strips

The Arduino microcontrollers are ideal for hobbyists, because they are very affordable, easy to program, and they offer a lot of options for a variety of in- and output devices. There are many different variations of Arduinos, and you can choose the one you think is best for your goals. The only thing that's very important is the amount of PWM outputs the Arduino has. For every RGB channel you have (LED strip or lamp), you will need 3 PWMs (one for red, one for green and one for blue). The Amblone PC software currently supports up to 4 channels, so an Arduino Mega is a very good choice, since it has 14 PWMs.

You will need a male A to male B USB cable for the communication between the PC and the Arduino Mega.

We bought our Arduino at ge-th, or actually via their eBay store, and it was a positive experience. We ordered the Arduino Mega for a very reasonable price, the shipping was pretty quick, and it also came with a USB cable.

It's also possible to order Arduinos unassembled, so you can assemble them yourself. That sounds like fun!

The most important part of your setup is, of course, the lighting that you're going to use. In this guide we use RGB LED strips, but some other projects have been done with CCFLs, LED lamps, and seperate LED lights. We bought our LED strips at Deal Extreme. Although the quality of their products isn't always the best, their prices are very sharp. Someone told me that Lightake also offers some nice products, but we have no experience with them.

We bought three 50cm LED strips; one for the top of the TV, and two for the sides.

These strips run on 12V, which cannot be supplied by the Arduino directly, so we will need a separate 12V adapter, and some transistors to control the current, determined by the Arduino. How many, and what kind of transistors you will need depends on your RGB lights. Our LED strips have one shared positive, and an individual negative for the colours. For this reason, we only needed one transistor for every red, green and blue connection, so with three LED strips, that makes 9 transistors. You will probably also need some resistors.

The last thing you will need is some electrical wiring, and you will have to think about the way to mount the LED strips on your television set. You'll probably want the strips to be firmly attached, but it should not mess with your TV, and be removable if needed. We advise using double sided tape.

Step 1: Soldering and wiring

Important! The steps you need to take in this section heavily depend on the type of light source you have chosen. Our LED strips have a shared positive and an individual negative for the red, green and blue channel. If your light source is different, the circuit diagram and the components you have to use might differ. Make sure you are using the correct circuit diagram and components before you start. Neglecting to do so can cause damage to your Arduino board, torch your dog, or blow up the light source.



The Arduino Mega has a number of Pulse Width Modulation (PWM) outputs. For each LED strip, we need to connect the red, green and blue wire to one of these outputs. Channel one uses pins 2 to 4, where pin 2 is red, pin 3 is green and pin 4 is blue. Channel two uses pins 5 to 7, where pin 5 is red, pin 6 is green and pin 7 is blue, etc. However, the Arduino itself does not have the power to drive the LED strips. For this reason, we need an extra powersource that powers the LED strips. A 12V, 1A adapter will be sufficient. We will also need a resistor and a transistor for each red, green and blue wire. For our setup, we needed three 2200Ω resistors and three NPN-transistors that could switch 200mA at 12V for each channel.



The circuit is pretty simple. Connect the output of the Arduino to a resistor, and the resistor to the base of a transistor. Connect the emitter to the ground of the Arduino, and the collector to the corresponding colour of the LED strip. Do this for all the RGB wires. Connect the common positive of the LED strips to the positive of the 12V adapter, and the negative of the 12V adapter to the ground of the Arduino.



Below is the circuit diagram: (click to enlarge)







Micah Riddell designed the circuit diagram in Fritzing before building the physical board, and he used a ULN2003A chip instead of the NPN transistors. You can also download the design at fritzing.org/projects/uln2003a-amblone-v2.

The ULN chip can be ordered at a variety of places, including: www.hobbytronics.co.uk/uln2003a-darlington-array?keyword=Uln2003A



We soldered everything onto a small piece of print, and also used some headers to be able to disconnect different parts if need be, but of course you could just solder everything together. Here's a picture of the board we made:







As you can see we used headers for both connecting our board to the Arduino, as well as plugging the LED strips into the board.



Martin Graversen took the following two pictures of his Amblone board. Visit his portfolio to see more pictures and a video.







Andrew Cox used an old ADSL modem case to house his Arduino and electronic components. He then used ethernet cables as power cables to the LED strips. The result is a very nice and professional looking case with no loose parts or wires. See the picture below or check out his fritzing project for more pictures and to see how you can do this yourself with an Arduino Duemilanove or Uno.





Step 2: Arduino Software

Next you will have to download the Arduino software . To load the software into the Arduino, you will need the Arduino environment, which can be found at arduino.cc/en/Main/Software . For instructions on connecting the Arduino to your PC, please see the guide at arduino.cc/en/Guide/Windows . Open the pde file with the Arduino environment, and select the correct Arduino model by going to Tools > Board and select Arduino Mega. Also select the right COM port under Tools > Serial Port. Next hit the Upload button. After the code has been loaded, the Arduino should automatically start running, and start again each time it gets powered either through the USB cable or auxiliarily.

Step 3: Windows Software

Step 3.1: Making it work

Now we will download the Amblone Windows Software. You can either choose to download the binaries, or the sources and compile it yourself. When you start Amblone, a tray icon will apear in the system tray. Right click the tray icon, and select 'Configure Amblone'. Here you can set some options, of which two are important at this moment.



First of all, select the monitor that you want to take the average colour from, and specify the RGB channels you are using, and which screen section they should represent. For example, if you have an RGB LED strip located at the top of your TV screen, which is selected as the second monitor, and the LED strip is connected to output pins 2 to 4, you will have to select 'Secundary Monitor' under Source Monitor, and the section of the screen you want the strip to represent under Channel 1. This will probably be 'upper half' or 'entire screen'. Of course you could also make it represent the lower left corner if you're feeling weird on a monday morning. Knock yourself out. It is also possible to make the strips emit a custom, static colour. To do this, select the 'static' option, and choose the colour you want.



Next important setting is the COM port. You will have to select the COM port that the Arduino is connected to on your PC. As soon as the correct COM port is selected, Amblone should automatically start communicating with the Arduino. A little LED in the Arduino board should start flickering if it is receiving data.



If you now plug in the adapter of the LED strips, you should see them emitting the colours that you have specified.

Step 3.2: Finetuning the software

Once everything is working, and you have taken your time to be overwhelmed by this spectacular display of awesomeness, it's time to tweak the software to get the best performance. Several options are available.



The first one is colour calculation precision. This option determines one in how many pixels will be used to calculate the average screen colour. With the slider turned to the right, the algorithm will be faster, but the colour is less precisely determined, which can cause some flickering. Setting it to the left will give the best results, but it might slow down the process, which will make the LED strips turn colours at a slower rate, or hinder other processes running on your PC.



The second option is colour darkness threshold. This option sets the threshold which pixels need to exceed to be taken into account for the average. This option is very useful if the video you are playing does not span the entire screen, which leaves parts of your monitor black. It also lightens up the colours a bit. However, setting the threshold too high can also cause some flickering.



Next is the colour accentuation option. This feature makes the colours turn away from gray and white, and towards a more destinctive colour. Setting the slider to 'Off' will also speed up the algorithm a bit.



If the colours you are seeing are somewhat correct, you will not have to touch the next option. However, if the colours of the LED strips seem to be totally different than the colours on the screen, you can try checking the flip red and blue values checkbox. On some systems, the way bitmaps are handled are different, in that they are stored in RGB format instead of BGR. Checking this option will correct this, and the right colours will be sent to the Arduino.



Next is calibration. On most RGB LED strips and other RGB light sources, the red, green and blue lights do not have the same light intensity under the same currents. Because of this, the mixed colours (such as white), will not be displayed correctly, and will turn a bit blue, for example. If this is the case, you will have to slide the slider of that colour back to reduce its domination. You will also need to calibrate if the wall you are projecting on is not completely white.

In any case, a good way to calibrate Amblone, is select a static colour for all channels, pick white (255, 255, 255), and move the sliders until white light is projected on the wall.



There's also a brightness slider. With this slider, you can reduce the entire light intensity of your Amblone setup.



The last things you can change are some performance settings. First up is process priority. If you are having trouble running Amblone next to you video player or a video game, you can try changing this setting. Intuitively, one would say that setting the priority to the low side will allow other programs to run as smooth as possible. However, this does not necessarily have to be the case, so playing around with it and seeing what it does is probably best.



The second performance setting, Limit loops per second, allows you to put a restriction on the maximum loops per second. The advantage of this is that Amblone can only access the video resources a limited amount of times per second, which can be helpful if your video player is showing some jitter or similar problems.

Allow the program to slowly adjust to this setting, which may take some time.



Below you can see how I set all the options. This configuration works very well for me, although it might be different for various other systems and applications.