Shelf Lighting Project

In my first post I briefly discussed a bedroom shelf lighting project that I was working on.  I have now completed the programming, wiring and installation of all the electronics that control the lights, so it's time to share some insights with the world.

Shortly after my last post I ran into one final challenge, I fried both the Arudino Uno and the Digispark that I was using.  I never quite figured out how that happened, but I am pretty sure that I put 12V power to the 5V power rail somehow. I used silicone to hold various PCB together to reduce the overall size of the assembly, and I suspect that I was a little bit too conservative between the 12V board that ran the lights and the 5V hub that powered the sensors.  

When I went to fire it up the first time the PIR motion sensor/Photoresistor, night light combination worked properly, but the IR remote system that I just finished, didn't do a thing.  After double checking the wiring, I ripped everything apart again and started to troubleshoot.  

I proceed to un-comment all the Serial.write() commands that I had left in the code, but when I hit the upload button the dreaded avrdude stk500_getsync() not in sync resp=0x00 error flashed up in red in the debug window.  I followed all the instructions that I could find.  Nothing worked.

The Digispark had a similar problem.  The computer/IDE wouldn't recognize it when it was plugged in.  It wouldn't send commands via serial like it did before.  The power LED would turn on, but that's it.

I gave up and loaded the working sketches on to a spare set of micro controllers.  After double checking all the solder joints and testing for connectivity between every possible combination of 12V and 5V leads, I decided it was safe to plug it back in.  Luckily it worked just fine.

Here's the final sketch.

	#include <SoftwareSerial.h>
	SoftwareSerial mySerial(8, 7); // RX, TX
	int remoteOutput = 0;
	int previousOutput = 0;
	int i = 0;
	int pirPin = 4; //digital
	int lightPin = 0; //light sensor pin
	//int switchPin = 13; //switch pin
	int stepTime = 1;
	int hRedPin = 3;
	int hGreenPin = 5;
	int hBluePin = 6;
	int lRedPin = 9;
	int lGreenPin = 10;
	int lBluePin = 11;
	byte red = 0;
	byte green = 0;
	byte blue = 0;
	byte redOffset = 0;
	byte greenOffset = 0;
	byte blueOffset = 0;
	volatile int state = LOW;
	int lastcode = -1;
	boolean onOff = false;
	// light parameters
	long lightRange = 3600000;
	int lightStep = 100;
	int stepDirection = 1;
	long hue = 0; //value in light cycle
	long hueOffset = 0; //value in light cycle
	int offset = 0;
	float brightness = 100;
	float saturation = 100;
	void setup()
	{
	mySerial.begin(9600);
	}
	void loop()
	{
	if (mySerial.available())
	{
	remoteOutput = mySerial.read();
	mySerial.flush();
	}
	switch (remoteOutput)
	{
	case 49: //dimmer
	brightness = constrain(brightness - 2 , 0 , 100);
	break;
	case 50: //on/off
	onOff = !onOff;
	Serial.println("test");
	break;
	case 51://brighter
	brightness = constrain(brightness + 2 , 0, 100);
	break;
	case 52: //Setup returns to default values
	lightStep = 30;
	stepDirection = 1;
	hue= 0; //value in light cycle
	brightness = 100;
	offset = 0;
	break;
	case 53: //cycle faster
	lightStep = constrain(lightStep / 0.8+1, 1 , 10000);
	//Serial.println(lightStep);
	break;
	case 54: //stop or forward
	switch (stepDirection)
	{
	case 1:
	stepDirection = 0;
	break;
	case 0:
	stepDirection = 1;
	break;
	case -1:
	stepDirection = 1;
	break;
	}
	break;
	case 55://move light value down
	hue= hue- lightRange/100;
	if (hue> 0) hue= hue+ lightRange;
	break;
	case 56://undecided
	break;
	case 57://move light value up
	hue= (hue+ lightRange/100) % lightRange;
	break;
	case 97://undecided
	boolean sTest;
	sTest = saturation/100;
	saturation = 100 - (100 * sTest);
	break;
	case 98://cycle slower
	lightStep = constrain(lightStep * 0.8-1, 1 , 10000);
	//Serial.println(lightStep);
	break;
	case 99://stop or reverse
	switch (stepDirection)
	{
	case 1:
	stepDirection = -1;
	break;
	case 0:
	stepDirection = -1;
	break;
	case -1:
	stepDirection = 0;
	break;
	}
	break;
	case 100://undecided
	hue= lightRange/9 * 0;
	break;
	case 101://undecided
	hue= lightRange/9 * 1;
	break;
	case 102://undecided
	hue= lightRange/9 * 2;
	break;
	case 103://undecided
	hue= lightRange/9 * 3;
	break;
	case 104://undecided
	hue= lightRange/9 * 4;
	break;
	case 105://undecided
	hue= lightRange/9 * 5;
	break;
	case 106://undecided
	hue= lightRange/9 * 6;
	break;
	case 107://undecided
	hue= lightRange/9 * 7;
	break;
	case 108://undecided
	hue= lightRange/9 * 8;
	break;
	}
	remoteOutput = -1;
	//on off condition
	if(onOff == 0)
	{
	if(analogRead(lightPin) <= 12 && digitalRead(pirPin) == HIGH)
	{ //was motion detected while it was dark
	nightLight(true);
	delay(5000);
	nightLight(false);
	}
	else
	{
	nightLight(false);
	}
	}
	else
	{
	hue= hue+ lightStep*stepDirection;
	hue= hue% lightRange;
	HSV_to_RGB(hue /10000, saturation, brightness, red, green, blue);
	HSV_to_RGB(hue /10000, saturation, brightness, redOffset, greenOffset, blueOffset);
	analogWrite(hRedPin, red);
	analogWrite(hGreenPin, green);
	analogWrite(hBluePin, blue);
	analogWrite(lRedPin , redOffset);
	analogWrite(lGreenPin, greenOffset);
	analogWrite(lBluePin , blueOffset);
	delay(stepTime);
	}
	}
	void nightLight(boolean lightState)
	{
	byte onState = 100;
	byte offState = 0;
	if (lightState == true)
	{
	analogWrite(hRedPin, onState);
	analogWrite(hGreenPin, onState);
	analogWrite(hBluePin, onState);
	}
	else
	{
	analogWrite(hRedPin, offState);
	analogWrite(hGreenPin, offState);
	analogWrite(hBluePin, offState);
	}
	analogWrite(lRedPin, offState);
	analogWrite(lGreenPin, offState);
	analogWrite(lBluePin, offState);
	}
	void HSV_to_RGB(float h, float s, float v, byte &r, byte &g, byte &b)
	{
	int i;
	float f,p,q,t;
	h = constrain(h, 0.0, 360.0);
	s = constrain(s, 0.0, 100.0);
	v = constrain(v, 0.0, 100.0);
	s /= 100;
	v /= 100;
	if (s == 0) {
	// Achromatic (grey)
	r = g = b = round(v*255);
	return;
	}
	h /= 60.0;
	i = floor(h); // sector 0 to 5
	f = h - (float)i; // factorial part of h
	p = v * (1.0 - s);
	q = v * (1.0 - s * f);
	t = v * (1.0 - s * (1 - f));
	switch(i) {
	case 0:
	r = round(255*v);
	g = round(255*t);
	b = round(255*p);
	break;
	case 1:
	r = round(255*q);
	g = round(255*v);
	b = round(255*p);
	break;
	case 2:
	r = round(255*p);
	g = round(255*v);
	b = round(255*t);
	break;
	case 3:
	r = round(255*p);
	g = round(255*q);
	b = round(255*v);
	break;
	case 4:
	r = round(255*t);
	g = round(255*p);
	b = round(255*v);
	break;
	default: // case 5:
	r = round(255*v);
	g = round(255*p);
	b = round(255*q);
	}
	}

view raw Shelf_Lighting hosted with ❤ by GitHub

Video and pictures to follow tomorrow.

Digispark IR Remote Receiver

Background (skip to solution for the meat and potatoes)

I am working on the last phases of a bedroom shelving project that I started years ago.  The wooden parts of the shelf have been finished for some time, but I am still working on the Arduino controlled lighting system.  The key features of the system are as follows:

• Remote controlled
• Customizable lighting programs (using the HSV color space)  
• Motion sensing night light that only activates if the room is sufficiently dark

The initial prototype took about two days to build and code.  The PIR sensor, photo resistor combination worked well for the night light and I built a simple lighting program to show off to friends.  I ran into problems when I tried to integrate the remote control into the system though.  The interrupt subroutine from the IRremote library wasn't able to reliably decode the signal from the remote when the Arduino Uno was outputing six PWM signals.  Everything worked fine with five PWM signals, but things came to a grinding halt when that sixth analog write was uncommented.

I never really figured out what was causing the problem, but it must be related to how efficiently my code was processed by the 16MHz Atmega microcontrollers, as I tested both the Uno and the Mega.  I loaded the sketch onto my brand new ARM based Arduino Due and everything worked perfectly, but I couldn't justify wasting such a powerful piece of technology on some silly lights.  

Last year I backed the Digispark Kickstarter when I had a plan to use a few of the little chips for a project at work.  The work project fell through when I came up with a better idea, so I had a few spare microprocessors collecting dust in my drawer.  Naturally offloading the "sit and wait for input" task to a separate brain was the answer.

Solution

Figuring out how to use the Digispark was no simple task.  The documentation is rather limited and the simple hurdles like installing the IDE and downloading a program almost broke me due to my hatred of reading manuals.  

Once I had an LED blinking, a quick search brought up a the following web page:

http://www.ediy.com.my/index.php/blog/item/74-digispark-infrared-receiver

It's a very thorough explanation about how to decode NEC IR remotes.  I worked through the examples a few times to fully understand how the code worked.  I ran into one issue with my remote from Abra Electronics (the best Canadian supplier for hobby electronics) the first button output a 0 in the 8-bit command section of the signal, which was ignored later in the program.

I also had to make an addition to the code to handle the NEC repeat signal.  This confused me at first.  I will explain a few things that I learned /made up to justify my perception of the universe, in the process.

First thing, the IR receiver I had, and likely all IR receivers, inverts the IR signal being transmitted by the remote which basically means that we are analyzing the
the gaps in between the pulses instead of the pulses themselves.

This information is useful when trying to catch the repeat bit instead of a normal command.  The difference between the two is that the repeat signal has a 2.5 ms start bit whereas a regular command has a 4.5 ms start bit.  The following two diagrams compare the signal output from the remote control to the signal output from the IR Receiver.

Regular NEC Command and Corresponding IR Receiver Output

NEC Repeat Command and Corresponding IR Receiver Output

For more information about the NEC protocol check out the following site:
http://www.sbprojects.com/knowledge/ir/nec.php

My final Arduino code is shown below.  I used the DigiKeyboard library for trouble shooting the code.  I have commented all of the DigiKeyboard code out as it seems to cause a error when the code is compiled with I am using the latest version of the Digispark IDE (1.0.4) which has the ability to use the standard SoftwareSerial library, common to anyone who has worked with any other Arduino boards.

	//Origional code from http://www.ediy.com.my/index.php/blog/item/74-digispark-infrared-receiver
	//Modified by Daniel Splawski 02/11/2013
	//Uncomment DigiKeyboard statments for debugging
	//#include <DigiKeyboard.h>
	#include <SoftwareSerial.h>
	SoftwareSerial mySerial(0,1); // RX, TX
	int irPin = 2; //Sensor pin connect to digital pin2 (ATINY85 pin7)
	int start_bit = 3000; //Start bit threshold (Microseconds)
	int repeat_bit = 1700; //Repeat bit threshold (Microseconds)
	int bin_1 = 900; //Binary 1 threshold (Microseconds)
	int bin_0 = 400; //Binary 0 threshold (Microseconds)
	const byte BIT_PER_BLOCK = 32;
	String dataString = "";
	void setup()
	{
	pinMode(irPin, INPUT);
	mySerial.begin(9600);
	}
	void loop()
	{
	//DigiKeyboard.update(); // keep updating the keyboard
	//DigiKeyboard.sendKeyStroke(0);
	int key = getIRKey(); //Fetch the key
	if(key >= -1 && key <= 26) //Ignore keys that are outside of range
	{
	switch(key)
	{
	case -1:break; //No change in the dataString so the previous output will be repeated.
	case 0: dataString = "1"; break;
	case 1: dataString = "2"; break;
	case 2: dataString = "3"; break;
	case 4: dataString = "4"; break;
	case 5: dataString = "5"; break;
	case 6: dataString = "6"; break;
	case 8: dataString = "7"; break;
	case 9: dataString = "8"; break;
	case 10: dataString = "9"; break;
	case 12: dataString = "a"; break;
	case 13: dataString = "b"; break;
	case 14: dataString = "c"; break;
	case 16: dataString = "d"; break;
	case 17: dataString = "e"; break;
	case 18: dataString = "f"; break;
	case 20: dataString = "g"; break;
	case 21: dataString = "h"; break;
	case 22: dataString = "i"; break;
	case 24: dataString = "j"; break;
	case 25: dataString = "k"; break;
	case 26: dataString = "l"; break;
	}
	mySerial.println(dataString);
	//DigiKeyboard.println(dataString);
	}
	}
	// decode infrared signal
	int getIRKey() {
	int data[BIT_PER_BLOCK];
	int i;
	int test;
	test = pulseIn(irPin, HIGH);
	if(test > start_bit) //tests for the 4.5 ms start bit
	{
	for(i = 0 ; i < BIT_PER_BLOCK ; i++)
	data[i] = pulseIn(irPin, HIGH); //Start measuring bits, I only want HIGH pulses
	delay(100);
	for(i = 0 ; i < BIT_PER_BLOCK ; i++) //Parse them
	{
	if(data[i] > bin_1) //is it a 1?
	data[i] = 1;
	else if(data[i] > bin_0) //is it a 0?
	data[i] = 0;
	else
	return -2; //Flag the data as invalid; Return -2 on invalid data
	}
	//based on NEC protocol, command data started from bit 16
	//and end with bit 24 (8 bits long)
	int result = 0;
	for(i = 16 ; i < 24; i++) {
	if(data[i] == 1) result |= (1<<i-16); //Convert data bits to integer
	}
	return result; //Return key number
	}
	else if(test > repeat_bit) return -1; //Tests for the 2.5 ms repeat bit and sends -1 if true
	}

view raw Digispark_IR_Receiver hosted with ❤ by GitHub

One thing I might note, Serial.write(key) might eliminate the whole switch-case block.  I didn't happen upon it until after I had soldered up the finished product.  I tried to update the code, but the bootloader decided to quit working and I couldn't figure out how to fix it in 20 min so I gave up.

Here are a couple of schematics of the final project (Fritzing is a beautiful thing).