The second part of the Ozilight Arduino Ambilight TV project would be about how to control the RGB LED strip using Arduino, learn how to communicate between the Processing application and the Arduino, and ultimately integrate these ideas into our TV ambilight system. If you have not seen the first part, it’s here.

Some of the links on this page are affiliate links. I receive a commission (at no extra cost to you) if you make a purchase after clicking on one of these affiliate links. This helps support the free content for the community on this website. Please read our Affiliate Link Policy for more information.

If you have not seen the result, check out this video.

How to control the RGB LED strip using Arduino

I am using the WS2811 RGB LED strip, and it’s not controlled by RGB PWM signals, but some other protocol which only requires one wire connection. This would be quite difficult to do from scratch. Luckily the Adafruit team has developed a library for this type of LED strip, check out the NeoPixel Library.

I won’t go into too much detail how to use this library since it’s very simple, look it up on one of the examples included in the library.

http://www.youtube.com/watch?v=OEAyLy7_pq8

This video shows I am running the example in the library.

Communication between the Processing application and the Arduino

Serial communication is the most obvious option here (USB cable). Although we are not controlling the LEDs with RGB values directly, we still need to send the RGB values to the Arduino from Processing application. For 25 LEDs, we will have at least 75 data we need to send each time we take a screen shot.

That’s quite a few data here, and things could go wrong sometimes with data transmission (lost data). So what I have here is a two way communication protocol:

• Each time we are sending these 75 RGB data, we always append some constant values at the beginning, such as characters ‘o’ and ‘z’. This is a identifier for the Arduino so it knows this is the start of some new data
• When the Arduino finished receiving all the 75 RGB data, it will talk to the Processing Application, “I am done now, next bunch of data please.”
• When there is lost data, the Arduino would receive fewer then 75 data, and it will just stupidly wait. So we will need some kind of timeout functions to time how long we have waited and give up on the current operation.

Finally Arduino Ambilight TV is created by putting everything together

Don’t have much to say about this, went quite smoothly once I figured out how each part should work. I made a light adjustment to the LEDs position, now it’s 10 columns and 6 rows. (same number of LEDs, 25 of them, but taking 1 LED from the bottom left edge to the top edge)

And mounting the LED strip on the TV needs to be very accurate as well. It’s best to make the LEDs face slightly outward, so you can see more of the light from the front. But I am lazy so I just simply use Sellotape Tape, and it’s not accurate, AT ALL. ( I know I could do better than that)

In the code, You might notice a new array variable prevColor, this is a copy of ledColor from last cycle, and we will mix the current colour with previous colour, to get a nice and smooth colour transition effect.

If you are not sure what  “&0xff ” means, check out my post about this.

The current of each LED is about 20mA, so 25 of them is about 500mA.

Host Source code (Processing)

import java.awt.*;
import java.awt.image.*;
import processing.serial.*;

/*
// using 12 RGB LEDs
static final int led_num_x = 4;
static final int led_num_y = 4;
static final int leds[][] = new int[][] {
  {1,3}, {0,3}, // Bottom edge, left half
  {0,2}, {0,1}, // Left edge
  {0,0}, {1,0}, {2,0}, {3,0}, // Top edge
  {3,1}, {3,2}, // Right edge
  {3,3}, {2,3}, // Bottom edge, right half
};

*/

// using 25 RGB LEDs
static final int led_num_x = 10;
static final int led_num_y = 6;
static final int leds[][] = new int[][] {
  {2,5}, {1,5}, {0,5}, // Bottom edge, left half
  {0,4}, {0,3}, {0,2}, {0,1}, // Left edge
  {0,0}, {1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}, {7,0}, {8,0}, {9,0}, // Top edge
  {9,1}, {9,2}, {9,3}, {9,4}, // Right edge
  {9,5}, {8,5}, {7,5}, {6,5}  // Bottom edge, right half

};

static final short fade = 70;

static final int minBrightness = 120;

// Preview windows
int window_width;
int window_height;
int preview_pixel_width;
int preview_pixel_height;

int[][] pixelOffset = new int[leds.length][256];

// RGB values for each LED
short[][]  ledColor    = new short[leds.length][3],
      prevColor   = new short[leds.length][3];  

byte[][]  gamma       = new byte[256][3];
byte[]    serialData  = new byte[ leds.length * 3 + 2];
int data_index = 0;

//creates object from java library that lets us take screenshots
Robot bot;

// bounds area for screen capture         
Rectangle dispBounds;

// Monitor Screen information    
GraphicsEnvironment     ge;
GraphicsConfiguration[] gc;
GraphicsDevice[]        gd;

Serial           port;

void setup(){

  int[] x = new int[16];
  int[] y = new int[16];

  // ge - Grasphics Environment
  ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
  // gd - Grasphics Device
  gd = ge.getScreenDevices();
  DisplayMode mode = gd[0].getDisplayMode();
  dispBounds = new Rectangle(0, 0, mode.getWidth(), mode.getHeight());

  // Preview windows
  window_width      = mode.getWidth()/5;
  window_height      = mode.getHeight()/5;
  preview_pixel_width     = window_width/led_num_x;
  preview_pixel_height   = window_height/led_num_y;

  // Preview window size
  size(window_width, window_height);

  //standard Robot class error check
  try   {
    bot = new Robot(gd[0]);
  }
  catch (AWTException e)  {
    println("Robot class not supported by your system!");
    exit();
  }

  float range, step, start;

  for(int i=0; i<leds.length; i++) { // For each LED...

    // Precompute columns, rows of each sampled point for this LED

    // --- for columns -----
    range = (float)dispBounds.width / led_num_x;
    // we only want 256 samples, and 16*16 = 256
    step  = range / 16.0; 
    start = range * (float)leds[i][0] + step * 0.5;

    for(int col=0; col<16; col++) {
      x[col] = (int)(start + step * (float)col);
    }

    // ----- for rows -----
    range = (float)dispBounds.height / led_num_y;
    step  = range / 16.0;
    start = range * (float)leds[i][1] + step * 0.5;

    for(int row=0; row<16; row++) {
      y[row] = (int)(start + step * (float)row);
    }

    // ---- Store sample locations -----

    // Get offset to each pixel within full screen capture
    for(int row=0; row<16; row++) {
      for(int col=0; col<16; col++) {
        pixelOffset[i][row * 16 + col] = y[row] * dispBounds.width + x[col];
      }
    }

  }

  // Open serial port. this assumes the Arduino is the
  // first/only serial device on the system.  If that's not the case,
  // change "Serial.list()[0]" to the name of the port to be used:
  // you can comment it out if you only want to test it without the Arduino

 //port = new Serial(this, Serial.list()[0], 115200);

  // A special header expected by the Arduino, to identify the beginning of a new bunch data.  
  serialData[0] = 'o';
  serialData[1] = 'z';

}

void draw(){

  //get screenshot into object "screenshot" of class BufferedImage
  BufferedImage screenshot = bot.createScreenCapture(dispBounds);

  // Pass all the ARGB values of every pixel into an array
  int[] screenData = ((DataBufferInt)screenshot.getRaster().getDataBuffer()).getData();

  data_index = 2; // 0, 1 are predefined header

  for(int i=0; i<leds.length; i++) {  // For each LED...

    int r = 0;
    int g = 0;
    int b = 0;

    for(int o=0; o<256; o++)  	
    {       //ARGB variable with 32 int bytes where        	 		
        int pixel = screenData[ pixelOffset[i][o] ];        		
        r += pixel & 0x00ff0000;        		
        g += pixel & 0x0000ff00;        		
        b += pixel & 0x000000ff;      	
    }      	 	
    // Blend new pixel value with the value from the prior frame   
  
    ledColor[i][0]  = (short)(((( r >> 24) & 0xff) * (255 - fade) + prevColor[i][0] * fade) >> 8);
    ledColor[i][1]  = (short)(((( g >> 16) & 0xff) * (255 - fade) + prevColor[i][1] * fade) >> 8);
    ledColor[i][2]  = (short)(((( b >>  8) & 0xff) * (255 - fade) + prevColor[i][2] * fade) >> 8);

    serialData[data_index++] = (byte)ledColor[i][0];
    serialData[data_index++] = (byte)ledColor[i][1];
    serialData[data_index++] = (byte)ledColor[i][2];

    float preview_pixel_left  = (float)dispBounds.width  /5 / led_num_x * leds[i][0] ;
    float preview_pixel_top    = (float)dispBounds.height /5 / led_num_y * leds[i][1] ;

    color rgb = color(ledColor[i][0], ledColor[i][1], ledColor[i][2]);
    fill(rgb);  
    rect(preview_pixel_left, preview_pixel_top, preview_pixel_width, preview_pixel_height);

  }

  if(port != null) {

    // wait for Arduino to send data
    for(;;){

      if(port.available() > 0){
        int inByte = port.read();
        if (inByte == 'y')
          break;
      }

    }
    port.write(serialData); // Issue data to Arduino

  }

  // Benchmark, how are we doing?
  println(frameRate);
  arraycopy(ledColor, 0, prevColor, 0, ledColor.length);

}

Slave Source code (Arduino)

#include <Adafruit_NeoPixel.h>

#define PIN 6
#define NUM_LED 25
#define NUM_DATA 77 // NUM_LED * 3 + 2
#define RECON_TIME 2000 // after x seconds idle time, send afk again.

// Parameter 1 = number of pixels in strip
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LED, PIN, NEO_GRB + NEO_KHZ800);

uint8_t led_color[NUM_DATA];
int index = 0;
unsigned long last_afk = 0;
unsigned long cur_time = 0;

void setup() {
	strip.begin();
	strip.show(); // Initialize all pixels to 'off'
	Serial.begin(115200);
	Serial.print("ozy"); // Send ACK string to host

	for(;;){

		if (Serial.available() > 0) {
			led_color[index++] = (uint8_t)Serial.read();

			if (index >= NUM_DATA){

				Serial.write('y');
				last_afk =  millis();
				index = 0;		

				if ((led_color[0] == 'o') && (led_color[1] == 'z')){
					// update LEDs
					for(int i=0; i<NUM_LED; i++){ 						int led_index = i*3 + 2; 						strip.setPixelColor(i, strip.Color(led_color[led_index], led_color[led_index+1], led_color[led_index+2])); 					} 					strip.show(); 					 				}	 				 			} 			 		} 		else{ 		 			cur_time = millis(); 			if (cur_time - last_afk > RECON_TIME){
				Serial.write('y');
				last_afk =  cur_time;
				index = 0;
			}

		}

	}

}

void loop() {
}