Remote control of a multi-light chandelier with Arduino

To be frank, I'm not exactly sure why I even started this project. Initially I just wanted to change bulbs in a chandelier in my bedroom. It is a nice looking chandelier as you can see on the picture. However there was a little problem. First, it has 15 lights and was originally designed to host G4 2-pin halogen bulbs. These little criminals were looking like this:

They were probably around 15-20W and there was no way to switch them on and off partially in my chandelier. Only all at once, and this means the whole thing was devouring 225-300W whenever it was used. Oh top of that, the G4 halogen bulbs were extremely unreliable, rarely lasting more than few months so we usually had only 7-8 of them working at any given time.

Things have improved a bit with the ubiquitous emergence of LED. These guys below did the same job at much less cost and power consumption:

Each of them is sipping only 2-3W and gives about the same amount of light. They are also thought to be much more reliable. In theory.

Actually, I had to replace them almost as often as the old halogen bulbs. Not sure why. Probably there is something wrong with my installation because the bulbs were glowing at night when switched off. One can read more about this phenomena in this article. Besides, it was hard to find warm light bulbs of this size for 220v so I was spending my time browsing through Amazon trying to find a reasonably priced replacement. One day I found a good offer - G4 LED, 2 pin and warm light so I immediately placed an order for 30 pieces... and realized after some time that they were actually 12v, not 220. Looking great though:

When connected to a lab power supply, they were showing exactly 0.1 Amp at 12v = 1.2W giving me 18W for 15 lights, which is not bad at all! So I decided that I need a 220 to 12V adapter, which can give around 1.5 Amp continuously, and bought one of these:

When I took my chandelier off the ceiling and tried with all the bulbs inserted, the result was perfect. The light was steady and warm and the adapter was handling the 15 lights easily. The only problem is - there is no way I could hide this adapter behind the ceiling although it was not very big. Oops.

I disassembled the adapter in the hope that I can take the electronic board out from it and place within the chandelier. Unfortunately the board was still too big, and, after cursing for some time, I decided to re-solder the adapter on a smaller prototype board of the size that could fit the flippin' chandelier. I'm not going to describe in details how I did it but re-soldering SMD components wasn't easy, believe me. Don't repeat this at home, please :)

On a bright side, I found a closely matching circuit diagram for it so now I know how these devils are made.

You may ask me - this is all nice but where is Arduino part? Please stay with me, it is coming :) Just wanted to share my joy when, after several weekends of soldering, my custom-made round-shaped adapter actually worked!

At this very moment I told to myself that, with 12v on board, I need to do something nice with my chandelier, otherwise it is not cool. After all, there is a little round container, right above the bigger one I just used for the adapter, virtually empty... hmm... right place for Arduino Nano...

Now it is time for drumbeats. Ladies and gentlemen, please welcome the Arduino MagicLamp project, which allows you, with help of the Arduino IR remote, to:

• Switch on and off bulbs on the chandelier, all or partially, or with running light effect.

• Shift the pattern of lights back and forth, invert or apply the running-light effect.

• Store the configuration of lights in the non-volatile memory

• Switch on or switch off the chandelier automatically depending on the illumination level of your room. One can also set up the illumination threshold at which the chandelier is lit on, using the same IR remote. The threshold is stored in the non-volatile memory.

• ... go get beer in the nearest supermarket (disclaimer - actually not)

The circuit diagram for the lamp is shown below:

As you can see, it is very simple and doesn't require any rare components. Since my chandelier has 15 bulbs, I decided to combine them in switching groups SG1-5 with the 3 in each, to keep it simple.The transistors T1.1-1.2 are cascaded to ensure reliable switching from the Arduino digital output. The T1.2 can be installed on the heatsink if required but, in my case, it was unnecessary, since the total current it needs to handle in open state is 0.1Amp x 3 = 0.3A, which corresponds to 0.018W for the opened transistor. Easy job for D882, it can dissipate up to 1W without any cooling.

Arduino digital outputs D2-D6 used for switching in my case can be easily increased up to 10 if required, with some changes in the Arduino sketch. This is more than enough for most home chandeliers.

The sketch for this project is below.

#include <IRremote.h>
#include <EEPROM.h>
const uint8_t POWER_BIT = 0xF;
const uint16_t POWER = 0x45;        // Power button (requires 3-sec long press for activation)
const uint16_t KEY_0 = 0x16;        // 1 light 
const uint16_t KEY_1 = 0x0C;        // 101 light combination
const uint16_t KEY_2 = 0x18;        // 10101 
const uint16_t KEY_3 = 0x5E;        // 11110
const uint16_t KEY_4 = 0x08;        // 11111 (all on)
const uint16_t KEY_5 = 0x1C;        // intro increasing right-to-left till all on state
const uint16_t KEY_6 = 0x5A;        // increasing left-to-righ till all on state
const uint16_t KEY_7 = 0x42;        // increasing to center till all on state
const uint16_t KEY_8 = 0x52;        // increasing from center till all on state
const uint16_t KEY_9 = 0x4A;        // running light then all on
const uint16_t KEY_UP = 0x09;       // shift up 
const uint16_t KEY_DOWN = 0x07;     // shift down
const uint16_t KEY_VUP = 0x46;      // adding 1 light
const uint16_t KEY_VDOWN = 0x15;    // removing 1 light
const uint16_t KEY_ST_REPT = 0x0D;  // store config of lights in non-volatile memory
const uint16_t KEY_EQ = 0x19;       // invert lights
const uint16_t KEY_FF = 0x43;       // circular shift up (running light effect)
const uint16_t KEY_FB = 0x44;       // circular shift down
const uint16_t KEY_PP = 0x40;       // circular shift pause/play
const uint16_t KEY_FUNC = 0x47;     // func key for setting max/min amb light
const uint16_t VENDORID = 0xFF00;   // not used
const uint16_t ADDRESS = 0x0000;    // address of the device
const uint16_t ALL_ON = 0x801F;     // all on
const uint16_t ALL_OFF = 0x8000;    // all off
uint16_t command = 0x0;
uint16_t prev_command = 0x0;
uint16_t prev2 = 0x0;
const uint8_t MAX_COUNT = 0xF;
const uint8_t LONG_PRESS = 3;       // number of cycles a button need to be pressed to recognize long press
const int SAVED_STATE_ADDR = 0;
uint8_t com_count = 0;
uint8_t cycle = 0;
const int RECV_PIN = 10;            // Arduino pin where the IR receiver is connected
const int FEEDB_PIN = 12;           // Arduino pin where the IR feedback LED is connected
IRrecv irrecv(RECV_PIN);
const int STARTPIN = 2;
const int MAXPINS = 5;
const int MIDPIN = ceil(MAXPINS/2);
uint16_t state = ALL_ON;            // Bitfield for storing current state of the Magic Lamp.
const uint16_t DEFAULT_MAX_AMBLIGHT = 0xFFFF;        // default max ambient light (always on)
const int MAX_DISP = 0xA;                            // max disp 
const int SAVED_MAXALGHT_ADDR = sizeof(uint16_t);    // address to save max
const int SAVED_MINALGHT_ADDR = 2*sizeof(uint16_t);    // address to save min
uint16_t max_amblight = DEFAULT_MAX_AMBLIGHT;        // maximum amblight threshold
uint16_t min_amblight = 0x0;                           // minimmum amblight threshold
uint16_t light_readings[MAX_COUNT];                  // stack of last amb light readings
void setup(){
 for(int i=0; i<MAXPINS; i++)
   pinMode(STARTPIN+i, OUTPUT);
 pinMode(FEEDB_PIN, OUTPUT);
 Serial.begin(9600);
//  Serial.println("Start IR");
 switchon();
 irrecv.enableIRIn();
}
int onCount() {
 int count=0;
 for(int i=0; i<MAXPINS; i++)
   if(bitRead(state,i)) count++;
 return count;
}
void blink(int times, uint16_t ms) {
 for(int i = 0; i<times; i++) {
   digitalWrite(FEEDB_PIN, HIGH);
   delay(ms);
   digitalWrite(FEEDB_PIN, LOW);
   delay(ms);
 }
}
void shift(bool up) {
     if(up) {
       bool buf = bitRead(state, MAXPINS-1);
       state = state << 1;
       bitWrite(state, 0, buf);
     }
     else {
       bool buf = bitRead(state, 0);
       state = state >> 1;
       bitWrite(state, MAXPINS-1, buf);
     }
     state = ALL_OFF + lowByte(state);
}
bool isplayable(uint16_t command) {
 return (command == KEY_FF) || (command == KEY_FB);
}
uint16_t get_run_avg(uint16_t light) {
 long total=0;
 for(int i=0; i<MAX_COUNT; i++) {
   if(i < MAX_COUNT-1) {
     light_readings[i] = light_readings[i+1];
     total += light_readings[i];
   }
   else {
     light_readings[i] = light;
     total += light_readings[i];
   }
 }
 return (uint16_t) round((float)total/MAX_COUNT);
}
uint16_t get_disp(uint16_t avglight) {
 long total=0;
 long delta=0;
 for(int i=0; i < MAX_COUNT; i++) {
   delta = (int)light_readings[i] - (int)avglight;
   delta = sq(delta);
   total = total + delta;
 }
 return (uint16_t) sqrt((float)total/(MAX_COUNT-1));
}
void reset_readings() {
 for(int i=0; i<MAX_COUNT; i++)
   light_readings[i] = 0;
}
void switchon() {
 EEPROM.get(SAVED_STATE_ADDR, state);
 if(onCount() == 0)
   state = ALL_ON;
 EEPROM.get(SAVED_MAXALGHT_ADDR, max_amblight);
 if(max_amblight == 0)
   max_amblight = DEFAULT_MAX_AMBLIGHT;
 EEPROM.get(SAVED_MINALGHT_ADDR, min_amblight);
 com_count = 0;
 cycle = 0;
 prev_command = 0;
 reset_readings();
}
void switchoff() {
 state = 0x0;
 cycle = 0;
 com_count = 0;
 prev_command = 0;
 reset_readings();
}
void set_min_amblight(uint16_t light) {
 min_amblight = light;
 EEPROM.put(SAVED_MINALGHT_ADDR, min_amblight);
 Serial.print("Min Light = ");
 Serial.println(min_amblight); 
}
void set_max_amblight(uint16_t light) {
 max_amblight = light;
 EEPROM.put(SAVED_MAXALGHT_ADDR, max_amblight);
 Serial.print("Max Light = ");
 Serial.println(max_amblight);
}
void loop(){
 uint16_t light = get_run_avg(analogRead(A7));
 uint16_t disp = get_disp(light);
 Serial.print(" ");
 Serial.print(light);
 Serial.print(" ");
 Serial.println(disp);
 if (irrecv.decode()){
   if((irrecv.decodedIRData.protocol) == NEC && irrecv.decodedIRData.address == ADDRESS) {
     command = irrecv.decodedIRData.command;
     if(prev_command == KEY_FUNC and command != KEY_FUNC) {
       switch(command) {
         case KEY_0:
           set_max_amblight(DEFAULT_MAX_AMBLIGHT);
           set_min_amblight(0);
           blink(3, 200); 
           break;
         case KEY_1:
           if(disp < MAX_DISP) {
             set_max_amblight(light);
             blink(3, 200);
           }
           break;
         case KEY_3:
           if(disp < MAX_DISP) {
             set_min_amblight(light);
             blink(3, 200);
           }
           break;
         case KEY_4:
           set_max_amblight(DEFAULT_MAX_AMBLIGHT);
           blink(3, 200);
           break;
         case KEY_6:
           set_min_amblight(0);
           blink(3, 200);
           break;
         default:
           blink(1, 50);
           break;
       }
       command = 0;
       com_count = 0;
     }
     else       
       blink(1, 50);
     bool isOn = bitRead(state,POWER_BIT);
     if (isOn && (command == KEY_PP)) {
       if(isplayable(prev_command)) {
         prev2 = prev_command;
       }
       else if(prev_command == KEY_PP) {
         command = prev2;
       }
     }
     if (prev_command != command) {
       prev2 = prev_command;
       prev_command = command;
       com_count = 0;
     }
     else {
       if(irrecv.decodedIRData.decodedRawData == 0 && (com_count < MAX_COUNT) ) 
         com_count++;
       else
         com_count = 0;
     }
//      Serial.println(irrecv.decodedIRData.decodedRawData, HEX);
//      Serial.println(irrecv.decodedIRData.address, HEX);
//      Serial.println(command, HEX); 
//      Serial.println(com_count, HEX);
     switch(command) {
       case POWER:
         if(com_count>1) {
           if(!isOn) 
             switchon();
           else 
             switchoff();
         }
         break;
       case KEY_0:
         state = 0x8001;
         break;
       case KEY_1:
         state = 0x8005;
         break;
       case KEY_2:
         state = 0x8015;
         break;
       case KEY_3:
         state = 0x800F;
         break;
       case KEY_4:
         state = 0x801F;
         break;
       case KEY_5:
       case KEY_6:
       case KEY_7:
       case KEY_8:
       case KEY_9:
         state = ALL_OFF;
         cycle = 0;
         break;
       case KEY_FF:
       case KEY_FB:
         break;
       case KEY_EQ:
         if(isOn && (onCount()<MAXPINS))
           for(int i=0; i<MAXPINS; i++)
             bitWrite(state, i, !bitRead(state,i));
         break;
       case KEY_UP:
         if(isOn) {
           shift(HIGH);
         }
         break;
       case KEY_DOWN:
         if(isOn) {
           shift(LOW);
         }
         break;  
       case KEY_VUP:
         if(!isOn) bitWrite(state, POWER_BIT, HIGH);
         for(int i=0; i<MAXPINS; i++)
           if(!bitRead(state,i)) {
             bitWrite(state,i,HIGH);
             break;
           }
         break;
       case KEY_VDOWN:
         for(int i = MAXPINS-1; i >= 0; i--)
           if(bitRead(state,i)) {
             bitWrite(state,i,LOW);
             if((lowByte(state) & 0x1F) == 0) 
               bitWrite(state, POWER_BIT, LOW);
             break;
           }
         break;
       case KEY_ST_REPT:
         if(isOn && com_count > LONG_PRESS) {
           // Long press, store current state
           EEPROM.put(SAVED_STATE_ADDR, state);
           com_count = 0;
           blink(3, 200);
//            Serial.println("State stored!");  
         }
         if(!isOn) {
           // restore state from NVR
           EEPROM.get(SAVED_STATE_ADDR, state);
           if(!bitRead(state, POWER_BIT))
             state = ALL_ON;
         }
         break;
       default:
//          Serial.println("Not supported");  
         break;   
     }      
   }
   irrecv.resume();
 }
 else {
   com_count = 0;
 }
 if(bitRead(state, POWER_BIT)) {
   switch(prev_command) {
     case KEY_5:
       if(cycle < MAXPINS ) 
         bitWrite(state, cycle, HIGH);
       else
         prev_command = 0;
       break;
     case KEY_6:
       if(cycle < MAXPINS ) 
         bitWrite(state, MAXPINS-cycle-1, HIGH);
       else
         prev_command = 0;
       break;
     case KEY_7:
       if(cycle < MIDPIN + 1 ) {
         bitWrite(state, MIDPIN + cycle, HIGH);
         bitWrite(state, MIDPIN - cycle, HIGH);
       }
       else
         prev_command = 0;
       break;
     case KEY_8:
       if(cycle < MIDPIN + 1) {
         bitWrite(state, cycle, HIGH);
         bitWrite(state, MAXPINS - cycle-1, HIGH);
       }
       else
         prev_command = 0;
       break;
     case KEY_9:
       if(cycle < MAXPINS ) {
         state = ALL_OFF;
         bitWrite(state, cycle, HIGH);
       }
       else{
         state = ALL_ON;
         prev_command = 0;
       }
       break;
     case KEY_FF:
       if(onCount()<MAXPINS) {
         shift(HIGH);
       }
       break;
     case KEY_FB:
       if(onCount()<MAXPINS) {
         shift(LOW);
       }
       break;
     default:
       break;
   }
 }
 if(bitRead(state,POWER_BIT) && (light > max_amblight) && (disp < MAX_DISP)) {
   switchoff();
 } 
 if((!bitRead(state,POWER_BIT)) && (light < min_amblight) && (disp < MAX_DISP)) {
   switchon();
 }
 // Serial.println(state, HEX);
 // Write state to pins
 for(int i=0; i<MAXPINS; i++)
   digitalWrite(STARTPIN+i, bitRead(state, i));
 delay(700);
 if(cycle > MAX_COUNT || !bitRead(state,POWER_BIT))
   cycle = 0;
 else
   cycle++;
 if(!bitRead(state,POWER_BIT)) 
   digitalWrite(FEEDB_PIN, HIGH);
} 

It is pretty much self explanatory - each cycle Arduino is analyzing comments received from IR and enables corresponding lights as necessary. You may have to adapt the sketch for your specific remote as I just took what I had available:

It should be possible to use a universal remote instead, or tailor key codes in the Arduino sketch.

Special functions for automatic switch on/switch off the chandelier based on ambiance illumination can be enabled after pressing FUNC/STOP and then a numeric key (feedback LED will blink 3 times to indicate that the function is activated). Allowed numeric keys are listed below:

1. FUNC/STOP + 0 - disable all and any automatic on/off based on ambience light

2. FUNC/STOP + 1 - current ambiance light will be measured and stored in the non-volatile memory. If the ambiance light is brighter than this stored value then the chandelier will shut down automatically.

3. FUNC/STOP + 4 - disable automatic shutdown based on stored ambiance value

4. FUNC/STOP + 3 - current ambiance light will be measured and stored in the non-volatile memory. If the ambiance light is lower than this stored value then the chandelier will power up automatically.

5. FUNC/STOP + 6 - disable automatic power up

WARNING - the power up/shutdown functions are experimental and may not work properly in your environment and placement of LDR. If you are not getting desired results, try to reset by pressing FUNC/STOP+0 and start over.

That is all. Enjoy! If you liked this project, please give me a star or donate, I'd be really grateful :)