Raja!

Camera collar

We recently started letting our cat go outside and we started wondering what she actually does out there.  She tends to wander off for an hour or so and we have no idea where she goes or what she is doing.  I borrowed a mini color video camera from Eugene Maker Space and and attached it to my cat’s collar.  I put up a blog post about that a couple weeks ago.  I finally got some longer video uploaded to share.

The aspect ratio is weird because the video camera had to be mounted sideways in order to be securely fastened.  I had to rotate the video after it was uploaded to YouTube.  Also, the date and time are completely wrong because I haven’t figured out how to set them yet.

Bacon roses

I decided to make my girlfriend some bacon roses for Valentine’s day this year.  I wanted to do something different and something she wouldn’t expect.  I had seen this idea on Instructables a few months before and I knew I would have to try it some day.  I did some things a bit differently though and I figured I might as well detail the process I took here.  Most of these photos aren’t very good.  That’s a result of me rushing to get these bacon roses completed before my girlfriend got home from work combined with the fact that my house has terrible lighting for photos.

First off, I had to get a cupcake pan and poke a hole in each spot.  The Instructable recommended using a mini muffin pan but I forgot that when I was at Walmart and I purchased a regular sized cupcake pan instead.

Cupcake tin with holes

The dots in the center of each spot are holes that I poked using a hammer and a large nail. The hole is supposed to allow the bacon grease to drain out of the pan while the bacon is baking.  The Instructable suggesting drilling out the holes, but a commenter suggested using a nail to avoid creating metal shavings that may get into the food.  I liked that idea better and thought it would be easier to pound a few holes in the metal rather than try to drill them out.

Tools

After washing out the pan, I had to prepare the bacon.  I followed the Instructable exactly for this part.  I just rolled up each strip of bacon individually starting at the wider end.  Once I rolled a strip of bacon, I pressed it into one of the muffin spots with the fat side down.  When you press them in the bottom flares out a bit and helps create the rosebud look as well as helps the bacon stand up.

Raw bacon

The Instructable recommended placing a broiling pan underneath the cupcake pan to both allow the grease to drain out and to also catch the grease from falling into the oven.  I don’t have a boiling pan so I used a cookie sheet covered in foil instead.  I then created two large rolls of foil to use as stands to hold the cupcake pan up above the cookie sheet.  Without those, there would be less room underneath the cupcake pan and the grease would have a harder time draining.

Foil sheet with risers

Once the bacon was prepared I stuck them in the oven for 40 minutes at 350 degrees.  While that was cooking, I prepared the rose stems.

I bought the same roses listed in the Instructable.  They cost me $0.97 at Walmart for one “bouquet” of seven roses.  I found them over near the crafts section where they had a selection of fake floral arrangements.  I bought two and ended up cutting off one rose from each bouquet because I only had 12 strips of bacon.

Fake roses

Close up

The first step was to remove all of the rosebuds from the stems.  They slide off pretty easily.

Rosebuds removed

Next I had to take apart each rosebud.  This part was pretty easy to figure out.  It was tougher to take apart but these plastic pieces are pretty strong so I really didn’t have to worry about breaking anything.

Flower pieces separated

Once all of the pieces were separated, I put all of the green pieces back together and stuck the empty rose leaves back onto the stems.

Green pieces reassembled

Here is a shot of all 14 rose stems waiting for the bacon to finish cooking.

Ready for the bacon

After 40 minutes I was worried that the bacon hadn’t cooked enough.  I had a problem where my holes weren’t big enough and the bacon grease didn’t drain.  This seemed to result in the fatty part of the bacon at the bottom of the pan not cooking as much as the top.  Unfortunately Shannon was going to be home in about 10 minutes so I really didn’t have time to cook these any longer.  Also, the tops of the rosebuds were already crispy so I was afraid I would burn them.  Also, about half of the buds fell over while cooking.  I was able to stand most of them back up halfway through but it became clear why a mini cupcake pan would have been a better choice.

Bacon all cooked

Soaking up the grease

Once the bacon rosebuds were dried off and cool enough to hold I just slid them onto the rose stems.  I underestimated how heavy these bacon flowers would be and I really needed some kind of gravel or sand or something in the vase to hold them in place.  I managed without it but it was tricky to move the arrangement around without the stems falling over and the bacon falling off.

Fully assembled

I had a few minutes to spare before Shannon got home so I decided to do a bit extra for the presentation.  I took those otherwise wasted fake roses and chopped all of the petals off into individual petals.  I then scattered a bunch of them around the arrangement so she wouldn’t be able to miss it when she got home from work.

The presentation

She seemed to really like the bacon roses and definitely didn’t expect them.  The bacon ended up being a bit under cooked, especially at the center of the rosebud.  Also, the fat was extra chewy since it wasn’t cooked enough and I tend to like my bacon a bit crispier.  Next time I might try cooking the bacon longer or perhaps on a higher temperature setting.  I’ll also have to make the holes bigger so the grease can drain out more easily.

The soldering iron that came with the kit is a very basic “disposable” type.  I figured it would be a great tool to have at the shop though for whenever we do events like this.  I’d rather have people learn to solder on a junker iron than on a nice expensive one.

Soldering Iron

For the design, my original thought was to just use a block of wood and stick a piece of strong wire into it and bend the wire into a curly shape to hold the iron.  We didn’t have strong enough wire at the shop so I decided to try and make something completely out of wood.  Therefore, my materials consisted of one chunk of 2″x4″ board and some screws.

Materials

I first cut a piece of wood about the length of the iron.  I think cut a second piece of wood that was about 1/2 of the length of the first.  I cut a 45 degree angle into the second piece of wood with the miter saw.

Wood pieces

Then I used the drill press to drill a 5/16″ hole in the shorter piece of wood.  This hole was just big enough for the soldering iron to slide through it and stop where the handle of the iron starts.

Drilling a hole

Hole drilled out

The final step was to attach the two pieces together.  This part was a pain because of the angles.  I didn’t want to use glue because I hate waiting for glue to dry.  I opted to try screwing them together.  There was really no good way for me to clamp the work down to the bench with the tools I had on hand.  Also, I was feeling lazy so I did not pre-drill the holes which made the whole thing more difficult.

Attaching the pieces

The final piece works but since the screws are not countersunk, it is wobbly on the table.  Also, since I didn’t have a good way to hold the pieces together while I was attaching them, there is a small gap between the pieces of wood that looks horrible.  The smaller piece also ended up rotating a bit and is obviously crooked when looking at it in person.

Final piece

The end result was something that works, but not well enough that I am actually going to use it.  In fact, I already threw this thing away.  I wasn’t even going to document this but I figured that 1) it is funny and 2) it’s important to keep track of our failures because we learn more from our failures than we do from our successes.  I learned that I need more practice working with wood and that I need to be less lazy when building things.

Tada!

Makerbot!

I spent some time at Eugene Maker Space’s open house last Friday getting my Makerbot Thing-o-matic up and running.  I had it wokring at home for about a year but I really wanted to get ReplicatorG up and running on one of the shop’s computers so I could leave the bot there for others to use.  Bob spent some time last week getting the latest version of Ubuntu installed on our PC at the shop along with the same version of ReplicatorG that I had been using at home.

I was able to copy my ~/.replicatorg directory off of my home system and onto the EMS system with no problems.  I also copied my thingomatic.xml file from my old system to the new one as well because I had tweaked some settings in there in order to make my prints come out closer to the proper sizes.  With these in place, the Makerbot prints just as well as it did at home.

It definitely needs more fine tuning.  I’m hoping I will find some time next week to spend a few hours at the shop just tuning the Makerbot to get the best prints possible.  Up to this point it has only been me using the thing, so I didn’t mind if things were a bit finicky.  But now that others will be learning to use the bot, I want it to run as smoothly as possible with minimal operator knowledge.  If anyone wants to use the Makerbot at the shop, just shoot me an email and I will find a time to meet with you and teach you how to use it.

For anyone interested, the episode of the show is available on their website as a free MP3 download.

int getRGBValue(int blackColor, int whiteColor, int readColor) {
 //scale the perceived color so it is somewhere between 0 and 255
 int x = map(readColor, blackColor, whiteColor, 0, 255);
 //make sure that X can't ever go above 255 or below 0
 x = constrain(x, 0, 255);

 return x;
}

This is so much simpler.  I had actually used the map function a couple years back but completely forgot about it, and I had never even seen the constrain function before.  This makes the code much more readable and removes some complexity that would be more difficult to debug.  Thank you, Kristof, for the suggestions.

Also, cinezaster left this comment on the Hackaday forums suggesting that I take a general brightness reading of the color I am sensing with white light and use that to further calibrate my sensor.  I didn’t have a white LED but I figured if I just turned on the red, green, and blue leds at the same time it should be close enough.  I took his idea and ran with it.  Here is the latest code.

/*
 ColorSensorWithBrightnessCheck

 This sketch determines the color of an object by flashing a red, green, and blue LED.

 This version "white balances" each color individually like version 2, but this version
 will also check each color with "white" light to see how bright in general the color is.
 That way if it is really bright we can scale things down to see if it will reach bright
 colors better.

 This sketch uses the Adafruit TSL2561 digital luminosity sensor as the light sensor

 By Rick Osgood

 : connect TSL2561 SCL to analog 5
 : connect TSL2561 SDA to analog 4
 : connect VCC to 3.3V DC (MUST NOT BE GREATER HTAN 3.3V!!!)
 : connect GROUND to common ground
 */

#include <Wire.h>
#include "TSL2561.h"
#include "LPD8806.h"
#include "SPI.h"

#define redLed 10
#define greenLed 11
#define blueLed 12
TSL2561 tsl(TSL2561_ADDR_FLOAT);
//for balancing colors to themselves
int redRed = 0;
int greenGreen = 0;
int blueBlue = 0;
//for white balancing
int whiteRed = 0;
int whiteGreen = 0;
int whiteBlue = 0;
int whiteBrightness = 0; // How much light reflected with all leds lit at once
//for black balancing
int blackRed = 0;
int blackGreen = 0;
int blackBlue = 0;
int blackBrightness = 0; // How much light reflected with all leds lit at once

//jsut initializing
int redRead2 = 0;
int greenRead2 = 0;
int blueRead2 = 0;
void setup() {
Serial.begin(9600);
// initialize the digital pins as outputs.
 pinMode(redLed, OUTPUT);
 pinMode(greenLed, OUTPUT);
 pinMode(blueLed, OUTPUT);
// turn off all the outputs by default
 digitalWrite(redLed, LOW);
 digitalWrite(greenLed, LOW);
 digitalWrite(blueLed, LOW);// Collection time. Longer the time, the more light it collects
 tsl.setTiming(TSL2561_INTEGRATIONTIME_13MS);
 // Set gain of sensor
 tsl.setGain(TSL2561_GAIN_16X);
//setup the while and black balancing
 whiteBlackBalance();
}
void loop() {

 //Figure out how bright this color is
 int brightness = readAll();

 //Take a sensor reading of all three colors
 int redRead = readColor(redLed);
 int greenRead = readColor(greenLed);
 int blueRead = readColor(blueLed);

 // Convert color readings to 0-255 RGB values
 if (brightness < 500) {
 redRead2 = getRGBValue(blackRed, redRed, redRead);
 greenRead2 = getRGBValue(blackGreen, greenGreen, greenRead);
 blueRead2 = getRGBValue(blackBlue, blueBlue, blueRead);
 } else {
 redRead2 = getRGBValue(blackRed, whiteRed, redRead);
 greenRead2 = getRGBValue(blackGreen, whiteGreen, greenRead);
 blueRead2 = getRGBValue(blackBlue, whiteBlue, blueRead);
 }
//Output RGB Values
 Serial.print("R: ");
 Serial.println(redRead2);
 Serial.print("G: ");
 Serial.println(greenRead2);
 Serial.print("B:");
 Serial.println(blueRead2);
 Serial.println();
// Serial.print("Brightness: ");
// Serial.println(brightness);
}
//takes a sensed color value (readColor) and returns an int representing the scaled value from 0-255
int getRGBValue(int blackColor, int whiteColor, int readColor) {
 //scale the perceived color so it is somewhere between 0 and 255
 int x = map(readColor, blackColor, whiteColor, 0, 255);
 //make sure that X can't ever go above 255 or below 0
 x = constrain(x, 0, 255);

 return x;
}
void whiteBlackBalance() {
 delay(1000);
 whiteBalance();
 delay(1000);
 colorBalance();
 delay(3000);
 blackBalance();
 delay(1000);
 blackBalance();
 delay(1000);
 blackBalance();
}
// Balance colors to pure white
void whiteBalance() {
 delay(1000);
 whiteBrightness = readAll();
 whiteRed = readColor(redLed);
 delay(2000);
 whiteGreen = readColor(greenLed);
 delay(2000);
 whiteBlue = readColor(blueLed);
 delay(2000);
}
// balance colors to their pure colors
void colorBalance() {
 redRed = readColor(redLed);
 delay(2000);
 greenGreen = readColor(greenLed);
 delay(2000);
 blueBlue = readColor(blueLed);
 delay(2000);
}
// Balance colors to black
void blackBalance() {
 blackBrightness = readAll();
 blackRed = readColor(redLed);
 blackGreen = readColor(greenLed);
 blackBlue = readColor(blueLed);
}
// pass this function the pin number of the led of the color you want to measure
int readColor(int ledPin) {
 digitalWrite(ledPin, HIGH);
 uint16_t x = tsl.getLuminosity(TSL2561_VISIBLE);
 delay(300);
 digitalWrite(ledPin, LOW);
 return x;
}
// Turn on all LEDs ("white" light) and measure the light intensity
int readAll() {
 // Turn on all 3 leds
 digitalWrite(redLed, HIGH);
 digitalWrite(greenLed, HIGH);
 digitalWrite(blueLed, HIGH);
 // sense light levels
 uint16_t x = tsl.getLuminosity(TSL2561_VISIBLE);
 delay(300);
 // turn off all leds
 digitalWrite(redLed, LOW);
 digitalWrite(greenLed, LOW);
 digitalWrite(blueLed, LOW);

 return x;
}

I’m not sure I’m in love with this implementation but it does seem to be more effective.  Now I take a white balance reading against a pure white color for each led.  Then I balance the red, green, and blue to their own respective colors.  I still take a black balance the same way I did before.  Each time I sense a color the sensor first takes a brightness reading.  If that brightness is less than 500 then it uses the “white balance” variables that were balanced to each individual color (redRed, greenGreen, or blueBlue) because those seem to work better for darker colors.  If the brightness is greater than or equal to 500 then the sensor uses the white balance variables that were balanced to an actual white object (whiteRed, etc) because it seems to work better for brighter colors (like light pink).

The value 500 came from some experimentation.  I wrote some test code that would just sense the brightness of a color and output it to my computer.  I noticed that pure white was showing about 900 units of brightness whereas pure red was 178, green was 262, and blue was 336.  Pink showed up at 597.  I noticed that brighter colors tended to be above the 500 unit mark so I chose the number 500 based on that observation.  This may need some tweaking as I try sensing new colors.

This system feels a bit cludgy but it actually does seem to work the best so far.  Here are the results of my testing:

Red: R: 255 G: 59 B: 50
Looks great.

Green: R: 28 G: 255 B: 74
It looks more like lime green on the monitor and a bit darker on paper.

Blue: R: 23 G: 130 B: 255
Very close.  A bit lighter on screen.

Yellow: R: 255 G: 255 B: 79
Looks perfect.

Cyan: R: 24 G: 141 B: 208
This is really close but a bit darker on screen.

Magenta: R: 203 G: 49 B: 129
Looks great.

Pink: R: 255 G: 137 B: 169
This is has a bit more purple in it than the actual paper does but it is very close.

White: R: 255 G: 255 B: 255
Works fine.

Black: R: 0 G: 0 B: 0
Also looks as it should.

Based on these results, this new version of the code works better than any of the old versions.  I still want to try printing out a few lighter colors and some darker colors to make sure the sensor is close enough but I’m pretty confident I will be pleased with the results.  More updates to follow after further testing.

void whiteBlackBalance() {
 delay(1000);
 whiteBalance();
 delay(3000);
 blackBalance();
 delay(1000);
 blackBalance();
 delay(1000);
 blackBalance();
}

void whiteBalance() {
 whiteRed = readColor(redLed);
 delay(2000);
 whiteGreen = readColor(greenLed);
 delay(2000);
 whiteBlue = readColor(blueLed);
 delay(2000);
}

This code just makes a two second delay between the white balancing of each color so I have time to point the sensor at the different colors between readings. I never actually use the color white for balancing with this code. Once I had the code loaded up I calibrated the sensor and tried reading my color chart again. This time the colors were much more accurate. The green and blue are now much more sensitive to colors as I hoped they would be.  Here are the results I got from each color:

Red: R: 255 G: 59 B: 45
While it’s not 255, 255, 255, it looks really close to the actual color and therefore I am happy with the result

Green: R: 28 G: 255 B: 70
This is more of a lime green than the actual color printed on the paper but it’s close enough that I consider it accurate for my purposes for now.

Blue: R: 23 G: 131 B: 251
This should have been a bit darker like a navy blue, but again it’s close enough that it should work for me.

Yellow: R: 255 G: 255 B: 255
This looks dead on now.  It was orange with the previous code but now it looks almost identical to the print out.

Cyan: R: 42 G: 255 B: 255
This color looks a bit lighter than what is printed on the paper but still close enough for now.

Magenta: R: 245 G: 49 B: 130
This isn’t really that close to the 255, 0, 255 that I hoped for but it actually looks surprisingly close to the print out.  So this is a win.

Everything seemed great until I tried reading a sheet of light pink paper. The sensor picked up all colors as being 255, so basically it thought the paper was white. I guess it must be because the paper its such a lighter color than the blue and green colors and therefore is more reflective than colored paper. Pink worked great with the old code but not with the new code. It seems like my new code works great with darker colors but the old code works better with lighter colors. I’m not entirely sure how to fix this problem. I’m wondering if it would help to turn down the brightness of the leds when sending colors. Or perhaps turning down the sensor gain would help. It seems that a pure green color returns less light than white. This is really the source of my problem. I’ll have to think about this for a while and see if I can come up with a workable solution.

I’m also curious if maybe my computer screen is not calibrated properly. So when I plug in the numbers from my readings the screen might be showing me colors that are not actually accurate. I’m not sure how to fix that problem.

Color Sensor

A few years ago I wanted to build a home made color sensor for a project.  I never got it working exactly right and ended up dropping the idea until last December.  I had an idea for a different project that would require a color sensor and after analyzing my last attempt, I thought I might have known what was wrong with my last prototype.  So I started planning.

The basic idea to this color sensor is that you  can represent almost any color if you know how much red, green, and blue is in the color.  The way this sensor will work, is I will have three LEDs.  A red, a green, and a blue LED.  There will also be a light sensor.  The entire thing will need to be surrounded by some kind of dark shield to prevent external light from getting in.  The sensor will be pressed against a colored object and first, the red light will turn on.  The sensor will take a reading.  Then the green light, and then the blue light.  This way I can get readings of how much red, green, and blue light is reflected back to the sensor.  With this information I should be able to roughly determine the color of the object.

When I last tried to build this sensor I tried using a photoresistor but it didn’t seem to work reliably.  I also tried using a light to frequency counter but that didn’t seem to work well either.  After some research I found this digital luminosity sensor on Adafruit’s website.  This sensor can give readings of all light, or only infrared light.  With those two readings you can determine only visible light.  That is what I wanted.  I thought maybe the other sensors were also reading infrared light and skewing my color values the last time I tried this, so this sensor might give better results.  I also decided to buy the super bright red, green, and blue LED’s from Adafruit as well since they have similar brightness ratings.  The green and red are both rated at 8000 mcd typical brightness and the blue is rated at 6000 mcd.

Red LEDs
Green LEDs
Blue LEDs

Once I knew what LEDs I was going to use I could figure out what size resistors I would need.  I found an online resistor calculator that made it simple to figure out what size resistors I would need to power the LEDs at close to their maximum brightness.

Once all the components arrived, I soldered them all to a small round prototyping board I bought at RadioShack.

Prototype board

I put some heat shrink tubing on each of the LEDs.  The idea is that the tubing will prevent any of the LED light from reaching the sensor directly form the LED.  It forces the light to bounce off of the colored object first.

Under side of the board

Each LED has its corresponding resistor attached to its anode.  The other side of each resistor will have a wire attached that will eventually plug into digital IO pins on the Arduino.  The cathode side of the LEDs all get tied to each other and to the ground pin of the sensor module.  The sensor module is just soldered into the board.  It will have a wire attached to each pin.

Next I decided to figure out what I would use for an enclosure for this board.  I thought back to the last time I tried this and I had the old board taped inside of a black ABS fitting. I think that maybe the tape was too loose and the sensor could have wiggled around inside of the housing.  If that was the case, it would explain why it would fall out of calibration sometimes when I moved it.  I knew that I had to avoid that problem this time.  Now that I have my own 3D printer, I decided to design a custom enclosure for this board.  The enclosure will fit the board nice and snug, and also have screw holes so I can mount the board inside securely.  It should also prevent outside light from reaching the sensor, and have a hole in the back so the sensor wires can leave the enclosure and attach to the Arduino.

3D Printed enclosure

That’s what I came up with.  There are standoffs printed on the inside to hold the board up about halfway inside of the enclosure.  Two of the standoffs have screw holes so I can mount the board in place.

Board mounted inside the enclosure

Next I attached the wires for the LEDs and for the sensor.  I separated out the LED wires from the sensor wires so it would be easier to figure out which wire was which later one.

Wires attached

Next I hooked up the LED wires and the ground wire to the Arduino board so I could figure out which wire went to which LED.  I also needed to test and ensure that the LEDs functioned properly.  I ran some test code to cycle through flashing each LED.

Red LED

Green LED

Blue LED

All of the LEDs worked.  I labeled each of the wires so they would be easy to reconnect later on.  Next I had to hook up all of the sensor wires and get the sensor working.  I used the sample code that came with the Adafruit Arduino library for this sensor.  Once I had the wires going to the right Arduino pins, it worked fine.

Sensor fully connected

The rest of this project was really just code, test, repeat.  After much trial and error, I finally got this sensor working pretty well.  I will paste my color sensor code below and then explain how it works afterwards.

#include <Wire.h>
#include "TSL2561.h"
#include "LPD8806.h"
#include "SPI.h"

/*
ColorSensor
This sketch determines the color of an object by flashing a red, green, and blue LED.

This sketch uses the Adafruit TSL2561 digital luminosity sensor as the light sensor

By Rick Osgood

: connect TSL2561 SCL to analog 5
: connect TSL2561 SDA to analog 4
: connect VCC to 3.3V DC (MUST NOT BE GREATER THAN 3.3V!!!)
: connect GROUND to common ground
*/

#define redLed 10
#define greenLed 11
#define blueLed 12

TSL2561 tsl(TSL2561_ADDR_FLOAT);

//for white balancing
int whiteRed = 0;
int whiteGreen = 0;
int whiteBlue = 0;
//for black balancing
int blackRed = 0;
int blackGreen = 0;
int blackBlue = 0;

void setup() {
Serial.begin(9600);

// initialize the digital pins as outputs.
pinMode(redLed, OUTPUT);
pinMode(greenLed, OUTPUT);
pinMode(blueLed, OUTPUT);

// turn off all the outputs by default
digitalWrite(redLed, LOW);
digitalWrite(greenLed, LOW);
digitalWrite(blueLed, LOW);

// Collection time. Longer the time, the more light it collects
tsl.setTiming(TSL2561_INTEGRATIONTIME_13MS);
// Set gain of sensor
tsl.setGain(TSL2561_GAIN_16X);

//setup the while and black balancing
whiteBlackBalance();
}

void loop() {
//Take a sensor reading of all three colors
int redRead = readColor(redLed);
int greenRead = readColor(greenLed);
int blueRead = readColor(blueLed);

// Convert color readings to 0-255 RGB values
int redRead2 = getRGBValue(blackRed, whiteRed, redRead);
int greenRead2 = getRGBValue(blackGreen, whiteGreen, greenRead);
int blueRead2 = getRGBValue(blackBlue, whiteBlue, blueRead);

//Output RGB Values
Serial.print("R: ");
Serial.println(redRead2);
Serial.print("G: ");
Serial.println(greenRead2);
Serial.print("B:");
Serial.println(blueRead2);
Serial.println();

}

//takes a sensed color value (readColor) and returns an int representing the scaled value from 0-255
int getRGBValue(int blackColor, int whiteColor, int readColor) {
//since the black balance might not be zero, we subtract the black value to shift the range so it starts at 0
int maxColor = whiteColor - blackColor;
long x = readColor - blackColor;
x = x * 255;
x = x / maxColor;

if (x < 0) {
x = 0;
}
else if (x > 255) {
x = 255;
}

return x;
}

void whiteBlackBalance() {
delay(1000);
whiteBalance();
delay(1000);
whiteBalance();
delay(1000);
whiteBalance();
delay(3000);
blackBalance();
delay(1000);
blackBalance();
delay(1000);
blackBalance();
}

void whiteBalance() {
whiteRed = readColor(redLed);
whiteGreen = readColor(greenLed);
whiteBlue = readColor(blueLed);
}

void blackBalance() {
blackRed = readColor(redLed);
blackGreen = readColor(greenLed);
blackBlue = readColor(blueLed);
}

// pass this function the pin number of the led of the color you want to measure
int readColor(int ledPin) {
digitalWrite(ledPin, HIGH);
uint16_t x = tsl.getLuminosity(TSL2561_VISIBLE);
delay(300);
digitalWrite(ledPin, LOW);
return x;
}

This sensor only works if it calibrates itself to known black and white values.  The sensor first goes through a white and black balancing process.  It first takes three readings of “white”.  While this is happening, you have to press the sensor against something white and preferably non glossy.  It takes three readings because I noticed that it seems to “settle” into a more accurate reading after a few readings of the same color.  Then it pauses three seconds and takes three readings of a black object.

These values get stored in the blackRed, whiteRed, etc variables.  When it takes a reading of another color after calibration, it uses those black and white balancing variables to figure out where in the spectrum between black and white the values reside.  The getRGBValue function takes care of this:

int maxColor = whiteColor - blackColor;
long x = readColor - blackColor;
x = x * 255;
x = x / maxColor;

It first shifts the scale of minimum color to maximum color.  For example, lets say the blackRed reading is 50 and the whiteRed reading is 500.  This means that when the sensor reads a black object, it will still read 50 units of red.  No object should show less than that because black is the darkest it should get.  White will always show about 500 units and no other object (other than true red) should show 500 units of red because white is the brightest it should ever get.  We need to shift the scale from 50 – 500 so it starts at zero.  So the function first subtracts 50 (blackColor) from the whiteColor variable and also from the readColor variable. (readColor is how much of that color was just sensed on an object).

Next, I wanted to scale the sensed value so it was between 0 and 255.  This would make it easy for me to plug into a computer paint program to see if the RGB values were correct. So the software takes the perceived value (now shifted down) and multiplies it by 255 and then divides it by the maxColor variable (whiteColor scaled down).  It really is difficult to explain this in words.  It makes much more sense if you just plug in sample values and see how the math works out.

The main loop of the program just takes the red, green, and blue readings, converts them to RGB values and then prints them out via the serial port:

//Output RGB Values
Serial.print("R: ");
Serial.println(redRead2);
Serial.print("G: ");
Serial.println(greenRead2);
Serial.print("B:");
Serial.println(blueRead2);
Serial.println();

I can just open up the Arduino serial terminal to view the RGB values.  It spits the values out about every 500 milliseconds.  Once I calibrate the sensor to black and white, I can just hold it up to any object and it gives me the RGB values between 0 and 255.  I then take those values and plug them into MS Paint’s “custom colors” tool to see what color those values actually are.

I printed out this color chart below so I could see how well the color sensor works.  I put the RGB values on each square for documentation purposes but they were not actually printed on the sheet of paper.

Color chart

And here are the results:

Red: R: 209 G: 22 B: 20
Red looked really good.  It wasn’t as bright as I expected but the color matched pretty closely.

Green: R: 22 G: 98 B: 31
Green looked alright but it was a bit dark.

Blue: R: 22 G: 50 B: 114
Blue was also pretty close but a bit darker than the real image.

Yellow: R: 239 G: 156 B: 34
This is the worst so far.  It comes out more like a light orange.  For some reason the green is not as sensitive as it needs to be.

Cyan: R: 22 G: 135 B: 197
This one is kind of close, but there’s a bit too much blue and not enough green

Magenta: R: 201 G: 17 B: 57
This is not very accurate.  It shows up as a dark red.  There is not enough blue in it to look like magenta.

I would say this first test was a success.  The sensor definitely works but the colors are not all quite right.  The red sensor seems to be working fine, but the blue and especially the green are not sensitive enough.  I would expect that when I sense a 100% green color, the green sensor would sense somewhere over the 200 value for green.  But it doesn’t.  I wonder if the White balance is just too bright.  Perhaps if I balance the red green and blue separately rather than just using white I would get more accurate readings.  Time to tweak my code and find out!

Check Signing Machine

I was able to procure some old check signing devices yesterday.  I’m not entirely sure how these devices work, but it appears that they hook up between a computer and a laser printer.  Somehow they tell the printer how to print signatures on checks I guess.  I was not interested in the intended functions of this device.  I noticed it had two key switches and a nice 4×40 character LCD display.  It also had various switches and plugs that I thought may be useful.  After talking with Kevin at work, I decided it would be awesome if I could turn this device into a rocket control station for my air rocket launcher.  I could use the key switches as arming and launch switches and I could use the LCD screen to display a count down or launch codes or something.  The device also has a ps/2 port on the back so it’s possible I might be able to hook that up to an Arduino to accept keyboard input so it requires you to type in launch codes before it will launch.

I brought one of these machines down to the shop for our open house night last night and tore it apart.

Back side

Ports

Bottom

I started out by opening the small hatch on the bottom of the device.

Hatch opened

Inside is a large eeprom chip and three sets of DIP switches.  I have covered the eeprom in blue tape because it had a label that identified the company this device was being used by before I got a hold of it.  Next I removed the entire bottom panel.

Bottom removed

On the right side there is a really large plug that wasn’t attached to anything.  I wonder if it was used for programming or debugging or something.  It might also be used for an extra peripheral or perhaps for a more advanced model of this same machine.  Here you can also see the two key switches on the bottom left of the image and the LCD board towards the bottom of the image.

Some identifying information

Connection points and LCD board

Switch and LCD connections

Main board removed

After I removed the main board, I decided to remove the key switches.

10 position key switch

10 position key switch serial numbers

8 Position key switch

8 Position switch serial numbers

Once the key switches were removed and documented I went for the LCD.

LCD Board

The upper left side of the board has the model number of the LCD module.  It appears to be a Powertip PC4004A-P1 A model LCD.

LCD Model Number

Now that I had the key switches and the LCD module, I decided to put the rest of the unit back together.  Those were the primary components I wanted to remove so that I could try to interface them with an Arduino.

Reassembled

Next I decided to try and interface with the LCD module.  I did some Googling for the model number of the LCD and Arduino and hit the jackpot pretty much right away.  I found this forum thread where someone was trying to interface this exact same LCD module with an Arduino.  They linked to the datasheet, figured out the pinouts and pasted sample code all in that thread.  It looked like the LCD ran on 5 Volts so I should be in business.

Here is a copy of his sample code he provided in the forum post in case the forum is ever unavailable.  The sample code requires the LiquidCrystal440 library which can be found here. Pinouts are in the comments at the top of the code.  His pinouts include backlight pins but my LCD does not appear to have a backlight.

// WH4004A Test Program: WinStar 40x4 LCD
// using Enhanced LiquidCrystal440.h
// Since the pinouts are different from Forum sample 40x4 LCDs
// Available nkcelectronics.com. Data sheet WH4004A-YYH-JT.pdf
// To adjust contrast, 10K pot between GND and +5V, wiper W to lcd 12
// LCD Func Arduino Desc pins               Dan Magorian 10/19/2010
// 1    DB7  12    Data bus line
// 2    DB6  11    Data bus line
// 3    DB5  10    Data bus line
// 4    DB4   9    Data bus line
// 5    DB3        Data bus line
// 6    DB2        Data bus line
// 7    DB1        Data bus line
// 8    DB0        Data bus line
// 9    E1   4     Chip enable signal, lcd lines 1 & 2
// 10   RW   3     H: Read L: Write
// 11   RS   2     H: DATA, L: Instruction code
// 12   V0   W     Contrast, gnd = full, too dark
// 13   VSS GND    Ground for logic
// 14   VDD +5V    Supply Voltage for logic
// 15   E2   5     Chip enable signal, lcd lines 3 & 4
// 16    NC
// 17    LED+      Ext +5V Supply for fluor LED+ optional turn fluor on
// 18    LED-      Ext GND Supply for fluor LED- optional turn fluor on
//
// If char blocks show black but nothing prints, adjust contrast pot,
// and check lcd pins 13 and 14: display may not be initialized.  
// If alternate blocks and blank lines show, then neither of the controllers
// is properly initialized, check RW, E1, E2, or any of the connections

#include <LiquidCrystal440.h>
// LiquidCrystal lcd(rs,rw,enable1,enable2,d4,d5,d6,d7);
// Note: some Forum examples using LiquidCrystal440.h have wrong DB pins,
// eg DB0-DB3, or in wrong order.  The top 4 work, in this order.

LiquidCrystal lcd(2, 3, 4, 5, 9, 10, 11, 12);
void setup(){
  lcd.begin (40, 4);
  lcd.clear();
    for (int j=18; j<129; j++) {
      lcd.write(j);
  } // print English chars in rom lower 4 bits, upper 4 bits Japanese
}
void loop() {}

Once I had the sample code and pinouts, it was obvious I had to try to wire up the LCD according to his pinouts and give this a try.

First attempt

My first attempt didn’t work so well.  I chopped off one end of the ribbon cable so that I could splice out the individual wires.  I thought that if I spliced them apart and stripped each one, I could just stick the wire into the proper Arduino port.  Well the wires were actually thin stranded wire, not solid core as I thought so that didn’t work out.

I realized that if I had not chopped off the plug to the ribbon cable, I could have just stuck some jumper wires in the end of it and jumped them over to the Arduino board.  I ended up opening a second check signing machine so I could steal its unaltered ribbon cable.

Jumper wires

It took me a while to get the LCD hooked up properly.  It was really easy to plug wires into the wrong ports.  When I finally thought I had it plugged in properly and had the code running on the Arduino, it seemed at first like the LCD wasn’t working properly.  When I moved certain wires around, the screen would light up with underlines or garbled characters but nothing that made me think it was working properly.  Finally I took a closer look and noticed that there were in fact letters being printed on the LCD screen.  They were just so faint that I could barely see them.  It was really hard to get a photo of this, but if you look really closely at the image below, you can make out some of the faded letters.

Faint letters

I tried messing around with the contrast pin a bit and nothing I did seemed to work to fix this problem.  All the wires seemed to be plugged into the right place.  Finally, I thought that maybe the LCD wasn’t getting enough power.  I had the LCD VCC pin going to the Arduino’s VCC pin, so it should have been getting 5 Volts.  Maybe it wasn’t getting enough current?

If I remember correctly, the VIN pin just takes the raw power from your power supply and pipes it through.  So if you plug in a 12 Volt 2 Amp power supply, you will see 12 Volts on that pin and be able to draw up to 2 Amps.  The VCC pin is 5 Volts of power that gets regulated by circuitry on the Arduino board.  So even if you plug in a 12 Volt power supply, you will only see 5 Volts on that pin.  I thought that maybe the VCC pin was limiting the current to the LCD and preventing it from lighting up properly.  Since my Arduino power supply was 5 Volts as well, I decided to just plug the LCD into the VIN pin on the Arduino.

LCD fully functioning

That obviously did the trick.  Now I know that I can successfully interface these LCD modules to an Arduino.  I should be able to use this in my air rocket launch control project. Next I will have to test out those key switches to make sure they function the way I expect them too.  Expect more updates once I test out those other components and start more detailed planning out the launcher project.

Mystery Box

A little over a week ago Shannon and I went to Portland to see the Mythbusters tour.  We stayed overnight and the next day we went to check out OMSI.  I bought the catapult kit while I was there and finally was able to put it together on Sunday after we completed the mystery box.  It works surprisingly well.

Catapult ready to fire

Catapult up close

Finally, Shannon and I recently started letting our cat outside and we thought it would be really fun to find a way to attach a camera to her so we could see what she does out there.  I remembered that we had a tiny video camera at the shop for our nearspace project that we weren’t using yet.  This camera takes a micro SD card and has a built in rechargeable battery.  The entire package is very small and very light so I figured it would be perfect.  I brought it home and started trying to design a 3d printable bracket to hold the camera onto my cat’s collar.  Then I realized there might be an easier way and I just zip tied it on.

Camera collar

Raja!

Another cat picture for good measure

The zip ties worked really well.  My cat didn’t seem to be bothered by the camera at first, although after a little while she started trying to bite at it.  I only have footage of her roaming around the inside of the house for now because it was dark out when I tested this. I will probably have to wait until the weekend to let her out during the day since that’s the only time I’m home while the sun is still up.  If I get any good video I’ll put it up here.  I also have a small wireless camera that I would like to try this with.  It would be really fun to get live video from the cat but I need to find a 9V battery small enough that it won’t weigh her down.