Introduction: Capacitive Touch Mood/Ambilight

Picture of Capacitive Touch Mood/Ambilight

This instructable is a quick write-up of my experience creating a multifunctional moodlight. Some basic knowledge of electronic circuits is expected. The project has not yet finished, some adding functionality  and tweaking has to be done but it is already functional. If you guys are enthousiast about this instructable I will update it.



At the heart of the system is an Arduino. It will process the input from USB or each of the Capacitive touch inputs and control the RGB light.
This instructable is split into three sections:
- The capacitive touch section covers the invisible input buttons
- The moodlight section covers the controlling of the moodlight
- The ambilight section covers input by serial port, processing RGB values generated by a computer program to control the lights.

Disclaimer: Electronics can be dangerous, you yourself are responsible for any damage done. Some code is collected from forums and might not contain the name of its owner. Please let me know and I'll add your name.

Step 1: Item List

The following components are needed for this instructable:

- Arduino+USB cable
- Breadboard
- Computer power supply
- 3x RGB strips, check out dealextreme.com.
- 3x TIP120 FETs, like http://uk.farnell.com/stmicroelectronics/tip120/darlington-transistor-to-220/dp/9804005
- A bunch of resistors (6* 10 kiloOhm, 3 * 2 megaOhm)
- A lot of wire.
- Tools

Capacitive touch
- Metal rings for groundplates
- Copper wire or plate
- Something to build it into (like a bookshelf:)


Step 2: Capacitive Touch - Basics & Circuit

Picture of Capacitive Touch - Basics & Circuit

Since I was painting my bookshelfs, I had the oppurtunity to 'upgrade' them as well. I wanted to control the moodlight by means of invisible touch. At first, my plan was to use a dedicated IC for this (like the Atmel QT240). But then I stumbled upon a page explaining that the Arduino can emulate a capacitive sensor by software.

The electronic circuit can be found in the picture, the sensor is a spiralled copper wire (only one is shown for simplicity). Sensitivity is controlled by the resistors found before every pin. They can range from 1 MegaOhm (absolute touch) to 40 MegaOhm (12-24 inch away) depending on if absolute or near touch is needed (I ended up using 2M Ohm resistors). Experiment with the values until the sensor behaves like desired. It is a good idea to install some conducting surface (seperated by a thin non-conducting piece) connected to the circuits' ground at the back of each spiral. This way the sensors will be more stable and less influenced by noise.

Some more pictures about installing the sensors in a bookshelf. A plug is installed as well for easy connection with the circuit later on. Filler is used to conceal everything, and after that they are ready to be painted.

Step 3: Capacitive Touch - Code & Testing

Picture of Capacitive Touch - Code & Testing

The following source code can be used on the Arduino for debugging, check the values with the arduino serial monitor. Six values are generated. The first is a measure of the performance of the system. The second to sixth are the sensed values on every pin. The values should rise when nearing your finger. If not, check for bad connections and interference. The resistor values can be changed to determine sensitivity. By implementing an if-then structure which is activated at a certain logical treshold, a switch can be made. This will be used in the final arduino code.

More information, suggested to read: http://www.arduino.cc/playground/Main/CapSense

--- Arduino CapTouch Debugging Code ---
#include

void setup()  {
CapSense   cs_2_3 = CapSense(2,4);        // 10M resistor between pins 2 & 4, pin 4 is sensor pin, add wire, foil
CapSense   cs_2_4 = CapSense(2,7);        // 10M resistor between pins 2 & 7, pin 7 is sensor pin, add wire, foil
CapSense   cs_2_5 = CapSense(2,8);        // 10M resistor between pins 2 & 8, pin 8 is sensor pin, add wire, foil
CapSense   cs_2_6 = CapSense(2,12);        // 10M resistor between pins 2 & 12, pin 12 is sensor pin, add wire, foil
CapSense   cs_2_7 = CapSense(2,13);        // 10M resistor between pins 2 & 13, pin 13 is sensor pin, add wire, foil

void setup()                   

{
   Serial.begin(9600);
}

void loop()                   
{
    long start = millis();
    long total1 =  cs_2_3.capSense(30);
    long total2 =  cs_2_4.capSense(30);
    long total3 =  cs_2_5.capSense(30);
    long total4 =  cs_2_6.capSense(30);
    long total5 =  cs_2_7.capSense(30);   
  
    Serial.print(millis() - start);        // check on performance in milliseconds
    Serial.print("\t");                    // tab character for debug windown spacing

    Serial.print(total1);                  // print sensor output 1
    Serial.print("\t");
    Serial.print(total2);                  // print sensor output 2
    Serial.print("\t");
    Serial.print(total3);                // print sensor output 3
    Serial.print("\t");
    Serial.print(total4);                // print sensor output 4
    Serial.print("\t");
    Serial.println(total5);                // print sensor output 5

    delay(10);                             // arbitrary delay to limit data to serial port
}
--- END ---

Step 4: Mood Light - Basics & Circuit

Picture of Mood Light - Basics & Circuit

Now it is time to build the output part of the system. The arduino's PWM pins will be used to control each colour. PWM means Pulse Width Modulation, by switching a pin on and off very quickly the leds will be dimmed from 0 to 255. Every pin will be amplified by a FET. For now, the system has only one channel per color, meaning that all RGB strips will  be controlled at once and 3 PWM pins are needed (one for every colour). In the future I want to be able to control each of my four RGB strips. That means 4*3=12 PWM pins (and probably an Arduino Mega).

Ok, time for some schematics! This (see picture) is a basic representation of the circuit (will make a nicer one soon). The capacitive sensors are included as well (green part). Basically there are three components that have to be explained:

- FET
This is the amplifier I was talking about. It has a Gate, a Source and a Drain. It amplifies the senses a small current on the gate (connected to the Arduino) and opens the way for the RGB strip that is driven on 12 volts. Source should be on +12V, drain on GND (Ground). Check the specifcations sheet of your FET for exact pinout. Every RGB channel should be positioned before its own FET. In this sense, it is acting like an Arduino controlled switch.

- RGB strip
This 12 volts RGB strip is of the common anode (+) type. Meaning, that the common wire should be connected to +12V and the current is sinked through each of the seperate colour channels. The strip has incorporated resistors, so no worries about that!

- Resistors
Three 10k resistors will make sure that the FET won't turn on when they are not supposed to turn on. Three others will limit the maximum current the FET will drain. The top three resistors are already in the RGB strip.

I soldered USB cables to the RGB strips so I can modularly connect them easily. Plugs from an old hub are placed on my breadboard. Use an old computer power supply for juice, 12V for powering the RGB strip and eventually 5V for the circuit if you want it to run without the USB cable.

Step 5: Mood Light - Code & Control

The mood light is controlled by the capacitive sensors. For now, I only programmed sensors 2 & 3 for colour changing. The other sensors have no function as of yet. Here is the code:


--- Arduino Mood Control Code ---
#include

const boolean invert = true;
const long timeout = 10000;

// Capacitive sensor declaration
CapSense   In1 = CapSense(2,4);        // 2M resistor between pins 4 & 2, pin 2 is sensor pin, add wire, foil
CapSense   In2 = CapSense(2,7);        // 2M resistor between pins 4 & 6, pin 6 is sensor pin, add wire, foil
CapSense   In3 = CapSense(2,8);        // 2M resistor between pins 4 & 8, pin 8 is sensor pin, add wire, foil
CapSense   In4 = CapSense(2,12);        // 2M resistor between pins 4 & 8, pin 8 is sensor pin, add wire, foil
CapSense   In5 = CapSense(2,13);        // 2M resistor between pins 4 & 8, pin 8 is sensor pin, add wire, foil

// PWM Pin declarations
int PinR1 = 3;
int PinG1 = 5;
int PinB1 = 6;

// Other variables
int Color1 = 128;        // start at a red like colour
int Brightness1 = 255;    // start at full brightness
int RedValue1, GreenValue1, BlueValue1;    // The RGB components

void setup()                   
{    // set sensor timeout values
    In1.set_CS_AutocaL_Millis(timeout);
    In2.set_CS_AutocaL_Millis(timeout);
    In3.set_CS_AutocaL_Millis(timeout);
    In4.set_CS_AutocaL_Millis(timeout);
    In5.set_CS_AutocaL_Millis(timeout);
}

void loop()                   
{
    long start = millis();
    long total1 =  In1.capSense(30);
    long total2 =  In2.capSense(30);
    long total3 =  In3.capSense(30);
    long total4 =  In4.capSense(30);
    long total5 =  In5.capSense(30);

    if (total2 > 150) {
          Color1++;         // increment the color
          if(Color1 > 255) {   //
             Color1 = 0;
          }
    } else if (total3 > 200) {
          Color1--;         // decrement the color
          if(Color1 < 0) {   //
             Color1 = 255;
          }
    // convert hue to rgb
    hueToRGB(Color1, Brightness1);
       
    // write colors to PWM pins
    analogWrite(PinR1, RedValue1);
    analogWrite(PinG1, GreenValue1);
    analogWrite(PinB1, BlueValue1);
}

// function to convert a color to its Red, Green, and Blue components.

void hueToRGB(int hue, int brightness)

    unsigned int scaledHue = (hue * 6);
    unsigned int segment = scaledHue / 256; // segment 0 to 5 around the color wheel
    unsigned int segmentOffset = scaledHue - (segment * 256);    // position within the segment
   
    unsigned int compliment = 0;
    unsigned int prev = (brightness * ( 255 -  segmentOffset)) / 256;
    unsigned int next = (brightness *  segmentOffset) / 256;

  if(invert)
    {
    brightness = 255-brightness;
    compliment = 255;
    prev = 255-prev;
    next = 255-next;
    }
   
    switch(segment ) {
    case 0:    // red
    RedValue1 = brightness;
    GreenValue1 = next;
    BlueValue1 = compliment;
    break;
    case 1:     // yellow
    RedValue1 = prev;
    GreenValue1 = brightness;
    BlueValue1 = compliment;
    break;
    case 2:     // green
    RedValue1 = compliment;
    GreenValue1 = brightness;
    BlueValue1 = next;
    break;
    case 3:    // cyan
    RedValue1 = compliment;
    GreenValue1 = prev;
    BlueValue1 = brightness;
    break;
    case 4:    // blue
    RedValue1 = next;
    GreenValue1 = compliment;
    BlueValue1 = brightness; 
    break;
   case 5:    // magenta
    default:
    RedValue1 = brightness;
    GreenValue1 = compliment;
    BlueValue1 = prev;
    break;
    }
}
--- END ---

Step 6: Ambi Light - Arduino Side

Of course, it would be totally cool to be able to control the mood light from your computer. For example to create an ambilight or a sound controlled disco. This section focusses on the ambilight part, in the future I will add more functionality.

Well, there's no additional circuitry because it is all available in the Arduino. What we are going to use is the serial communiction capabilities and some 'Processing 1.0' software. Hook-up your arduino to your computer by an USB cable (if you were uploading sketches to it, it already is). 

For the arduino, well have to add some extra code for serial communication. The code will switch to listen mode, turning of the capacitive sensors as long as it receives RGB values from the computer. It then sets the RGB values to the PWM pins. This is my final code for now, check for the changes yourself:

--- Arduino Ambilight Code ---
#include

const boolean invert = true;
const long timeout = 10000;
long commStart = 0;
char val;

// Capacitive sensor declaration
CapSense   In1 = CapSense(2,4);        // 2M resistor between pins 4 & 2, pin 2 is sensor pin, add wire, foil
CapSense   In2 = CapSense(2,7);        // 2M resistor between pins 4 & 6, pin 6 is sensor pin, add wire, foil
CapSense   In3 = CapSense(2,8);        // 2M resistor between pins 4 & 8, pin 8 is sensor pin, add wire, foil
CapSense   In4 = CapSense(2,12);        // 2M resistor between pins 4 & 8, pin 8 is sensor pin, add wire, foil
CapSense   In5 = CapSense(2,13);        // 2M resistor between pins 4 & 8, pin 8 is sensor pin, add wire, foil

// PWM Pin declarations
int PinR1 = 3;
int PinG1 = 5;
int PinB1 = 6;

// Other variables
int Color1 = 128;        // start at a red like colour
int Brightness1 = 255;    // start at full brightness
int RedValue1, GreenValue1, BlueValue1;    // The RGB components

void setup()                   
{
    Serial.begin(9600);    // start serial communiction
// set sensor timeout values
    In1.set_CS_AutocaL_Millis(timeout);
    In2.set_CS_AutocaL_Millis(timeout);
    In3.set_CS_AutocaL_Millis(timeout);
    In4.set_CS_AutocaL_Millis(timeout);
    In5.set_CS_AutocaL_Millis(timeout);
}

void loop()                   
{
    long start = millis();
    long total1 =  In1.capSense(30);
    long total2 =  In2.capSense(30);
    long total3 =  In3.capSense(30);
    long total4 =  In4.capSense(30);
    long total5 =  In5.capSense(30);
   
    if (Serial.available()) {             // If data is available to read,
     val = Serial.read();                // read it and store it in val
     commStart = millis();
 
   if (val == 'S') {                   //If start char is recieved,
     while (!Serial.available()) {}    //Wait until next value.
     RedValue1 = Serial.read();              //Once available, assign.

     while (!Serial.available()) {}    //Same as above.
     GreenValue1 = Serial.read();

     while (!Serial.available()) {}
     BlueValue1 = Serial.read();
     }
     Serial.print(RedValue1);
     Serial.print(GreenValue1);
     Serial.println(BlueValue1);
  } else if ((millis() - commStart) > 1000) {
   
 if (total2 > 150) {
          Color1++;         // increment the color
          if(Color1 > 255) {   //
             Color1 = 0;
          }
    } else if (total3 > 200) {
          Color1--;         // decrement the color
          if(Color1 < 0) {   //
             Color1 = 255;
          }
    }
    hueToRGB(Color1, Brightness1);
    }
   
    analogWrite(PinR1, RedValue1);
    analogWrite(PinG1, GreenValue1);
    analogWrite(PinB1, BlueValue1);
}

// function to convert a color to its Red, Green, and Blue components.

void hueToRGB(int hue, int brightness)

    unsigned int scaledHue = (hue * 6);
    unsigned int segment = scaledHue / 256; // segment 0 to 5 around the color wheel
    unsigned int segmentOffset = scaledHue - (segment * 256);    // position within the segment
   
    unsigned int compliment = 0;
    unsigned int prev = (brightness * ( 255 -  segmentOffset)) / 256;
    unsigned int next = (brightness *  segmentOffset) / 256;

  if(invert)
    {
    brightness = 255-brightness;
    compliment = 255;
    prev = 255-prev;
    next = 255-next;
    }
   
    switch(segment ) {
    case 0:    // red
    RedValue1 = brightness;
    GreenValue1 = next;
    BlueValue1 = compliment;
    break;
    case 1:     // yellow
    RedValue1 = prev;
    GreenValue1 = brightness;
    BlueValue1 = compliment;
    break;
    case 2:     // green
    RedValue1 = compliment;
    GreenValue1 = brightness;
    BlueValue1 = next;
    break;
    case 3:    // cyan
    RedValue1 = compliment;
    GreenValue1 = prev;
    BlueValue1 = brightness;
    break;
    case 4:    // blue
    RedValue1 = next;
    GreenValue1 = compliment;
    BlueValue1 = brightness; 
    break;
   case 5:    // magenta
    default:
    RedValue1 = brightness;
    GreenValue1 = compliment;
    BlueValue1 = prev;
    break;
    }
}
--- END ---

Step 7: Ambi Light - Computer Side

On the side of the computer a Processing 1.0 sketch is run, see processing.org . This little (somewhat messy) program calculates the average screencolor at every instant and sends this to the serial port. It is very basic as of yet and it could use some tweaking, but it works very well! I will update it in the future for multiple separate RGB strips and screen sections. You could also do that yourself, the language is quite straightforward.

Here is the code:

--- Processing 1.0 Code ---
import processing.serial.*;
import java.awt.AWTException;
import java.awt.Robot;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;

PImage screenShot;
Serial myPort;

static public void main(String args[]) {
  PApplet.main(new String[] {
    "--present", "shooter"  }
  );
}

void setup() {
  size(100,100); //size(screen.width, screen.height);
  // Print a list of the serial ports, for debugging purposes:
  println(Serial.list());

  // I know that the first port in the serial list on my mac
  // is always my  FTDI adaptor, so I open Serial.list()[0].
  // On Windows machines, this generally opens COM1.
  // Open whatever port is the one you're using.
  String portName = Serial.list()[0];
  myPort = new Serial(this, portName, 9600);
}

void draw () {
  //image(screenShot,0,0, width, height);
  screenShot = getScreen();
  color kleur = color(0,0,0);
  kleur = colour(screenShot);
  //myPort.write(int(red(kleur))+','+int(green(kleur))+','+int(blue(kleur))+13);
  //myPort.write(int(red(kleur)));
  //myPort.write(',');
  //myPort.write(int(green(kleur)));
  //myPort.write(',');
  //myPort.write(int(blue(kleur)));
  //myPort.write(13);
  fill(kleur);
  rect(30, 20, 55, 55);
}

color colour(PImage img) {
  int cols = (img.width);
  int rows = (img.height);
  int dimension = (img.width*img.height);
  int r = 0;
  int g = 0;
  int b = 0;
  img.loadPixels();

// Ga elke pixel langs (dimension)
for (int i = 0; i < (dimension/2); i++) {
  r = r + ((img.pixels[i] >> 16) & 0xFF);
  g = g + ((img.pixels[i] >> 8) & 0xFF);
  b = b + (img.pixels[i] & 0xFF);
}

int mean_r = r/(dimension/2);
int mean_g = g/(dimension/2);
int mean_b = b/(dimension/2);

color mean_clr = color(mean_r, mean_g, mean_b);
  myPort.write('S');
  myPort.write(mean_r);
  myPort.write(mean_g);
  myPort.write(mean_b);
return (mean_clr);
}

PImage getScreen() {
  GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
  GraphicsDevice[] gs = ge.getScreenDevices();
  DisplayMode mode = gs[0].getDisplayMode();
  Rectangle bounds = new Rectangle(0, 0, mode.getWidth(), mode.getHeight());
  BufferedImage desktop = new BufferedImage(mode.getWidth(), mode.getHeight(), BufferedImage.TYPE_INT_RGB);

  try {
    desktop = new Robot(gs[0]).createScreenCapture(bounds);
  }
  catch(AWTException e) {
    System.err.println("Screen capture failed.");
  }

  return (new PImage(desktop));
}

--- END ---

Step 8: Result

Picture of Result

And this is the result, it is actually at the bottom side of my bed. I still need to replace the cloth, it will diffuse the light more. More pictures on that soon.



I hope you like this instructable and I also hope it is a base for your own creativity. Because of time-constraints I wrote it very quickly. You might need to have some basic arduino/electronics knowledge to understand it but I plan to update it in the future if it is well received.

Comments

RPKH (author)2010-06-07

Symbols used in the schematics are transistors not FETs

ewertz (author)RPKH2012-09-07

FETs are transistors -- but it's true that the symbols used in the schematic are for bipolar transistors.

MANIAC (author)2010-06-16

would you be able to sue seperate el wire instead of leds? if so, what modification would need to be made?? thanks.

ewertz (author)MANIAC2012-09-07

LEDs are driven with DC current and EL wire is not -- you need a special inverter to drive them. So, no, you cannot just swap out LEDs and replace them with EL wire.

If you haven't looked there already, Adafruit (www.adafruit.com) has a lot of EL products and examples you may be interested in.

thewindomearlecharacter (author)2012-08-06

Hi everyone,

I'm a newbie using arduino but I tried something with the CapSense as well.

It worked just fine (the numbers in the Serial Monitor changed a bit while contacting with my hand), but now I get always the same number in the Serial Monitor :x Does that mean the resistor is dead or something?

Any help is welcomed.

Thanks in advance.

I already know the resistor is alive.

I started the program from scratch and the values change again.

joedpogi (author)2011-11-13

Nice project, I would like to make my touch sensors too with my arduino, is it possible to use all of the digital and analog pins for many touch sensors?

kctess5 (author)2011-01-29

Whats wrong with just using a TIP31 transistor, it sounds like it does the same thing as a FET

Gazaman (author)2010-11-16

May I suggest using an Arduino Mini or a Mini Pro? You need a FTDI cable or FTDI Basic and a USB cable to connect like a full size Arduino board, you can get it in 3.3V or 5V source and it takes unregulated DC voltage from a wall wart or battery to the RAW pin. With projects like this you may want to keep the Arduino embedded if it's a "keeper" and these stamp sized units are smaller and cheaper.

Bongmaster (author)2009-11-15

kools :)

About This Instructable

19,823views

42favorites

License:

More by lunar:Capacitive touch Mood/Ambilight
Add instructable to: