Jim Wink's Make Blog

Atiny85

2011-10-16T21:03:00.000-07:00

A while back I ordered an Attiny 2313 from Adafruit. Along with it I ordered a USBtinyISP to program it. For whatever reason I could never get the thing working.

The process involved downloading AVRDude, WinAVR, and various steps of setup. After getting everything installed & following the instructions carefully, I still couldn't get it to work. I did submit some questions on Adafruit's forum & got some answers, but I suspect the problem was either I'd made a mistake in assembling the USBtinyISP or just my general lack of understanding of what was going on. It was also possible I'd wrecked the chip, so I gave up after a while.

Later I decided it might have been better to take myself out of the equation, so again I ordered another programmer and some chips, this time from Sparkfun: a Pocket AVR programmer, another Attiny 2313 and an Attiny85. So far I've not gotten around to trying out their AVR programmer & until recently the chips stayed in their wrapping.

Recently I ran across an article from MIT outlining how to program the Attiny85 with an Arduino. I'd heard about people doing this before, but never really looked into it. After reading this article, though, it seemed easy. So I tried it.

It worked, though there was one item of confusion from the article. It said I'd need a capacitor between the reset and the ground on the Arduino, but only if I was using an Uno. Not something I'd need on the Duemilanova. Not true. I could not get the thing working right until I dropped a capacitor between the two. It said I'd need a 10 uf capacitor, but since I wasn't sure what exactly I had I just tried something. Worked fine.

The article started me off with the basic blink out of the Arduino examples. Instead of using pin 13 you use 0:

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.
 
  This example code is in the public domain.
 */

void setup() {                
  // initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  pinMode(0, OUTPUT);     
}

void loop() {
  digitalWrite(0, HIGH);   // set the LED on
  delay(1000);              // wait for a second
  digitalWrite(0, LOW);    // set the LED off
  delay(1000);              // wait for a second
}

I'd recorded a video of this but won't post it here because, well, blink? Boring.

What I wanted to do with this instead was Morse code. I'd remembered an idea a friend of mine had about building a simple Christmas tree ornament with something like this. Something that blinks "Happy Holidays" or some such in Morse code. Not only would it be an opportunity to program something other than an Arduino, but also an excuse to maybe silk screen and etch a circuit board. You know, something that looks like a tree? Or a radio tower?

A (very) quick search on Google revealed a simple Java Morse code translator. A little reading after that revealed International Morse code would probably best with a Farnsworth speed of 20 words per minute. My timings are probably off by more than a bit on this as I was using a watch and some guesswork. But here's code that'd get the LED to blink "Happy Halloween" in Morse code:

/*
 * Morse Test 1
 * Blinks an LED in Morse code.
 */

void setup() 
{
  // initialize the digital pin as an output
  pinMode(0, OUTPUT);     
}

void loop() 
{
  dit();  // H
  dit();
  dit();
  dit();
 
  dit();  // A
  dah();
 
  dit();  // P
  dah();
  dah();
  dit();
 
  dit();  // P
  dah();
  dah();
  dit();
 
  dah();  // Y
  dit();
  dah();
  dah();
 
  space();
  space();
  
  dit();  // H
  dit();
  dit();
  dit();
 
  dit();  // A
  dah();
 
  dit();  // L
  dah();
  dit();
  dit();
 
  dit();  // L
  dah();
  dit();
  dit();
 
  dah();  // O
  dah();
  dah();
 
  dit();  // W
  dah();
  dah();
 
  dit();  // E
  
  dit();  // E
  
  dah();  // N
  dit();

  space();
  space();
  space();
  space();
}

void dah()
{
  digitalWrite(0, HIGH);
  delay(375);
  digitalWrite(0, LOW);
  delay(125);
}

void dit()
{
  digitalWrite(0, HIGH);
  delay(125);
  digitalWrite(0, LOW);
  delay(125);
}

void space()
{
  delay(500);
}

And here's a video of that in case: a) anyone's watching, and b) they care to attempt to translate what I coded.

Here's another video with another message which I'll leave as a mystery for someone to figure out. The message actually plays twice since as I recorded it I didn't catch the first message end separation (about 2 seconds) and turn off the camera in time. So I just let it run through the message again as it repeated. Might have been easier to just put the message in the setup method instead of the loop.

I should also point out the reason I like this so much is because I can use the Arduino IDE to do all the work. No coding in C or using programmers or command line code. It is much easier. I'm hoping (have not checked) that I can program an Attiny 2313 this way as well. I have also seen some articles outlining how to build a shield to handle this, though I'd probably create one for the 45/85 and another for the 2313.

Now that I've got this much figured out I may take this a step further & see if I can etch a circuit board for this. It'd also be cool to include some voltage handling to keep the power to something reliable and then get voltage from a light string directly. Kind of like ornaments you can get from Hallmark or wherever that plug right into the string & are lit. Might be cool.

Though if I am smart I should probably also include a switch that either turns the LED off or leaves it on all the time as the intermittent blinking might get on people's nerves after a while...

Persistence of Vision (PoV)

2010-12-19T12:04:00.000-08:00

Because it was quick and because I wasn't getting much done on other projects, I decided to look into Persistence of Vision (PoV).

PoV was fairly simple to set up with the RBBB. I put the RBBB in a breadboard, ran a patch to the ground rail and added in five blue LEDs. I started with a sketch of my own that sort of worked, but not well.

So I figured I'd have more luck looking on the Arduino playground. There I clicked on Interfacing with Hardware and searched on PoV. There I found a link to an art icle written in German by someone named Michael Zoellner. I didn't understand the German but the sketch that was linked had comments in English. I made some tweaks to the code to allow for adjustments and ran it.

It worked fairly well so I updated the setup so I didn't have to run it off of the USB cable & added battery power. This made it easier to hold it in my hand and wave it in front of a camera. I set up a camera on a tripod, lowered the ISO to 100 and turned down the lights. The camera is only a small point and shoot, so it didn't have much for time exposure settings. It did have a "long exposure" night setting, which I assume sets the F stop lower.

I used the 2 second timer and then just started waving my PoV setup in front of the camera with one hand furiously. This generally didn't catch anything or the letters were reversed. Some of the shots came out okay though.

I did have to try the basic "Hello World", but couldn't get a shot much better than this. There's probably a lot of work that could be done to this set up with either some tweaks to the timing or to flip the letters when waved one way or the other. To do that I'd probably need to add an accelerometer to determine which way the swing is moving. At this stage, more work than it's worth.

Here's another shot with me attempting to show the entire alphabet. Some of the letters - like the W - aren't well formed. Another thing that might help the legibility a bit would be to have more than 3 vertical lines.

As usual, here is the source code. I've left the header comments mostly as they were to give credit to the original writer, Michael Zoellner, but I've added in a few more comments with "JTW" to indicate some changes of my own.


/*
¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡
persistence of vision typography with arduino
michael zoellner - march 2006
http://i.document.m05.de

connect anodes (+) of 5 leds to digital ports of the arduino board
and put 20-50 ohm resistors from the cathode (-) to ground.

the letters are lookup tables consisting arrays width the dot status in y rows.
¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡
*/

// JTW: pins running LEDs - added this as an array so I could change pins or positions
// int pins[] = { 2, 3, 4, 5, 6 };
int pins[] = { 6, 5, 4, 3, 2 };
// JTW: inverted pins so I could hold it upside down 

// defining the alphabet
int _[] = {0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0};
int A[] = {0,1,1,1,1, 1,0,1,0,0, 0,1,1,1,1};
int B[] = {1,1,1,1,1, 1,0,1,0,1, 0,1,0,1,0};
int C[] = {0,1,1,1,0, 1,0,0,0,1, 1,0,0,0,1};
int D[] = {1,1,1,1,1, 1,0,0,0,1, 0,1,1,1,0};
int E[] = {1,1,1,1,1, 1,0,1,0,1, 1,0,1,0,1};
int F[] = {1,1,1,1,1, 1,0,1,0,0, 1,0,1,0,0};
int G[] = {0,1,1,1,0, 1,0,1,0,1, 0,0,1,1,0};
int H[] = {1,1,1,1,1, 0,0,1,0,0, 1,1,1,1,1};
int I[] = {0,0,0,0,1, 1,0,1,1,1, 0,0,0,0,1};
int J[] = {1,0,0,0,0, 1,0,0,0,1, 1,1,1,1,1};
int K[] = {1,1,1,1,1, 0,0,1,0,0, 0,1,0,1,1};
int L[] = {1,1,1,1,1, 0,0,0,0,1, 0,0,0,0,1};
int M[] = {1,1,1,1,1, 0,1,1,0,0, 0,1,1,1,1};
int N[] = {1,1,1,1,1, 1,0,0,0,0, 0,1,1,1,1};
int O[] = {0,1,1,1,0, 1,0,0,0,1, 0,1,1,1,0};
int P[] = {1,1,1,1,1, 1,0,1,0,0, 0,1,0,0,0};
int Q[] = {0,1,1,1,1, 1,0,0,1,1, 0,1,1,1,1};
int R[] = {1,1,1,1,1, 1,0,1,0,0, 0,1,0,1,1};
int S[] = {0,1,0,0,1, 1,0,1,0,1, 1,0,0,1,0};
int T[] = {1,0,0,0,0, 1,1,1,1,1, 1,0,0,0,0};
int U[] = {1,1,1,1,1, 0,0,0,0,1, 1,1,1,1,1};
int V[] = {1,1,1,1,0, 0,0,0,0,1, 1,1,1,1,0};
int W[] = {1,1,1,1,0, 0,0,1,1,0, 1,1,1,1,0};
int X[] = {1,1,0,1,1, 0,0,1,0,0, 1,1,0,1,1};
int Y[] = {1,1,0,0,0, 0,0,1,0,0, 1,1,1,1,1};
int Z[] = {1,0,0,1,1, 1,0,1,0,1, 1,1,0,0,1};

// defining the time dots appear (ms)
int dotTime = 3;  

// defining the space between the letters (ms)
int letterSpace = 6;

/*
 * Run once method - set up pins
 */
void setup()
{
  // setting the ports of the leds to OUTPUT
  for (int y = 0; y < 5; y++) { pinMode(pins[y], OUTPUT); }
}


/*
 * Continual running method
 */
void loop()
{
  // printing some letters
  printLetter(H);
  printLetter(E);
  printLetter(L);
  printLetter(L);
  printLetter(O);
  printLetter(_);
  printLetter(W);
  printLetter(O);
  printLetter(R);
  printLetter(L);
  printLetter(D);
  printLetter(_);
}


/*
 * Show a passed in letter array 
 * JTW: altered slightly to use pin array
 */
void printLetter(int letter[])
{ 
  // printing the first y row of the letter
  for (int y = 0; y < 5; y++) { digitalWrite(pins[y], letter[y]); }
  delay(dotTime);
  
  // printing the second y row of the letter
  for (int y = 0; y < 5; y++) { digitalWrite(pins[y], letter[y + 5]); }
  delay(dotTime);
  
  // printing the third y row of the letter
  for (int y = 0; y < 5; y++) { digitalWrite(pins[y], letter[y + 10]); }
  delay(dotTime);
  
  // printing the sspace between the letters
  for (int y = 0; y < 5; y++) { digitalWrite(pins[y], 0); }
  delay(letterSpace);
}

New 'duinos

2010-09-21T20:46:00.000-07:00

I haven't posted in a while. I have still been busy tinkering, but for one reason or another haven't gotten around to posting. I have made some progress on my design for a color fading juggling ball, and have started some other projects, but I think I will save them for another post. Instead, I'll say a word or two about some new purchases.

When I built the web cam pan this summer, I sent with it my one and only Arduino. It was an older one with an Atmega 168 and 16 k of memory so I was looking to upgrade. Prior to sending it off, I first bought an Arduino Pro Mini 5.5v / 328 from Sparkfun. I also had to get an FTDI breakout board for it as it doesn't have on-board USB communications.

Man, that thing is tiny! It's about the size two postage stamps! Pictured here is what it looks like after putting pins all over it so I can snap it into a breadboard.

I did learn one thing with it - solder carefully. The picture you see here is actually my second Pro Mini. With the first I had put straight male headers facing up - and then later decided I didn't like them, so I tried to remove them with an iron and de-solder gun. I got the right angle header on only to learn it wouldn't communicate any more. It still ran the last script I had on it, but that's not a lot of good. So I ordered another and hung my head in shame.

Not long after that I decided I needed a screw-shield for my project, so I used the opportunity to get another Duemilanova. It's pretty much the same deal as the other but with twice the processor speed and twice the memory.

It also has a nifty sticker up in the corner indicating Italy or some such.

Once I was done with the web cam pan and had sent it up north I started looking into next projects. The Pro Mini I decided would be dedicated to my lighted juggling ball project. The Duemilanova would have to run the motor-shield for my plotter project.

That left no spares for just messing around, so I ordered a "Really Bare Bones Board" from Modern Device. At $12.50, this is has to be the cheapest Arduino out there. I ordered the kit (of course) so I could assemble it myself. Like the Pro Mini, it doesn't have an FTDI/USB chip on it, so you need a converter - which I already had purchased for the Pro-mini and could use with this one.

I like this board. It plugs directly into a bread board and is actually slightly more narrow than the Pro Mini, freeing up one more row of slots on the board. It is, of course, also an Atmega 328, so its faster and has more memory.

It is, however, very long. If I were to use this in a juggling ball, the ball would probably end up rather big. You can chop it down to almost the length of the chip itself as long as you are willing to provide very clean power to the thing.

A big juggling ball is not impossible for a good juggler, but I do, for some reason, have a desire for a fairly compact ball. We'll see what I end up with. The RBBB is definitely in the running for the main unit anyway because of it's price. If I want to make 3 of these - and possibly more later if this works out - then I'll want the cheapest components I can get. And that means RBBB. If I order 5 they're only $10.50!

Though I do fear this will mean I have to learn to solder an accelerometer "surface mount" chip directly. Sparkfun has one for $7.95, but a quick spin through Digikey reveals some cheaper options.

I do have a photo of this one, really. I didn't have at the time of writing this, though. I also have a video of a little test jig I worked up, but have that either. I'll add them both at a later time.

Web Cam Pan

2010-07-28T23:00:00.001-07:00

Here is a photo of a project I started a while back. I took an old Logitech web camera we had sitting around, removed it from it's case and sandwiched it between two small sheets of Acryllic. My reasoning here is it would be easier to attach that to a servo than the weird sphere casing it was originally in. Really, I think it just looks cooler that way.

The servo is bolted to - well through - a plank I had in the garage. I think it's left over from building the deck. A plank, yes. Probably green-treat or some such. If I could've figured out a way to get duct tap on it, I probably would have.

Anyway, behind the web camera is an Arduino Duemilanova (168) - the original/first one I got. It's connected with some simple wood screws through the board.

Underneath all this, on the other side of the plank is a Power Switch Tail.
This nifty little device is a bit like a really short extension cord with a switch. Regular 120 volt house current goes in one end and comes out the other. Except when it doesn't. Wired to the tail are two wires - 5 volts and ground to the Arduino. Inside the tail is a relay. When 5 volts go through the two wires, 120 volts can pass through the main part of the tail. When 5 volts aren't going hrough the tail, no 120 volts.

The Arduino is running a simple sketch. It receives commands from a PC to do one of two things: turn on and off the tail, and move the servo. On the PC is a .NET/C# WinForm app that does a number of things:

- Turns on and off a preview of what the web camera is looking at
- Via the Arduino, turns on and off the tail
- Also via the Arduino, moves the servo (and also the web ca
mera) left and right
- Takes snapshots of whatever the web camera is looking at

What's the point of all this you ask? Well, at my parent's cabin in northern Wisconsin is an internet connection. On that connection is a router instructed to route remote desktop requests to a PC running Windows XP pro. With this setup connected - and I connect to that PC via Remote Desktop - I can turn on a light an look around.

What do I want to look at? Well, in this case, the utility room. This is where the water heater, furnace, floor drain, and other odds and ends are. We wanted to be able to look in this room where things could break down - freeze in the winter, or flood, or whatever,
when no one is physically there. Now we can.

Here is a photo of the setup as installed in the room. We drilled a hole through the side of the board and then screwed it into one of the bare studs in the room. It is just leaning on the UPS and cords hanging from the bottom of it. The camera is deliberately pointed at the floor where flooding or water leakage is likely to occur.

We had to hang it close to the PC so the Arduino and web camera could be connected directly to the PC. That spot, however, isn't the most ideal in the room. I think for version 2 I might consider a second Arduino communicating to the first via wireless (Xbee?) or some other form of communication.

The downside of this setup is while it works great in the local network, it's fairly slow over the internet. The DSL at the cabin isn't the fastest, and previewing images through the remote desktop connection isn't the best.

I am using Avicap32.dll through .NET and C#. This wasn't the most intuitive and easy to use methods, but it got the job done. I may update the code to have a "manual" mode that snaps a photo and posts it to the preview screen whenever something changes: light on/off, or panning.

I will post code here eventually. I had installed the thing on July 4th and had just never gotten around to posting anything about it until now.

One other thing I will mention: this has been done before. There are probably commercial products out there to do what I did for nearly as cheap. The reason I started doing this was, well, why I do any of this: because I wanted to see if it was possible.

I did also want to see how cheaply I could do it. I tried to use parts I already had sunk money into long ago and weren't currently in use for anything else. The web cam is one of many I have gathering dust on my shelf. These days they are smaller than that and cheap, but using this one required no extra cost.

The servo was an extra from an RC car kit my dad gave me for my birthday a while back. The kit came with two, one for controlling steering of the front wheels and the second for handling speed control. Except the kit also came with a control board that did electronic speed control, so the second servo was not needed. After this project was done, I did break down and buy another one just like it from a local hobby store. You never know when you'll need one, right?

The Arduino wasn't gathering dust - it was my only one until I started this project. I had, however, been wanting an updated one with an Atmega 328 chip instead of the 168. So I got another full Duemilanova as well as a mini from Sparkfun.

The Power Switch Tail wasn't sitting around. I had to order it and it cost a bout $15 bucks. A bit more than I really wanted to spent, but I wanted something sealed and well tested. I could have built something - there are plenty of instructions on how to do so on the web - but when you're dealing with full house current, I really didn't want to mess around. I'd rather not burn down the cabin.

The plank, well, I have stacks of wood left over from when we built the deck in, what, 2002? Expect more planks in future projects.

The code I wrote myself. As usual. But with lots of help from many excellent people on the web.

Steppers and the Motor Shield

2010-04-25T20:09:00.000-07:00

Axman Surplus is awesome.

I've been thinking of building a CNC. There are a number of articles on the web that'll walk you through building a CNC, including this one on how to build a desktop CNC. That one, in particular, could use a tool I already have - a Dremel.

Anyway, a CNC is complicated. There's a whole language used for communicating with CNC's called g-code, that is pretty much a complete mystery to me. Then there's taking 3-d models and converting them to g-code, and probably any number of details I don't have figured out.

It'd be a bigger project than I've tackled so far. But like anything, I've got to start somewhere, so I figured I'd start with equipment I already have. In this case I'm referring to the Motor Shield I got from Adafruit. I built it a while back and then set it aside and never used it. So I figured this was a good time.

I'd already figured out how to run a servo on the Arduino, but the Motor Shield has pins set aside to do this. It used to have a specific library too, but it looks like the folks at Arduino came up with their own. Anyway, using the example in Layada's tutorial worked right away, no troubles.

The real power in a CNC are the stepper motors. These are specialized motors that can spin in very small, descrete movements in either directions. Two steppers set opposite each over can control X and Y axis. A third stepper - or a servo - can control up an down.

I really don't understand how servo motors work, but I sort of don't need to. I hook it up and tell it where to go in code. With steppers, though - it's sort of different. Different steppers hook up different ways. There are unipolar and bipolar, 5-lead, 6-lead, and 8-lead. How you hook it up - even to something like the Motor Shield, which goes out of it's way to make it easier on you - makes a difference.

So needed to get some stepper motors. I could have ordered some online, but that'd mean waiting a bit and possibly paying more than I really want. Instead, I called the good folks at Axman surplus and asked them whether they sold stepper motors. They said they did and had a selection. Beyond that they couldn't say anything about what kind of steppers they had. Not surprising if you've ever been to Axman. It's a unique experience.

My friend Chad was up from Rochester for the weekend so I dragged him and my son over to the Axman in St. Paul off of University Avenue. After 30 minutes or so of just wandering the aisles - a process the cannot be avoided in such a place - we made it to area where all the motors were. There I found quite a few stepper motors, including some very similar to what is suggested on Adafruit's site: an Airpax C82290-M2. It's a 5 volt, 7.5 degree stepper motor - again, very similar to the examples. I bought 3.

The trick with these steppers is that they have 8 wires - more than the examples in the tutorial. The eight wires came in pairs: two red, two black, two yellow, and two grey. I tried first by tying together the pairs an hooking them up to the shield. Running the code didn't have the results I'd expected - the motor just shifted clock-wise and counter.

So followed some links suggested by the tutorial and eventually ran into one that talked about how to reverse engineer the purpose of the wires. And this link is pretty much the whole reason I posted today. It helped me figure how that the two red and two gray wires can be joined and then the black and yellow's mixed. I hooked these up to the motor shield and ran the example code as was. And now that link is here in the cloud for the next stepper I can't figure out.

Eventually I hope to create a simple plotter with all this. Probably a fixed pen or pencil over a moving platform that'll hold a sheet of paper. I'm not sure whether this little steppers are powerful enough for that, but I'll find out soon enough.

That's all I've got for now. No code since anything I used is available in the tutorial. More, hopefully, as I continue building something.

Still on XYZ and RGB

2010-03-06T18:01:00.000-08:00

It should come as no surprise that I am still somewhat obsessed with my accelerometer. I've stated earlier that I'd like to create a lighted juggling ball that changes color as it rotates. This should be a simple task with an accelerometer - three axis, three colors, mix 'em and you're done, right? Maybe not so much.

I won't rehash previous posts, but I will say I am really close. I should, however, explain my criteria:

Rotation should change color of the light, obviously
At a minimum, there should be shifting between the 3 basic colors: red, green, blue
I'd prefer 6 colors total, with the other 3 being mixes: yellow (red/green), aqua (green/blue), and purple (blue/red)
I'd like to get some nice fading as it switches between colors, but as I'll point out later, this is somewhat hard
The light intensity should never change - all on, and never off
I'd prefer it if there wasn't much white - all colors on - showing

I already have code on the Arduino that'll produce 6 distinct colors. Based on the above criteria, I've succeeded. I've wired up the prototyping shield, the accelerometer, an RBG LED, and a seven segment display. The last is so I can display the digit of the color currently showing.

That setup (shown left) is seriously prototype. It's nothing I'd really use in an actual juggling ball. It's too big, it only has one LED, I probably wouldn't include the 7-seg display - but it helped me understand what I was up against.

It was a bit of a stretch to come up with the 6 basic colors out of 3 axis. Here's how I did it:

The accelerometer produces values from 0 to 692 (roughly)
There are 3 values coming from the X, Y, and Z axis
To get 6 distinct numbers I split each axis down the middle and then checked which side of middle it was on
If the value was lower than the mid-point it was one number, if higher than the mid-point it was another number
Two colors were assigned to each axis, and as such only one color could show at a time, again if less than mid-point one color, higher, another color
For example, the X axis lower than 346 is red, higher than that its aqua
At any given time the position of the three axis indicates 3 numbers and colors at once - to pick only one, we take the highest of the three
The axis values are split in half so they are from 0 to 346 and altered so they always increase the more the accelerometer is leaned in a particular direction, i.e. from 0 to 346 is actually flipped so at the zero value we'd be returning 346 and vice versa as we approach middle. From 346 to 692 we just subtract 346.
These "half" values are shoved into an array and bubble sorted so we know which one is highest. The array is multidimensional and also contains the index we assigned to that number. When we know which value is highest, we also know which index is highest.
Since we know which color is assigned to that index, we show that color.

The code in this situation might make more sense than that explanation. As usual you will find that code at the bottom of the post. Before that, though, I have a few more things to mention.

One is another notion I introduced with this code: smoothing. The values that come streaming out of the accelerometer are... not consistent. The sort of jump all over the place. If you were to watch the values on the serial output you'd see something like this:

373, 349, 536

372, 348, 532

371, 347, 548

378, 355, 554

372, 352, 539

365, 346, 531

371, 351, 542

371, 348, 541

371, 352, 544

374, 352, 544

And so on...

The first value is X, the second Y, and the third Z. X and Y are roughly middle, i.e. there's little pulling them one way or another. Z is pointing down, so it's higher than the other two. At it's current setting the accelerometer is measuring 1.5 g's, so at rest the Z values is somewhere lower than it's max. I'd have to shake it a bit to see it hit 692.

I started trying to figure out how fast the Arduino could sample the output of the accelerometer and between running at 16 mhz and returning those values out of serial at 9600 baud I gave up. It's pretty fast - there's a lot of sampling going on each second. And as you can see above, there's a lot of variation going on in a really short period of time.

That variation is not due to vibration. I'm not sure whether it's noise on the analog inputs (likely) or inaccuracy on the accelerometer (possible) or something else I don't know (also likely). Whatever the case, it's annoying and it causes the light of the LED to blink between colors when it's at a boundary between them.

So I figured out smoothing. What this is basically is shoving the values coming off the accelerometer into an array and then taking the average of a set of values (like 30) and using that value instead. It worked fairly well, though if I made the array too large it had some interesting effects.

I actually went back to some old .NET code I'd written in April of '09 (that post here) to test it. The app was designed to that just the X and Y and paint dots on a screen. Without smoothing the dots scatter and draw something that looks a bit like spray paint. With the smoothing it draws something closer to lines.

It was actually kind of pretty and fun to play with. I updated the app to use the Z axis to determine color. I ended up spending a lot of time with the kids playing with it. If I ever get into wireless I may consider creating a hardware interface that's a bit more user friendly that my current rig. I'm not sure how practical it'd be as a drawing interface, but still - fun to play with.

So I had smoothing. What I didn't have was fading between the 6 colors. I spent some time trying to figure this out on the Arduino, but this was frustrating at best. There's no debugger and using Serial.println has it's limits. So I took that job into .NET and wrote a simple Arduino sketch that'd just dump out to serial the values it fetches from the Accelerometer.

What I came up with was what you see in this video:

Before I move on I want to mention the software I used to get that video: CamStudio. It's got a free version that does well getting the basic AVI I have above.

The video starts out with me selecting read. From that point onward it's taking values in from the Arduino and doing the following:

Showing them on the sliders that depict the full range of 0 to 692
Splitting the values in half and showing the top 3
Showing the dominant color on a visual representation of three axis split
Showing the RGB value it came up with, both in numbers and in color

The mixing is achieved by determining how close the second and third picks are to the first. The first pick is always the dominant color, but if the second pick is within a certain percentage (as determined by the tolerance slider - usually 30%) then how large that second pick is in relation to the first will determine how much of that color bleeds into the primary color. The same calculation is used with the third pick in relation to the first.

Once I got all that sorted out it worked really well. In the video I am rolling the unit one way slowly, then the other, and finally all over the place quickly. It's fairly responsive and kind of cool to watch.

It was this idea, how this mixing worked, that had me wondering whether I'd post anything about any of this. I have scoured the web on several occasions looking for whether anyone else has figured this out. I've found little or no examples. Where I did find examples either they made no sense to me, or they didn't have enough information. When I eventually did come up with a solution - and I'm not saying this is the best/only way of doing this - I honestly didn't want to share it. Partially because no one else did and I felt a little like I wanted to hold onto this secret, but also partially because I'm not sure whether I want to build and sell juggling balls (or other products) using this technology.

Eventually - and obviously - I gave in and posted everything. What I came up with isn't really all that complicated or hard to figure out, though it did take me a while. I also feel like I need to pay some of this forward. I've gotten so many other good ideas and just raw reference - how to - from the inter-toobz that I think I should put some quasi-useful stuff out there myself. This is one of the reasons why I almost ALWAYS post code - and put lots of comments in said code.

Anyway, as usual, I'm not going to post all the .NET code here, though. It's fairly big and I'm feeling somewhat lazy at this point. The core of what you'd need to see is in the MainForm.cs, which is posted below:


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Data;
using System.Drawing;
using System.IO.Ports;
using System.Text;
using System.Windows.Forms;

namespace XYZtoRGB_PointFade
{
public partial class MainForm : Form
{
#region Members

// full length of each axis
private const int conMax = 692;

// mid point of the axis
private const int conMid = 346;

// points picked - can only be 3 of 6 at a time
private int[,] picks = { { 0, 0 }, { 0, 0 }, { 0, 0 } };

// blue, red, violet, green, yellow, aqua
private int[,] colors = {
   { 255, 255, 0 },
   { 255, 0, 0 },
   { 0, 255, 0 },
   { 0, 255, 255 },
   { 255, 0, 255 },
   { 0, 0, 255 }
   };

// the serial port we'll read from
private SerialPort arduino = null;

// read from the serial input - by default, don't
private bool readSerial = false;

// places to put port and rate
string comPort = string.Empty;
int baudRate = 0;

// smoothing arrays
int[] xList = new int[50];
int[] yList = new int[50];
int[] zList = new int[50];

// watch values of the smooth loops
int wsx = 0, wsy = 0, wsz = 0;

#endregion Members

#region Events

public MainForm()
{
   InitializeComponent();
}

private void MainForm_Load(object sender, EventArgs e)
{
   // init our smoothing arrays?
   for (int i = 0; i < comport =" ConfigurationManager.AppSettings[" baudrate =" int.Parse(ConfigurationManager.AppSettings[" text =" tbSmoothing.Value" text =" tbTolerance.Value" readserial =" false;" text = "Read" readserial =" true;" text = "Stop">
/// What to do when one or all of the axis are changed,
/// namely update the color displayed.
///
private void AxisUpdate()
{
   // fetch and display the axis values
   txtXaxis.Text = tbXaxis.Value + "";
   txtYaxis.Text = tbYaxis.Value + "";
   txtZaxis.Text = tbZaxis.Value + "";

   // mix these values into colors
   MixPicks(tbXaxis.Value, tbYaxis.Value, tbZaxis.Value);

   // then draw the map
   DrawAxisMap();
}


/// 
/// More complicated color computation based on three
/// points of dominance, ranked in order
/// 

///
///
///
private void MixPicks(int xVal, int yVal, int zVal)
{
   FindPicks(xVal, yVal, zVal);

   //txtPoint1.Text = picks[0, 0] + "";
   txtStep1.Text = picks[0, 1] + "";

   //txtPoint2.Text = picks[1, 0] + "";
   txtStep2.Text = picks[1, 1] + "";

   //txtPoint3.Text = picks[2, 0] + "";
   txtStep3.Text = picks[2, 1] + "";

   // an array to hold the chosen color
   int[] choice = { 0, 0, 0 };
   int idx = picks[0, 0];

   // set the primary color
   choice[0] = colors[idx, 0];
   choice[1] = colors[idx, 1];
   choice[2] = colors[idx, 2];

   if (tbTolerance.Value < perf =" ((float)tbTolerance.Value" per2 =" ((float)picks[1," per3 =" ((float)picks[2,"> perF)
       {
           idx = picks[1, 0];
           choice[0] = AdjustColor(choice[0], colors[idx, 0], per2);
           choice[1] = AdjustColor(choice[1], colors[idx, 1], per2);
           choice[2] = AdjustColor(choice[2], colors[idx, 2], per2);
       }

       // if color 3 is above tolerance
       if (per3 > perF)
       {
           idx = picks[2, 0];
           choice[0] = AdjustColor(choice[0], colors[idx, 0], per3);
           choice[1] = AdjustColor(choice[1], colors[idx, 1], per3);
           choice[2] = AdjustColor(choice[2], colors[idx, 2], per3);
       }
   }

   ShowColor(choice[0], choice[1], choice[2]);
}


/// 
/// More compact method that returns a multidimensional
/// array of the accelerometer values along with the points
/// they represent.
/// 

///
///
///
/// 
private void FindPicks(int xVal, int yVal, int zVal)
{
   // supporting cast
   int pnt = 0, val = 0;

   // clear the text boxes
   //txtXplus.Text = "0";
   //txtXminus.Text = "0";
   //txtYplus.Text = "0";
   //txtYminus.Text = "0";
   //txtZplus.Text = "0";
   //txtZminus.Text = "0";

   // blue, red, violet, green, yellow, aqua

   // x plus/minus or red/green
   if (xVal < text =" picks[0,"> conMax) { xVal = conMax; }
       picks[0, 1] = xVal - conMid;
       //txtXminus.Text = picks[0, 1] + "";
   }

   // y plus/minus or violet/yellow
   if (yVal < text =" picks[1,"> conMax) { yVal = conMax; }
       picks[1, 1] = yVal - conMid;
       //txtYminus.Text = picks[1, 1] + "";
   }

   // z plus/minus or aqua/blue
   if (zVal < text =" picks[2,"> conMax) { zVal = conMax; }
       picks[2, 1] = zVal - conMid;
       //txtZminus.Text = picks[2, 1] + "";
   }

   int limit = 2;

   do
   {
       int last = 0;

       for (int i = 0; i < j =" i" pnt =" picks[i," val =" picks[i," last =" i;" limit =" last;"> 0);
}


/// 
/// Separate method to make the determination of whether to
/// use a new possible color or to keep the current color.
///
/// This is core to the whole method because it allows us to
/// first put in a core color and then later to introduce seconday
/// and tertiary colors if they do not over power the dominant
/// color.
/// 

///
///
///
/// 
private static int AdjustColor(int current, int possible, float percent)
{
   // reduce the possible color by the given percent
   int test = (int)(possible * percent);

   // default our adjusted color to the current
   int adjusted = current;

   // if the test color is larger, use it
   if (test > adjusted) { adjusted = test; }

   // return the adjusted color
   return adjusted;
}


/// 
/// Display RGB value to view panel
/// 

///
///
///
private void ShowColor(int rVal, int gVal, int bVal)
{
   // first show the numeric values in text boxes
   txtRed.Text = rVal + "";
   txtGreen.Text = gVal + "";
   txtBlue.Text = bVal + "";

   // then set the color
   pnlColor.BackColor = Color.FromArgb(rVal, gVal, bVal);
}


///
/// Does the work of fetching serial data from the Arduino
/// and displaying it - in various ways - to the form.
///
private void ReadArduino()
{
   // working variables
   char[] delim = { ',' };
   string line = "";
   string[] axis = null;
   int tmpX = -1, tmpY = -1, tmpZ = -1;
   int count = 0;

   // if we haven't already connected
   if (arduino == null)
   {
       // connect to the Arduino
       arduino = new SerialPort(comPort, baudRate);
       arduino.ReadTimeout = 5000;
       arduino.WriteTimeout = 5000;
       arduino.Open();
   }

   // while flagged to read
   while (readSerial)
   {
       count++;

       // fetch one line of serial data from the Arduino
       line = arduino.ReadLine();

       // remove the return at the end of the line
       if (line.LastIndexOf("\r") > -1)
       {
           line = line.Substring(0, line.Length - 1);
       }

       // if there was nothing read, just skip this iteration
       if (string.IsNullOrEmpty(line.Trim())) { continue; }

       // implicit else - split the line to an array of strings
       axis = line.Split(delim);

       // if we got an array
       if (axis != null && axis.Length == 3)
       {
           // if we can't parse the values, set them low
           if (!int.TryParse(axis[0], out tmpX)) { tmpX = -1; }
           if (!int.TryParse(axis[1], out tmpY)) { tmpY = -1; }
           if (!int.TryParse(axis[2], out tmpZ)) { tmpZ = -1; }

           // if values are good, smooth them
           if (tmpX > -1) { tmpX = SmoothVal(tmpX, ref wsx, xList); }
           if (tmpY > -1) { tmpY = SmoothVal(tmpY, ref wsy, yList); }
           if (tmpZ > -1) { tmpZ = SmoothVal(tmpZ, ref wsz, zList); }

           // finally try and set the value
           tbXaxis.Value = (tmpX > conMax) ? conMax : tmpX;
           tbYaxis.Value = (tmpY > conMax) ? conMax : tmpY;
           tbZaxis.Value = (tmpZ > conMax) ? conMax : tmpZ;

           AxisUpdate();
       }

       // pump the windows message loop
       Application.DoEvents();
   }
}


/// 
/// Chucks a value into one of the lists and then
/// sends back out the caller an averaged value.
/// 

///
/// 
private int SmoothVal(int value, ref int ws, int[] axList)
{
   int smax = tbSmoothing.Value;
   int avg = 0;

   // if no smoothing, return what ya got
   if (smax <= 0) { return value; }              // add to our watch index             ws++;              // shift index back to zero if greater than smoothing limit             if (ws >= smax) { ws = 0; }

   // put it in the array
   axList[ws] = value;

   // next, get the average
   for (int i = 0; i < value =" ((int)avg" value =" (value"> conMax) ? conMax : value;

   // return the average
   return value;
}


/// 
/// Draw the axis map with emphasis on given axis that are
/// currently influencing the colors
/// 

private void DrawAxisMap()
{
   // clear what was there first
   Graphics gfx = pbAxisMap.CreateGraphics();
   gfx.Clear(Color.DimGray);
   gfx.Dispose();

   // get some numbers
   int w = pbAxisMap.Width;
   int h = pbAxisMap.Height;
   int cx = ((int)w / 2);
   int cy = ((int)h / 2);

   // blue, red, violet, green, yellow, aqua

   // draw the lines
   DrawLine(0, PickWidth(0), cx, cy, cx, h);
   DrawLine(1, PickWidth(1), cx, cy, 0, cy + cy / 2);
   DrawLine(2, PickWidth(2), cx, cy, w, cy + cy / 2);
   DrawLine(3, PickWidth(3), cx, cy, w, cy / 2);
   DrawLine(4, PickWidth(4), cx, cy, 0, cy / 2);
   DrawLine(5, PickWidth(5), cx, cy, cx, 0);
}


/// 
/// Picks the width of a given color line.
/// 

///
/// 
private int PickWidth(int idx)
{
   int g = 1;

   if (idx == picks[0, 0]) { g = 9; }
   else if (idx == picks[1, 0]) { g = 6; }
   else if (idx == picks[2, 0]) { g = 3; }

   return g;
}


/// 
/// Draw a single line of a given color
/// 

///
///
///
///
///
///
private void DrawLine(int idx, int girth, int x1, int y1, int x2, int y2)
{
   Color color = Color.FromArgb(colors[idx,0], colors[idx, 1], colors[idx, 2]);
   Point point1 = new Point(x1, y1);
   Point point2 = new Point(x2, y2);
   Pen pen = new Pen(color, girth);
   Graphics gfx = pbAxisMap.CreateGraphics();

   gfx.DrawLine(pen, point1, point2);

   pen.Dispose();
   gfx.Dispose();
}

#endregion Supporting
}
}

Once I got this working SO well in .NET I thought it'd be a cinch to get it working the same in the Arduino, right? Not so much. The language is MUCH simpler and has less to support what I wanted to do. I tried in .NET to use simple concepts and "do the work" where I should. For example I sorted the top 3 values myself using a bubble sort instead of just calling the "sort" on a collection.

What I got in the Arduino sort of worked, but not nearly as well. Here's a video I hope will help explain what I mean:

It's not smooth like the .NET app. For that matter there's not really much distinct "mid" color at all. It's like there's one middle color between the two major colors. I do have a BlinkM somewhere that I should really consider trying before I dismantle this whole thing. It may simplify the handling of colors, but it does have one considerable drawback - it's expensive. The RGB LED's cost about $2, and the BlinkM was $12.

I fiddled with this set up for a bit before deciding to post. It's close, but I'm kind of out of patience for it at this stage. My first juggle-able prototype will probably be just the 6 basic colors. This is easy to achieve and, to be honest, when juggling no one is going to notice the lack of fades as much. Here's a similar video with no fading:

I think for my first "throwable" prototype I'll just stick with the basic 6 colors. I intend to get a Really Bare Bones Board kit from Modern Device for this. It's small and really cheap. If I eventually figure out fading and I think I've got something like a real product on my hands I may consider creating a custom PCB that puts the accelerometer and the smaller form-factor ATmega328 directly on board along with LEDs. Possible a circular PCB that could be bolted directly into a ball, though some shock absorption of some sort may be in order.

Now that I've got this project in the cloud and off my chest, as it were, I can move on to another idea. I want to use the Arduino, a web cam, and a servo along with (yet another) custom .NET app to create a panning web cam app. I'll probably point it at my fish tank for now, but this is something I have a practical application for - watching the utility room at my folk's cabin. More on that later...


/*
* PointFade3.pde
*
* Third versiom of fading colors between 6 points
* of the accelerometer cross. This should be a
* conversion of the .NET code that I'd got working.
*/

// axis analog pins
int xPin = 0, yPin = 1, zPin = 2;

// axis value mid and max
int axMax = 692, axMid = 346;

// pins controlling red/green/blue
int rPin = 3, gPin = 6, bPin = 5;

// values from those pins
int xVal = 0, yVal = 0, zVal = 0;

// smoothing
int xLst[50], yLst[50], zLst[50];
int sTrk = 0, sMax = 10;
boolean full = false;

// array to store top 3 picks
int picks[][3] = {{ 0, 0 }, { 0, 0 }, { 0, 0 }};

// array to store positions and values of colors
int colors[][6] = {
{ 102, 163, 0 },
{ 102, 0, 0 },
{ 0, 163, 0 },
{ 0, 163, 163 },
{ 102, 0, 163 },
{ 0, 0, 163 }
};

// tolerance - or how much fade
float tol = 1.00;

// maximum PWM allowed for each LED
int rMax = 102, gMax = 163, bMax = 163;

// power for the 7-segment LED
int segPow = 11;

// establish an array for our LED pins
int segLed[7] = { 4, 7, 8, 9, 10, 12, 13 };

// array to store settings for numbers
int numbers[][11] = {
{ LOW,  LOW,  LOW,  LOW,  HIGH, LOW,  LOW  }, // 0
{ LOW,  LOW,  HIGH, HIGH, HIGH, HIGH, HIGH }, // 1
{ HIGH, LOW,  LOW,  HIGH, LOW,  LOW,  LOW  }, // 2
{ LOW,  LOW,  LOW,  HIGH, LOW,  LOW,  HIGH }, // 3
{ LOW,  LOW,  HIGH, LOW,  LOW,  HIGH, HIGH }, // 4
{ LOW,  HIGH, LOW,  LOW,  LOW,  LOW,  HIGH }, // 5
{ LOW,  HIGH, LOW,  LOW,  LOW,  LOW,  LOW  }, // 6
{ LOW,  LOW,  LOW,  HIGH, HIGH, HIGH, HIGH }, // 7
{ LOW,  LOW,  LOW,  LOW,  LOW,  LOW,  LOW  }, // 8
{ LOW,  LOW,  LOW,  LOW,  LOW,  HIGH, HIGH }, // 9
{ HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH }  // off
};


/*
* The "run once" setup method
*/
void setup()
{
// set up to communication with serial
Serial.begin(9600);

// set axis/analog pins to input
pinMode(xPin, INPUT);
pinMode(yPin, INPUT);
pinMode(zPin, INPUT);

// turn on power for the 7-segment display
analogWrite(segPow, 102);

// initialize all 7 segment LED pins
for (int idx = 0; idx < xval =" getListVal(xLst);" yval =" getListVal(yLst);" zval =" getListVal(zLst);" xrv =" analogRead(xPin);" yrv =" analogRead(yPin);" zrv =" analogRead(zPin);" strk =" sTrk">= sMax)
{
// reset to beginning
sTrk = 0;

// and track that we've filled the arrays at least once
full = true;
}
}


/*
* Get a smoothed value from given array
*/
int getListVal(int aLst[50])
{
int idx = 0;
long sum = 0;

for (idx = 0; idx < idx =" idx" sum =" sum" ret =" sum" pnt =" 0," val =" 0;"> axMax) { xVal = axMax; }
picks[0][1] = xVal - axMid;
}

// y plus/minus
if (yVal <> axMax) { yVal = axMax; }
picks[1][1] = yVal - axMid;
}

// z plus/minus
if (zVal <> axMax) { zVal = axMax; }
picks[2][1] = zVal - axMid;
}

// now sort 'em

int limit = 2;

do
{
int last = 0;

for (int i = 0; i < j =" i" pnt =" picks[i][0];" val =" picks[i][1];" last =" i;" limit =" last;"> 0);

//showPicks(picks[0][0], picks[0][1],
//picks[1][0], picks[1][1], picks[2][0], picks[2][1]);
}


/*
* We should have our top 3 colors. Now
* we need to mix them in relation to each
* other based on the tolerance.
*/
void MixColors()
{
// create an array to hold the chosen color
int choice[3] = { 0, 0, 0 };

// get the percentages of the other two colors
float per2 = ((float)picks[1][1] / (float)picks[0][1]);
float per3 = ((float)picks[2][1] / (float)picks[0][1]);

// find the primary index
int idx = picks[0][0];

// show the number on the 7-segment
showDigit(idx);

// set the primary color
choice[0] = colors[idx][0];
choice[1] = colors[idx][1];
choice[2] = colors[idx][2];

//showChoice(idx, choice[0], choice[1], choice[2]);

// if we set a usable tolerance
if (tol <> tol)
{
//Serial.println("In per2 adjust");
int i2 = picks[1][0];
if (colors[i2][0] > 0) { choice[0] = AdjustColor(choice[0], colors[i2][0], per2); }
if (colors[i2][1] > 0) { choice[1] = AdjustColor(choice[1], colors[i2][1], per2); }
if (colors[i2][2] > 0) { choice[2] = AdjustColor(choice[2], colors[i2][2], per2); }
}

// if color 3 is above tolerance
if (per3 > tol)
{
int i3 = picks[2][0];
if (colors[i3][0] > 0) { choice[0] = AdjustColor(choice[0], colors[i3][0], per3); }
if (colors[i3][1] > 0) { choice[1] = AdjustColor(choice[1], colors[i3][1], per3); }
if (colors[i3][2] > 0) { choice[2] = AdjustColor(choice[2], colors[i3][2], per3); }
}
}

// show the color on the RGB LEDs
ShowColor(choice[0], choice[1], choice[2]);
}


/*
* A separate method dedicated to making the determination of whether
* to use a new possible color or to keep the current color. This is
* the core to color mixing because it allows us to first put in a
* core color and then alter to introduce secondary and tertiary colors
* if they do not overpower the dominant color.
*/
int AdjustColor(int current, int possible, float percent)
{
// default our adjusted color to the current
int adjusted = current;

// if the percent and possible are useful
if (possible > 0 && percent  > 0)
{
// reduce the possible color by the given percent
int test = possible * percent;

// if the test color is larger, use it
if (test > adjusted) { adjusted = test; }

/*
Serial.print("Adjust - curr: ");
Serial.print(current);
Serial.print(", poss: ");
Serial.print(possible, DEC);
Serial.print(", perc: ");
Serial.print(percent, 4);
Serial.print(", test: ");
Serial.print(test, DEC);
Serial.println("");
*/
}
else
{
Serial.println("POSSIBLE IS ZERO!!");
}

// return the adjusted color
return adjusted;
}


/*
* Finally, after all that, light 'em.
*/
void ShowColor(float rPer, float gPer, float bPer)
{
//showAxis(rPer, gPer, bPer);

// calulate percentages lit
int rVal = rMax * rPer;
int gVal = gMax * gPer;
int bVal = bMax * bPer;

// light the LEDs to these percents
analogWrite(rPin, rVal);
analogWrite(gPin, gVal);
analogWrite(bPin, bVal);
}


/*
* Given specific number pluck out that
* row in the multi-dimensional array to
* show that combination of LOW/HIGH vals
*/
void showDigit(int digit)
{
// loop through LED pins
for (int idx = 0; idx <>

Amusing error messages

2009-12-11T13:14:00.000-08:00

So far in this blog I have not posted at all about what I do for a living. I've only posted about one of my many hobbies. But today I ran into something I wanted to share. I could go on and on about how I could share it (Facebook, Yammer, emails to hapless co-workers, emails to hapless friends, drone on and on to my wife about it) but I won't. Much.

Instead, I'll post it here. Here where it can quietly sit where few, if any, will see it. But I can always go back and get a chuckle about it.

Anyway, what I do for a living is write software. I am a software engineer. I've created software in a number of different languages: Pascal, COBOL, C++, Visual Basic, Java, C# - probably others I am forgetting - and I've been doing it for over 17 years now. Strange, but true.

This blog is about stuff I make. Software is stuff I make, right? Okay, boring stuff I make - I'll try and keep it to a minimum.

Anyway, I'm currently contracting at a company that uses Oracle (10g?) as it's primary database server. The current task I am working on involves creating a seed script to load some values in a database. Seed scripts are an easy way around creating an intelligent user interface to do the same thing. It's what I typically do when I am told not to spend too much time working on a task.

The seed script will load a series of values into the database representing the types of pages users can hit on a particular site. The goal is to eventually create a report that shows - by company, date, etc. - how many users hit what page and when. The table I am loading is used to identify the page and associate a key with it. What I was trying to do was to update the sequence object in Oracle that creates that key.

The sequence is an object within Oracle that, when you ask it, gives you the next sequential number in a sequence. It also remembers what it last gave out so it can give the next number next time it is asked. It's useful in generating keys which is exactly what I was using it for.

In this company's development environment I had been doing a lot of testing, so the sequence number was abnormally high. I figured I'd reset it to a lower number to make my seed entries show up with same/similar numbers as the other environments. I attempted to run a command that would do this:

ALTER SEQUENCE ThisTable_SEQ START WITH 200;

This is not allowed in Oracle, but instead of telling me that, they decided to be snide about it. Their responds was:

Error report:

SQL Error: ORA-02283: cannot alter starting sequence number

02283. 00000 - "cannot alter starting sequence number"

*Cause: Self-evident.

*Action: Don't alter it.

The cause was self-evident? Don't alter it? Translation: You can't do that. Duh! Stop it.

It seems odd to me when I get answers like this. It seems even odder that they won't allow me to do this when the work-around is so simple:

DROP SEQUENCE ThisTable_SEQ;

CREATE SEQUENCE ThisTable_SEQ MINVALUE 1 MAXVALUE 999999999999999999999999999 INCREMENT BY 1 START WITH 200 CACHE 10 ORDER NOCYCLE;

Anyway, posted here mostly for my own amusement. And so my brain can now forget it because it's here in the cloud, forever and ever...

Arduino-Lantern / Cylon

2009-11-01T10:48:00.001-08:00

I had to do this. Partially because I could, but also partially because I needed a quick project. I hadn't done many projects recently (well, summer, duh) and I needed to do something easy with some real impact. Even if I wasn't sure who in the neighborhood would get the joke. I live in the 'burbs - a lot of non-geeks out here.

I decided to do some real soldering on this one. I wanted to create a unit I could keep for later if I

wanted to use it. I started with a pile o

f red LED's I had liberated from a set of Christmas lights. Many of these LED's came pre-equipped with their own resistor. I'm not entirely sure why, though I've noticed during my forays with the RGB LEDs that the red typically wanted lower voltage.

I settled on 12 because its what I could comfortably fit in a Radio Shack proto-board. The LEDs with the resistor seemed okay with the 5 volts the Arduino put out without having issues, but the remaining non-resistored ones were rather bright otherwise. So bright that I wound up burning one out. I dug through my stockpile of resistors and found one with the same color stripes as those already set up.

I then bent all the leads of the LEDs 90 degrees and, using a wide "chip clip" and my 3rd hand, soldered them into the board. Across from the LEDs I put a female pin header. The 12th LED got it's resistor on board and then all were connected to the female pin header with some extra solder (not an easy task).

The female pin header was actually 24 wide. One pin was for voltage, the other for g

round. I considered connecting all the ground pins on board, but since LEDs actually care which is which and I couldn't remember which way I'd wired them, I left all 24 open to accept either.

Part of a breadboard provided ground and a nice spacer between the Arduino pin outs and my LED unit. I wired it up and, using a modified "Knight Rider" program from LadyAda's tutorial site, I had it running in short order. Aside from expanding it to handle the 12 LEDs I had to update it slightly so it left the first LED on before recycling to the next loop. Otherwise that LED would turn off briefly and noticeably.

Its worth noting that once I got all this working I realized it might have been easier to solder a set of male pins that could slot directly into the Arduino. On that side of the board were all the pins I was using as well as a ground. I could have soldered voltage directly to one pin of each LED and then joined all the other pins to ground. I went so far as to cut two sets of male pins before I realized that these would not line up with a protoboard. The two female headers on the Arduino on that side of the board are broken into two sets. The spacing between the two sets wasn't the proper width to fit standard hole spacings. Bummer.

I didn't get around to carving the pumpkins until a couple hours before trick-or-treaters started arriving, so I was somewhat rushed near the end. I had originally planned to use a plastic container for the Arduino so it wasn't brushing up against pumpkin guts. But, in my haste, I ended up using a smaller pumpkin, one that barely fit the Ardunio and the LED unit through the top. I had to cut two slots near the back to allow the breadboard - the widest part - through the top. One slot also provided a nice outlet for the power supply.

The pattern for the face came from another blog post from Evil Mad Scientist Laboratories. Their project involved soldering a dedicated chip, but I was more interested in the pattern for the pumpkin. I just free-handed what they had on their page to my pumpkin and then used a knife to make deep cuts for most of it. From those deep cuts I sort of chipped away with the knife to reveal the face.

The Arduino is resting on a small plastic treat cup my kids use to eat Cheerios or whatever. This gave it enough height to poke the LEDs out the front.

Here are two videos I took of it. I couldn't decide which was better so I put both up. In the first one the face is easier to see, but the camera is kind of unsteady:

I took another one in full darkness. The shot is more steady but the camera decided it needed a light. I could probably have turned it off, but meh...

Here's the code I used. As I mentioned it was based on the Knight Rider stuff. When I went through to put comments in I noticed a bunch of code that seemed to have no purpose. Instead of spending time fixing and testing, I figured I'd just make snide comments at myself.


/*
* Cylon 12 - similar to Sequence blink
*
* Twelve red leds in sequence scrolling
* back and forth.
*/

int count = 0;    // loop counter
int timer = 20;   // miliseconds to wait between blinks
int temp = 0;     // temporary counter

/*
 * Run-once method - turn 12 pins to output
 */
void setup()
{
 for (count = 1; count <= 12; count++)   {     pinMode(count, OUTPUT);   } }  /*  * Main loop  */ void loop() {   // the loop going out from 1 to 12   for (count = 1; count < temp =" count" count =" 12;"> 0; count--)
 {
   // again - shouldn't have to check this - remove it later I guess (or figure out why it's here)
   if (count < temp =" count"> 0) { digitalWrite(temp, HIGH); }
  
   // as long as were in range (do we need to check)
   if (count > 1)
   {
     // wait a bit
     delay(timer);
    
     // turn off main pin
     digitalWrite(count, LOW);
    
     // wait double
     delay(timer*2);
   }
 }
}

The Skywalker Family

2009-11-01T10:36:00.000-08:00

The origins of the idea, we think, were with our daughter Evy. She wanted to be Princess Leia this year for Halloween. She has fairly long hair & we thought we could probably do the iconic hair buns fairly easily. The outfit that goes with it would be, hopefully, simple (for Jeanette) to make. From there we figured it'd be an easy jump to get Sean outfitted as Luke.

I'm not sure where the idea came from that we, their parents, should dress up as... well, their parents. We think Evy eventually decided that this would a cool thing for her parents to do. Jeanette spent many a late night at her serger sewing machine, first with their costumes and then (probably more hours) working on ours.

The result was just fantastic. I only got to wear mine twice, but I think Evy got to wear hers to 5 different events. Jeanette and Sean, both in costume, joined Evy on Friday for Evy's school party. We then all wore our outfits to a 40th birthday party of a friend of mine from college.

We wore them again, for the last time this year (probably), on Halloween. I took the kids out on their run for candy and got a lot of good comments. Jeanette stayed back at the house and handed out candy. Not ready to be done for the night, Jeanette kept hers on for a shopping errand that same night.

Since this project is more craft than make - and I did very little of the work - any comments on the build I'll leave to Jeanette. If I can get her to post something here.

Jeanette's Comments:

Well, I will see what I can add to the above comments to fill in more details on what turned out to be a rather large, lengthy project for me to tackle in not too long of a time. As Jim said, Evy was the one who came up with the initial idea of dressing up as Princess Leia. I thought this would be very fun and mostly easy since Leia's iconic outfit from Star Wars IV: A New Hope was fairly straight forward and uncomplicated.

The biggest worry I had to start with was how in the world I was going to get her hair to cooperate and stay contained in those buns. Being pretty young, she still has that awesome fine, slippery hair, just a step up from baby-fine toddler hair, that likes very much to slip out of its confinements starting very soon after said confinement has been implemented. I actually came up with a rather sneaky method for helping myself with this problem after going thru the motions twice using just binders (for the initial ponytails to keep her hair separated into 2 sections at either side of her head) and LOTS of bobby pins. The buns actually worked pretty well on their own for the short term and looked pretty adorable on her. However, for the day of her Halloween party at school I had to come up with another idea to help keep the hair contained for most of a day - during which I would not be present for the first several hours. My solution? I used old knee-high nylons of mine that were past their usefulness as stockings. They were just about the perfect length to go from the binders down to the end of her hair with just a little stretching to contain the ends once twisted into the buns. I had to use far fewer bobby pins (and had to poke holes thru the nylons for the pins to work properly -only minor discomfort to poor Evy during that process) and the buns stayed put remarkably well for a long period of time. It also helped that Evy's hair is a fairly light brown/dark blonde color so the stockings didn't stand out too horribly.

As for the actual outfit, I used a pattern meant for a shepherdess outfit (think church Christmas play) and implemented a few minor changes that are pretty simple for a somewhat seasoned sewer (no, I am not what I would call an excellent seamstress by any means! I simply am able to make things look like I know what I am doing more than the average person). I made sure the sleeves were loose and fairly long and the hem length was just short enough for Evy to walk around easily without too much constriction but long enough to make no mistake as to who she was dresses as. Having done a couple of other outfits in the past with various collars, I was able to add one to the pattern I used without too much trouble. It did not quite duplicate the real thing but was close enough for costume purposes. I most certainly can not take credit for figuring out how to make the hood (which is actually just a length of material, like a trapezoid, that drapes from one shoulder down and back up to the other shoulder, without being sewed in the center back like a normal hood). I found an excellent website that has pictures of every costume in the Star Wars universe (as far as I can tell) with tons of details and pictures and suggestions for creating parts of the outfits: www.padawansguide.com is the place to go! Totally awesome pics!! The material I chose was some white drapey polyester (I think) type material I already owned. Going for the cost minimization thing here! I did have to make an under dress out of another, heavier white poly-type material I had in order to minimize the sheerness and aim for some greater warmth to accommodate our usually pretty cool Halloweens here in Minnesota. The belt I made for Evy was actually rather amusing. The big metal parts all around the white leather belt were not going to be an option for a child's costume (and a little difficult for me to even think about fabricating in just under a month!) so I came up with another option. I found some silver costume vinyl at the fabric store that I thought would work well as a stand in for the larger silver metal hexagon pieces circling the belt. The white leather-like matte vinyl I actually used for the belt was a remnant that got pretty cheap. As for what is supposed to be the bubble-like parts in the center of the metal hexagons I substituted shiny silver sequin-like discs, super-glued into stacks of 4 onto the center of the silver vinyl decorations. This whole mess was then fabric-glued onto the belt. I thought it turned out looking pretty close to the real thing, for being a child's costume that is.

Sean's Luke Skywalker costume was even easier. Think pajamas! That is exactly what pattern I used for the bottoms. I then took the pattern for the top from that same set and used it as a base size guideline for creating the wrap-style top that Luke wears in Star Wars IV: A New Hope. Now, I did not make extra efforts to make all these costumes without shoulder seams (Leia's, Luke's and even Anakin's outfits all seem to use patterns that have no shoulder seams -but that would require a WHOLE lot more material than I was willing to use or spend money on), but like I said, these are costumes not replicas. I used simple natural tone muslin material which was a pretty close stand-in for the real thing. Luke's belt was similarly improvised using some dark brown vinyl I got free from a friend who had 2 yards she didn't have much use for - terrific luck on my part! The buckle was made from the same silver vinyl (double layer, wrong sides fabric-glued together, for sturdiness and shape) as Evy's belt decorations.

Jim's Anakin outfit was almost as easy as the Luke costume. Think robe and pajama bottom patterns and there you have it! Again, I wasn't looking to duplicate the outfits, just make costumes that emulate them. Anakin actually has many layers to his outfit that proved just a little challenging. The under layer was made from the same natural tone muslin as Luke's outfit, cut to wrap across the torso and hang just below the hips. The pants and next top layer was made from dark brown quilter's cotton and cut the same way, only longer at the hem, to hang mid-thigh. The tabbards (I think that is what they are called) were made from lengths of the dark brown vinyl I got from my friend. I know the real Anakin costume actually had black leather tabbards but I was using what I could get my hands on without going into the poor house! Jim being as tall as he is, had me a little concerned if I could actually get the tabbards to hang nearly to his knees like Anakin's do. Turns out the 2 yards of vinyl I got were just about perfect. The vinyl was even used to make pseudo-boots for Jim to wear to the birthday party (which had a costume contest included, which we won, natch, since many other adults were too lame to wear much in the way of costumes... just teasing guys!), but he passed on those for Halloween night since we ran out of time to get dressed if we were going to let our monkeys actually do some trick-or-treating.

Finally, we have my Padme Amidala costume. This was a major task for me to accomplish and anyone with a bit of observational powers who has seen the movies, particularly Star Wars II: Attack of the Clones, more than a couple times will notice that I took several short cuts in order to actually have a prayer of completing this dress in time for Halloween and manage to keep some semblance of sanity in the process. It must have taken me over a month to decide upon which of the numerous gorgeous choices of dresses I would try to base my costume. Being in Minnesota ruled out several gowns as too impractical without lots of outer fall/winter wear to keep me from getting hypothermic. Others were a little too elaborate for me to wish to undertake with such a short timeline, both in dress and hair.

After consulting several friends and family members, I settled on the grey and black dress Padme wears while packing up to head home after the Chancellor told her to leave Coruscant for her own safety. The dress was fairly simple in construction with just a couple of slightly elaborate decorations that I figured I could avoid trying to out right copy and instead simplify for my own costume. The hair was still going to be a little difficult to duplicate but I had a couple of ideas for that too. But first, the dress:

Sticking to my desire to keep the costs down, I chose to use mostly costume fabric, which I obtained when it was at least 1/2 price, and used one rather significant substitution. Again I used a pattern that I was able to alter a bit on my own to closely resemble Padme's actual gown. The skirt was made from a dark grey silk-essence type of material that looks like a rough silk shantung and lays very nicely over the under-skirt crinoline I made. The skirt of Padme's dress is actually pleated at the waist but I didn't have the time to dedicate to making the waist look that perfect so I simply gathered it around and sewed it to the bodice. The real Padme costume was apparently a 2-piece dress with an under-dress that had a simple tank-top attached to the slightly drop-waisted skirt with the black velvet bodice and silky sleeves as a separate overlay piece. I opted for a one-piece dress for simplicity's sake.

The sleeves were made using a light grey silky costume fabric. The material at the shoulders of the sleeves was gathered onto the bodice. In the original costume had a 2-part sleeve that was gathered around the upper part of the arm creating a full, puffy looking sleeve top. The lower part of the sleeve is gathered at the upper arm where the top part is gathered and is full down to just above the wrist where it gathers into form-fitting cuffs. I made my cuffs only 4 inches tall or so, a bit shorter than the real thing but easy for me to manage. Mine were also closed by snaps, not the half dozen covered buttons of the original. One major difference I had on my outfit, due partly to time constraints and partly to a shortage of the particular trim I chose to imitate the actual metal armbands of Padme's costume, was the presence of only 1 decorative band at the gathered upper arm of my sleeves. I chose to use a silver and black trim I found on clearance at the fabric store in place of what looks like beaded silver bracelet-type bands. Perhaps I will add on bands at a later date and fix the sleeves to be puffier in between the gathering and the shoulder.

For the bodice I ended up using some black corduroy I have had for many years as velvet is pretty pricey. I did not end up turning the bodice into a corset-style top with boning and all the works (as the real thing is) due to time constraints so it wasn't as closely form fitting as I would have liked but it did look pretty nice with its princess seams and shape. I managed to free-form the collar to add onto the top of the bodice with rather impressive results, if I do say so myself. The front had a placket opening that I chose to put snap closures on for ease of creation and dressing. The decorated front overlay placket proved a bit of a challenge. In the real costume the placket is made from what looks like cut of brocade-type of material that is embroidered and beaded rather elaborately. Uh, yeah, not going to happen on my costume. My sister-in-law and I came up with the idea of using fabric paints to closely mimic the beading pattern. I cut a piece of the silver vinyl and a piece of the grey silky costume material I used for the sleeves and fabric glued them together to give it a somewhat firmer structure. After that, I simply laid out my cut piece and had a close-up picture of the actual placket next to it for reference. From that I was able to create a design that was similar with glittery blue fabric paint playing the part of the turquoise beads. I included silver, gold, and shimmery white fabric paint to complete the look of beaded loveliness.

RGB and XYZ

2009-06-29T21:46:00.000-07:00

I think it's going on 14 years or more when I first had the idea: a lighted juggling ball that changes color as it rotates. Seriously - 14 years. I'm fairly sure of this because I told my girlfriend at the time (who eventually became my wife) and she made a prototype. But I get ahead of myself.

It was always LED's that did the lighting, of course. It was also a ball. This is important to note as juggling equipment comes in many shapes and sizes. It is lighted from within, hopefully evenly. As this ball (or many) rotates it changes color. Hopefully it is bright enough to be seen from a far in a dark theater and it's obvious that the color is changing. It's not crucial that the juggler be able to control the changes, but that might be a nice option.

When I told Jeanette (afore mentioned wife) she made a prototype for a class she was taking in college. It was just after we had started dating - I think during her Junior year. Second half she says, and it was for a physics class.

What she created involved two mercury switches and three LEDs. The LEDs were two color - red and green, though they did a passable yellow as well. It worked fairly well as a test, but wasn't anything we could use in a juggling ball. Mercury switches would be too dangerous as they would most likely break.

As I didn't have any other ideas for a switching mechanism, I shelved the idea focusing instead on other matters such as getting married, buying a house, having kids - the usual stuff. But the idea stuck around and when I started getting into the Arduino last year it was the first thing I thought of building. After many other tests and trials of ideas I decided to take another crack at it.

By this point I'd had lots of experience with the accelerometer (see previous posts). It's functionality is rather simple. It expresses the position of each axis as strength of voltage. The highest voltage meant the position was at one side of the axis. No or low voltage meant the position was at the other side of the axis. The Arduino is capable of measuring the voltages with analog pins and can distinguish something like 693 different positions. Using the combination of all three axis you can determine which way is down - one axis, or a couple will always be pulled by gravity - except when in free-fall, which could be another position of sorts.

The first thing I tried - even though I knew it wouldn't work - was to just let the accelerometer drive the LEDs. The RBG LED's I had worked at an operating voltage of near what the maximum output the accelerometer would produce: 3.3 volts.

This was fairly simple to set up and get running. The Arduino was only there to provide power, in this case off of the 3.3 volt "always on" pin. I plugged the accelerometer into the protoboard, set the input and sleep with the 3.3 volt, ground to the ground and the sensitivity pins. The X, Y, and Z axis, in turn, provided the voltage directly to the LED. Oh, and the LED also has a ground.

All this might be easier to see with the accelerometer off to the side. I ran the lines from the three axis under the accelerometer. The two pins sticking up are just there to keep the board level.

I have no code to share for this set up, of course. Again - the Arduino is just providing power.

Running this way did work - sort of. The red, green and blue faded in and out nicely. When any given color tied to an axis was on high voltage it lit nicely. But when it was on low voltage it didn't light at all. What I want is something that shows a color regardless of how the thing is turned. Preferrably there's a way I can tie half of each axis to a color. The RGB LED does a nice job of showing mixes. Sure, the dominant colors are red green and blue, but mix 'em and you also get yellow (sort of), purple (very nice), and aqua (also pretty good). Mix all three and it's a fairly good white.

Next I tried working out some fairly complicated math to assign various positions of the axis to certain colors. These, in turn, were used to set PWM values for the LEDs. The PWM maxes out to something close to 3.3 v for green and blue and 2.0 v for read. But based on the positions of the axis, the strength of the lighting was altered.

This didn't work out very well. To do this I had picked a point between zero and full and treated that as half point. Doing this with each axis gives six "limbs" as it were. Given a position somewhere in or between these six I figured I could use this as a means of lighting or fading between colors.

I won't go into too many details as my failed attempts at this math are something of a private shame. Some of this still shows up - commented out - in the code I share below. I still think my goal of having all 6 colors show is possible - even with some nice fading and maybe having white as the "free fall" color. But I think I need to come up with something different.

What I did come up that works somewhat was to assign a color to each of the eight quadrants. If you bisect the three axis the same way you can think of a three dimensional cross with six points coming out of the middle. If you set the cross inside a cube, it actually looks like eight cubes stacked together - four cubes, two by two on two levels. Reading the accelerometer values I can "decide" that the position is in one of these eight sections and then light the appropriate color.

The problem is I really only have 7 colors: red, yellow, green, aqua, blue, purple, white. So I assinged "off" to the eighth. Here's another video:

This video has got some interesting interferance lines, doesn't it? That's probably the PWM singing in tune with the camera I was using. Might be fun to play with later - but I digress.

If I ever figure out some code that works with just six colors - and free-fall white - I might look into another Arduino board. I was thinking of an Arduino Pro Mini from Sparkfun. Its tiny, its output voltage is already 3.3 volts, and it's fairly cheap. All surface mount to boot, though I think I've gotta solder on my own connectors. I'd probably have to work out a way to connect the accelerometer directly to the thing and somehow tack on some power.

I'd most likely want to figure out a way to connect the LED's somewhat loosely to the board. Maybe connected via a loose wire. There'd probably be eight of these arranged also in quadrants. I'd probably put the bundle into a clear plastic ball and suspend it in that ball in some clear plastic beads that'd (hopefully) diffuse the light of the LED's a bit.

Its all ideas until I actually do it, which at this rate will be next year. Too many distractions...

Anyway, here's the code:


/*
* XYZ (accelerometer) and RGB (LED)
* Fading between colors controlled by accelerometer
* PWM: 3, 5, 6, 9, 10, 11
* USE: 9, 10, 11
*/

// axis analog pins
int xPin = 0;
int yPin = 1;
int zPin = 2;

// mid value of any axis
int max = 693;
int mid = 346;

// pins controlling red/green/blue
int rPin = 9;
int gPin = 10;
int bPin = 11;

// maximum PWM we want for each
int rMax = 102;
int gMax = 163;
int bMax = 163;


/*
* The run-once setup method
*/
void setup()
{
// set up to communicate with serial
Serial.begin(9600);

// set axis/analog pins to input
pinMode(xPin, INPUT);
pinMode(yPin, INPUT);
pinMode(zPin, INPUT);

// set LED pins to output - not
// really necessary for PWM, tho
pinMode(rPin, OUTPUT);
pinMode(gPin, OUTPUT);
pinMode(bPin, OUTPUT);
}


/*
* Main loop - shift lights with accelerometer values
*/
void loop()
{
// fetch value from various analog
int xVal = analogRead(xPin);
int yVal = analogRead(yPin);
int zVal = analogRead(zPin);

// determine which zone that is
int zone = findZone(xVal, yVal, zVal);

// tell us which zone
Serial.print("Zone: ");
Serial.println(zone, DEC);

/*
// calculate how "on" each LED should be
float rPer = redCalc(zone, xVal, yVal, zVal);
float gPer = grnCalc(zone, xVal, yVal, zVal);
float bPer = bluCalc(zone, xVal, yVal, zVal);
// light 'em
lightLed(rPer, gPer, bPer, 0);
*/

switch(zone)
{
 case 1:
   lightLed(1.0, 1.0, 1.0, 0);
   break;
 case 2:
   lightLed(1.0, 0.0, 0.0, 0);
   break;
 case 3:
   lightLed(1.0, 1.0, 0.0, 0);
   break;
 case 4:
   lightLed(0.0, 1.0, 1.0, 0);
   break;
 case 5:
   lightLed(1.0, 0.0, 1.0, 0);
   break;
 case 6:
   lightLed(0.0, 0.0, 1.0, 0);
   break;
 case 7:
   lightLed(0.0, 1.0, 0.0, 0);
   break;   
 default:
   lightLed(0.0, 0.0, 0.0, 0);
}
}


/*
* Based on the values of the 3 axis
* determines which of 8 zones we are in
*/
int findZone(int x, int y, int z)
{
int zone = 0;

if (x > mid && y > mid && z > mid) { zone = 1; }
else if (x <= mid && y > mid && z > mid) { zone = 2; }
else if (x <= mid && y <= mid && z > mid) { zone = 3; }
else if (x > mid && y <= mid && z > mid) { zone = 4; }
else if (x > mid && y > mid && z <= mid) { zone = 5; }   else if (x <= mid && y > mid && z <= mid) { zone = 6; }   else if (x <= mid && y <= mid && z <= mid) { zone = 7; }   else if (x > mid && y <= mid && z <= mid) { zone = 8; }    return zone;   }   /*  * Calculate how "on" red LED is  */ float redCalc(int zone, int x, int y, int z) {   float per = 0.0;      switch (zone)   {     case 1:       per = 1.0;       break;     case 2:       per = z - mid / mid;       break;     case 3:       per = z - mid / mid;       break;     case 4:       per = ((z + x) / 2) / mid;       break;     case 5:       per = ((x + y) / 2) / mid;       break;     case 6:       per = y / mid;       break;     case 7:       per = 0.0;       break;     case 8:       per = x - mid / mid;       break;   }      return per; }   /*  * Calculate how "on" green LED is  */ float grnCalc(int zone, int x, int y, int z) {   float per = 0.0;      switch (zone)   {     case 1:       per = y - mid / mid;       break;     case 2:       per = ((y + x) / 2) / mid;       break;     case 3:       per = x - mid / mid;       break;     case 4:       per = 0.0;       break;     case 5:       per = ((z + y) / 2) / mid;       break;     case 6:       per = 1.0;       break;     case 7:       per = ((x + z) / 2) / mid;       break;     case 8:       per = z / mid;       break;   }      return per; }   /*  * Calculate how "on" blue LED is  */ float bluCalc(int zone, int x, int y, int z) {   float per = 0.0;      switch (zone)   {     case 1:       per = z - mid / mid;       break;     case 2:       per = ((z + x) / 2) / mid;       break;     case 3:       per = 1.0;       break;     case 4:       per = ((y + z) / 2) / mid;       break;     case 5:       per = 0.0;       break;     case 6:       per = x / mid;       break;     case 7:       per = ((y + x) / 2) / mid;       break;     case 8:       per = y / mid;       break;   }     return per; }   /*  * Light the LEDs based on the percentages  */ void lightLed(float rPer, float gPer, float bPer, int wait) {   // caclulate percentages lit   int rVal = rMax * rPer;    int gVal = gMax * gPer;    int bVal = bMax * bPer;       // light the LEDs to these percents   analogWrite(rPin, rVal);   analogWrite(gPin, gVal);   analogWrite(bPin, bVal);      // if given a delay   if (wait > 0)
{
 // delay for a given milliseconds
 delay(wait);
}
}

RGB LED

2009-05-30T20:36:00.000-07:00

Yet another bit of fun that came with my last order to SparkFun were 10 (?) RGB LEDs. These are clear and have four leads coming off of them. They are - shortest to longest: blue, green, ground, and red.

The blue and green take 3.3v, the red takes 2v. Again, the Arduino gives us 5v on most of it's digital pins. There is a 3.3v pin, but I think that's always on. But the Arduino also makes 6 of the pin capable of PWM or Pulse Width Modulation. This is the ability to pulse that 5v on and off at certain intervals and simulate different voltages. Click the link if you want to know more.

Anyway, I set up the proto-shield using PWM and some 100 ohm resistors. While I still haven't bothered to actually calculate the proper resistance, I felt fairly certain I wasn't going to wreck the LED. My first bit of code just flipped through the 8 different combinations of colors: off, red, green, blue, yellow (red/green), aqua (green/blue), purple (red/blue), and white (all 3).


/*
* RGB LED Test 1
* Test lighting all in simple cycles.
* PWM: 3, 5, 6, 9, 10, 11
*/

// pins we'll use
int redLed = 9;
int grnLed = 10;
int bluLed = 11;

void setup()
{
pinMode(redLed, OUTPUT);
pinMode(grnLed, OUTPUT);
pinMode(bluLed, OUTPUT);
}

/*
* Main loop - light in cycles
*/
void loop()
{
lightLed(false, false, false); // off
lightLed(true,  false, false); // red
lightLed(true,  true,  false); // yellow
lightLed(false, true,  false); // green
lightLed(false, true,  true);  // aqua
lightLed(false, false, true);  // blue
lightLed(true,  false, true);  // purple
lightLed(true,  true,  true);  // white
}

/*
* Light the LEDs based on the booleans
*/
void lightLed(boolean redSet, boolean grnSet, boolean bluSet)
{
// default values to not set - no voltage
int redVal = 0;
int grnVal = 0;
int bluVal = 0;

// check booleans and set accordingly
if (redSet) { redVal = 102; } // 2.0v, 20 mA
if (grnSet) { grnVal = 163; } // 3.2v, 20 mA
if (bluSet) { bluVal = 163; } // 3.2v, 20 mA

// write what you set
analogWrite(redLed, redVal);
analogWrite(grnLed, grnVal);
analogWrite(bluLed, bluVal);

// delay for a half of a second using analog write
delay(500);

// this might cause problems being on the same timer
// as PWM, but it's all we've got
}

This was a simple proof that showed I could get all three colors with some simple mixing. Pretty, but I figured with PWM there were many other colors I could get. So I played with fading the three colors in and out with each other.


/*
* RGB LED Test 5
* Fading between colors
* PWM: 3, 5, 6, 9, 10, 11
*/

int redLed = 9;
int grnLed = 10;
int bluLed = 11;

int redMax = 102;
int grnMax = 163;
int bluMax = 163;

int pause = 50;
float step = 0.10;

void setup()
{
// set up to communication with serial
Serial.begin(9600);

pinMode(redLed, OUTPUT);
pinMode(grnLed, OUTPUT);
pinMode(bluLed, OUTPUT);
}


/*
* Main loop - light in cycles
*/
void loop()
{
float red, grn, blu;

// red on, green up, blue off
red = 1; grn = 0; blu = 0;
while (grn <= 1)   {     lightLed(red, grn, blu, pause);     grn += step;     showPercents(1, red, grn, blu);   }        // red down, green on, blue off     red = 1; grn = 1; blu = 0;   while (red >= 0)
{
  lightLed(red, grn, blu, pause);
  red -= step;
  showPercents(2, red, grn, blu);
}

// red off, green on, blue up
red = 0; grn = 1; blu = 0;
while (blu <= 1)   {     lightLed(red, grn, blu, pause);     blu += step;     showPercents(3, red, grn, blu);   }    // red off, green down, blue on     red = 0; grn = 1; blu = 1;   while (grn >= 0)
{
  lightLed(red, grn, blu, pause);
  grn -= step;
  showPercents(4, red, grn, blu);
}

// red up, green off, blue on
red = 0; grn = 0; blu = 1;
while (red <= 1)   {     lightLed(red, grn, blu, pause);     red += step;     showPercents(5, red, grn, blu);   }    // red on, green off, blue down     red = 1; grn = 0; blu = 1;   while (blu >= 0)
{
  lightLed(red, grn, blu, pause);
  blu -= step;
  showPercents(6, red, grn, blu);
}
}


/*
* Light the LEDs based on the percentages
*/
void lightLed(float redPer, float grnPer, float bluPer, int wait)
{
// default values to not set - no voltage
int redVal = redMax * redPer;
int grnVal = grnMax * grnPer;
int bluVal = bluMax * bluPer;

// write what you set
analogWrite(redLed, redVal);
analogWrite(grnLed, grnVal);
analogWrite(bluLed, bluVal);

// delay for a given milliseconds
delay(wait);
}

void showPercents(int state, float redPer, float grnPer, float bluPer)
{
Serial.print("State: ");
Serial.print(state, DEC);

Serial.print(", red: ");
Serial.print(redPer*10, DEC);

Serial.print(", grn: ");
Serial.print(grnPer*10, DEC);

Serial.print(", blu: ");
Serial.print(bluPer*10, DEC);

Serial.println(".");
}

This was a bit more satisfying to watch. So I decided to make another video of it:

I had, of course, decided not long after doing this that I should hook in the accelerometer (I can't leave that thing alone, can I?).

But I'll leave that for another post.

Back to the Accelerometer

2009-04-05T15:22:00.001-07:00

As I mentioned in my previous post I was a bit worried that my accelerometer wasn't working properly. When hooked up along with an LED matrix there were some LEDs that just wouldn't light. It seemed like was the X-axis that was giving me trouble.

Since I'd "played with it" I couldn't return it to Sparkfun, in any case it was past the 14 day limit. This is kind of a bummer because it cost me about $20 - aside from the Arduino, one of the most expensive components in my inventory.

So, I decided to create a way to test it. I figured it'd be cool to find out if there was actually a range of values that the X-axis wasn't producing. To do this would involve having the Arduino read the 3 axis and output the values through the serial port. I'd then have to write some software on the other side to read the values and display them in a way that made sense.

First I hooked everything up on the Arduino and

proto-sheild (see image). Then I proceeded to write a very simple sketch to read the accelerometer and output what it reads through the serial port.

Since I'd already done some serial communication between the Arduino and a .NET 2.0 application, this wasn't all that hard. The sketch reads all three axis in the main loop an then immediately outputs those values through serial as decimal values separated by commas. Each value is sent via Serial.print with the final one sent with a Serial.println. The println statement slaps on a '\n' to the final value separating it from the next set of values that are sent. The code for all this is as follows:


/*
* TripleAxisAccelerometer4.pde
*
* This test involves sending the analog values out through
* the serial port. These values will be read by a .NET app
* and displayed on a WinForm. The goal here is to determine
* whether the x-axis is as messed up as I think it is.
*/

// axis analog pins
int xPin = 0;
int yPin = 1;
int zPin = 2;

// values from those pins
int xVal = 0;
int yVal = 0;
int zVal = 0;

// other working variable schtuff
int mid = 337;
int set = 0;


/*
* The "run once" setup method
*/
void setup()
{
// set up to communication with serial
Serial.begin(9600);

// set axis/analog pins to input
pinMode(xPin, INPUT);
pinMode(yPin, INPUT);
pinMode(zPin, INPUT);
}

/*
* Main processing method
*/
void loop()
{
// fetch value from various analog
xVal = analogRead(xPin);
yVal = analogRead(yPin);
zVal = analogRead(zPin);

// show us
Serial.print(xVal, DEC);
Serial.print(",");
Serial.print(yVal, DEC);
Serial.print(",");
Serial.println(zVal, DEC);
}

The next part was to write a .NET app to read what the Arduino produces. This was a little harder. I'd sent info to the Arduino, but never read anything. The .NET framework provides some easy to use libraries and methods to do this, including one method that reads in an entire line from the com port.

Initially I just displayed the values to text boxes - just to prove that I could. Then I included high and low values, and then some progress bars. This was also useful in finding out something I didn't really know. The accelerometer actually produces values from 0 to 693. I found this by using the low and high trackers - these just take whatever value comes off of the Arduino for a given axis and compares to a value in memory. If the new value is lower or higher, it's kept

. After many replacements you see what the limit is.

This all went swimmingly until I decided to try and paint the values to the screen using the .NET System.Drawing library. There are a lot of examples on the web showing how to paint lines or polygons, but annoyingly enough there weren't many that showed how to paint just a single pixel. I eventually found one and that's what's included in the example below in the "Draw" method. Also note: I've only included the code-behind of the main form. This contains most of what anyone would need to reproduce this since I'm assuming any .NET developer could easily infer the rest on a simple WinForm app.


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO.Ports;
using System.Text;
using System.Windows.Forms;

namespace AccelerometerTest
{
public partial class MainForm : Form
{
 #region Members

 private SerialPort arduino = null;

 private int valX = 0, valY = 0, valZ = 0;
 private int lowX = 1023, lowY = 1023, lowZ = 1023;
 private int highX = 0, highY = 0, highZ = 0;

 private bool readSerial = false;

 KnownColor[] allColors = null;

 #endregion Members

 #region Constructor

 public MainForm()
 {
     InitializeComponent();
 }

 #endregion Constructor

 #region Events

 /// 
 /// Setup of main form - and Arduino communications
 /// 

 ///
 ///
 private void MainForm_Load(object sender, EventArgs e)
 {
     // fetch port and rate
     string comPort = ConfigurationManager.AppSettings["ComPort"];
     int baudRate = int.Parse(ConfigurationManager.AppSettings["BaudRate"]);

     // connect to the Arduino
     arduino = new SerialPort(comPort, baudRate);
     arduino.ReadTimeout = 3000;
     arduino.WriteTimeout = 3000;
     arduino.Open();

     System.Array colorsArray = Enum.GetValues(typeof(KnownColor));
     allColors = new KnownColor[colorsArray.Length];
 }

 protected override void OnPaint(PaintEventArgs e)
 {
     base.OnPaint(e);
 }

 /// 
 /// Shut down the app.
 /// 

 ///
 ///
 private void btnExit_Click(object sender, EventArgs e)
 {
     Application.Exit();
 }


 /// 
 /// Initiate - or stop - the process of reading the Arduino.
 /// 

 ///
 ///
 private void btnStart_Click(object sender, EventArgs e)
 {
     if (btnStart.Text == "Start")
     {
         btnStart.Text = "Stop";
         readSerial = true;
         ClearForm();
         ReadArduino();
     }
     else
     {
         btnStart.Text = "Start";
         readSerial = false;
     }
 }

 #endregion Events

 #region Supporting

 /// 
 /// Does the work of fetching serial data from the Arduino
 /// and displaying it - in various ways - to the form.
 /// 

 private void ReadArduino()
 {
     // working variables
     char[] delim = { ',' };
     string line = "";
     string[] axis = null;
     int tmpX = -1, tmpY = -1, tmpZ = -1;

     // while flagged to read
     while (readSerial)
     {
         // fetch one line of serial data from the Arduino
         line = arduino.ReadLine();

         // remove the return at the end of the line
         if (line.LastIndexOf("\r") > -1)
         {
             line = line.Substring(0, line.Length - 1);
         }

         // if there was nothing read, just skip this iteration
         if (string.IsNullOrEmpty(line.Trim())) { continue; }

         // implicit else - split the line to an array of strings
         axis = line.Split(delim);

         // if we got an array
         if (axis != null && axis.Length == 3)
         {
             // update the values if possible
             if (!int.TryParse(axis[0], out tmpX)) { tmpX = -1; }
             if (!int.TryParse(axis[1], out tmpY)) { tmpY = -1; }
             if (!int.TryParse(axis[2], out tmpZ)) { tmpZ = -1; }

             // update the form with these values
             UpdateForm(tmpX, tmpY, tmpZ);
         }

         // pump the windows message loop
         Application.DoEvents();
     }
 }


 /// 
 /// Clear everything we've painted
 /// 

 private void ClearForm()
 {
     // reset buckets
     valX = 0;
     valY = 0;
     valZ = 0;
     lowX = 1023;
     lowY = 1023;
     lowZ = 1023;
     highX = 0;
     highY = 0;
     highZ = 0;

     // reset texts
     txtXaxis.Text = valX + "";
     txtYaxis.Text = valY + "";
     txtZaxis.Text = valZ + "";

     txtXlow.Text = lowX + "";
     txtYlow.Text = lowY + "";
     txtZlow.Text = lowZ + "";

     txtXhigh.Text = highX + "";
     txtYhigh.Text = highY + "";
     txtZhigh.Text = highZ + "";

     // reset progress bars
     pgXaxis.Value = valX;
     pgYaxis.Value = valY;
     pgZaxis.Value = valZ;

     // clear the image
     RectangleF rectFToFill =
         new RectangleF(0, 0, pbTrack.Width, pbTrack.Height);
     SolidBrush brush = new SolidBrush(Color.White);
     Graphics gfx = pbTrack.CreateGraphics();
     gfx.FillRectangles(brush, new RectangleF[] { rectFToFill });
     brush.Dispose();
 }


 /// 
 /// Update bounds text
 /// 

 ///
 ///
 ///
 private void UpdateForm(int tmpX, int tmpY, int tmpZ)
 {
     // check if our values changed or are even valid
     valX = (tmpX > -1 && tmpX != valX) ? tmpX : valX;
     valY = (tmpY > -1 && tmpY != valY) ? tmpY : valY;
     valZ = (tmpZ > -1 && tmpZ != valZ) ? tmpZ : valZ;

     Draw(valX, valY, valZ);

     // update the core value text boxes
     txtXaxis.Text = valX + "";
     txtYaxis.Text = valY + "";
     txtZaxis.Text = valZ + "";

     // first update the progress bars
     pgXaxis.Value = valX;
     pgYaxis.Value = valY;
     pgZaxis.Value = valZ;

     // set lower bound values
     lowX = (valX < lowy =" (valY" lowz =" (valZ" text =" lowX" text =" lowY" text =" lowZ" highx =" (valX"> highX) ? valX : highX;
     highY = (valY > highY) ? valY : highY;
     highZ = (valZ > highZ) ? valZ : highZ;

     // set upper bound text
     txtXhigh.Text = highX + "";
     txtYhigh.Text = highY + "";
     txtZhigh.Text = highZ + "";
 }


 /// 
 /// Draws a single point
 /// 

 ///
 ///
 ///
 private void Draw(int xVal, int yVal, int zVal)
 {
     int idx = (zVal * 174) / 693;
     // Pen pen = new Pen(Color.Black, 1);
     Pen pen = new Pen(Color.FromKnownColor(allColors[idx]), 1);
     Graphics gfx = pbTrack.CreateGraphics();
     Point[] points = { new Point(xVal, yVal) };

     // Create a 1 x 1 bitmap and set the color
     Bitmap pt = new Bitmap(1, 1);
     pt.SetPixel(0, 0, Color.Black);

     // Draw bitmap on Graphics surface
     gfx.DrawImageUnscaled(pt, xVal, yVal);

     //gfx.DrawPolygon(pen, points);
     //gfx.DrawRectangle(pen, new Rectangle(points[0], new Size(1, 1)));
     //gfx.DrawRectangle(pen, new Rectangle(xVal, yVal, 1, 1));
     //formGraphics.DrawLine(myPen, xVal, yVal, xVal, yVal);

     pen.Dispose();
     gfx.Dispose();
 }

 #endregion Supporting

 #region Properties

 #endregion Properties
}
}

When the app is run and the painting starts its actually kind of interesting how it works. The dots are sort of sprayed all over the place as the accelerometer is moved. I'm not sure if this is just an artifact of how sensitive the accelerometer is or if it's due to noise coming in on the Arduino's analog ports. Either way it looks a bit like an airbrush. In this first go I stuck with painting black dots on a white canvas and only used the X and Y axis to do the painting. I'd like to eventually use the Z axis to drive color, but I'd have to decide how to assign the 0 to 693 or so values to colors somehow.

Doing this kind of "painting" again revealed something I didn't know. Handling the accelerometer without actually shaking it hard shows some median limits to how far it senses. Regular force, or 1 g, is about halfway through the range of values. That is if you tip it on its side so one axis is fully down - like X or Y - the value it displays is about halfway of middle. By tipping the Arduino/proto-shield fully on it side and then slowly rotating it the app paints a rough circle. It's kind of cool, actually.

One bit of work still remains, though: to pinpoint whether there are any values on the X axis (or the others, for that mater) that don't show. Based on what I am seeing, I don't think so. I suspect my problem with the LED matrix not showing some values is due to bad coding in the sketch somewhere.

I have made a recent purchase from SparkFun that will result in more posts. Among the items I've purchase is an LED matrix with a serial interface. This is the same LED matrix I already have, except the folks in Boulder have added a daughter board on the back that handles the job of lighting the LEDs based on signals sent serially. So I don't have to use up nearly as many pins on the Arduino to accomplish the same thing. In fact, with this I can certainly do more. But again, I'll leave that for a later post.

LED Matrix and Accelerometer

2009-04-05T13:35:00.000-07:00

One of the last items I decided to try out from my first order from SparkFun was a medium sized LED matrix. This is an 8 by 8 (64) grid of LEDs that are multi-color. Send voltage through one set of pins and you get green, through another set and you get red - through both I think yellow.

The specifications claim some pretty specific levels of voltage and current. The green wants 3.3 volts and 20 mA, the red wants 2.0 volts and 20 mA. The Arduino Duemilanova puts out 5v and 40 mA for the most part, though it has one 3.3v pin that produces 50 mA.

Of course, when I started playing with it I just through 5v and 40 mA through everything trying to see what it was capable of. For a while this seemed fine, but after a bit it some of the LEDs stopped lighting, or some light when not sent current. It still works, for the most part, with a few obvious gaps.

I did remember later that the Arduino can do Pulse Width Modulation (PWM) through some of it's digital out pins: 3, 5, 6, 9, 10, and 11. With PWM you can simulate a lower voltage by pulsing the 5v on and off over and over at a certain rate.

The LED matrix has two lines of 12 pins on the back of it. Eight of these accept ground leaving two other sets of eight for green or red. Connecting one of eight grounds with one of eight of either the green or red will light a single LED. Using as many pins as I could connect, I came up with the setup shown in the image here.

I used all the PWM capable pins as well as a couple of non PWM capable pins a full voltage. All of the voltage generating pins, however had 500 ohm (at least I think) resistors on them, lowering the current by half.

For this first effort I just stuck with green since it could accept a higher voltage anyway. My first sketch just cycled through lighting all the green LEDs one by one - well, at least those that were still working.


/*
* Matrix Test 1
* PWM: 3, 5, 6, 9, 10, 11
*/

int grnds[] = { 4, 2, 1, 0, 13, 12,  8,  7 };
int apins[] = { 3, 5, 6, 9, 10, 11, 18, 19 };

void setup()
{
for (int i = 0; i < i =" 0;" j =" 0;">

To get a single LED to light, that is to have one pin produce voltage and another become ground - while the remaining pins do nothing - was a bit tricky. The groun pin must be set to output and low while the voltage pin has to be set to output and either output also (5v) or analog write 170 (about 3.3v). To turn that set off requires turning both ground and voltage to input. This at least proved to me that I could light each LED individually even if some - 3, actually - were broke.

To me, the next logical step was to add the accelerometer to the test jig (also pictured above) and use it to direct the lighting of the individual LEDs. This proved to be a bit more difficult. The Accelerometer accepts 3.3v and outputs that much or less on 3 pins, one each for X, Y, or Z axis. The analog pins on the Arduino expect 5v and read to a granularity of 0 to 1023. With 3.3v the full range becomes more like 0 to 675 (though I found out later this was wrong - its more like 695). The LED matrix has 8 LEDs by 8, so I had to do some weird calculation to map 0 to 675 to 0 to 8.



/*
* LED Matrix plus Accelometer
*
* PWM: 3, 5, 6, 9, 10, 11
*/

// pins on the matrix connected to ground
int grnds[] = { 4, 2, 1, 0, 13, 12,  8,  7 };

// pins on the matrix connected to voltage
//int apins[] = { 3, 5, 6, 9, 10, 11, 18, 19 };
int apins[] = { 19, 18, 11, 10, 9, 6, 5, 3 };

// axis analog pins
int xPin = 0;
int yPin = 1;
int zPin = 2;

// calculations
float maxValue = 506.385;
float minValue = 168.795;
float fulRange = 337.59;
float divValue = (float)fulRange / 8.0;

// other working variable schtuff
int lstGrnd = 0;
int lstApin = 0;
int set = 0;

/*
* Run-once setup method
*/
void setup()
{
// set up to communication with serial
Serial.begin(9600);

// set axis/analog pins to input
pinMode(xPin, INPUT);
pinMode(yPin, INPUT);
pinMode(zPin, INPUT);

//showCalcs();

// set up ground and voltage pins
for (int i = 0; i < set ="=" set =" 1;" xval =" analogRead(xPin);" yval =" analogRead(yPin);" gc =" calcIdx(xVal);" ac =" calcIdx(yVal);" idx =" (((aVal" idx =" 0;"> 7) { idx = 7; }

return idx;
}


void ledOnOff(int grnd, int apin)
{
if (grnd != lstGrnd || apin != lstApin)
{
ledOff(lstGrnd, lstApin);
ledOn(grnd, apin);
lstGrnd = grnd;
lstApin = apin;
}

/*
ledOn(grnd, apin);
ledOff(grnd, apin);
*/
}

void ledOn(int grnd, int apin)
{
pinMode(grnd, OUTPUT);
digitalWrite(grnd, LOW);
pinMode(apin, OUTPUT);

if (apin == 3 || apin == 5 || apin == 6 ||
apin == 9 || apin == 10 || apin == 11)
{
analogWrite(apin, 170);
}
else
{
digitalWrite(apin, HIGH);
}
}

void ledOff(int grnd, int apin)
{
pinMode(grnd, INPUT);
pinMode(apin, INPUT);
}

This did not work as I expected. More than one LED lit at once and there seemed to be a gap in the values produced by the X axis, which translated into a row or two of LEDs that wouldn't light. At first I suspected my math was wrong, but now I am wondering whether there is a problem with the accelerometer. It's almost as if it has a gap in the values it is able to produce. I will have a later post describing how I tested that, though.

Here's a video on YouTube of it running:

Finally, before I disassembled this test jig I wanted to code a simple animation. I went with a box, lighting the outer sqare of LEDs, then the next inner, and so forth. Here's another video of it doing that bit:

The code for that is listed at the end of this post.

Before I finish entirely, though, I will make note of one thing. This is what I'd call my first mistake with monetary consequences. Though the matrix isn't completely ruined, it's certainly not working completely. These LED matrixes aren't all that expensive. They run about $7 on SparkFun, but it is a bummer to have wrecked it. So far my experimentation with the Arduino has been fairly innocuous. I guess the lesson here is to read the specs and stick to the voltage/current as best you can.

There is also one other thing I wanted to add. I made some videos of this project as well - which you can see I've added. My camera - a Fuji FinePix F50SE - can record movies at 640x480 / 30 fps for as long as I've got space on the memory card. They're pretty nice, but also in AVI or non-compressed format. I tried finding a way to convert these into MPEGs, but so far have not found any free software to do this. Googling for something of this sort almost always comes up with for pay, or trial then for pay software. I know there's gotta be some nice freeware / open-source software out there somewhere, but I am at a loss to find it.

Anyway, not long after I wrote this post I had a conversation with some friends at work. Their response was - don't try and figure it out - let YouTube do it. It will take various formats and store these off in it's own way and then give you a link to play it. Plus you are not really worried about storage once you put things there (not sure about this). So I did this and here they are. Cool.

Anyway, here's that last bit of code:


/*
* Matrix Test 2
*
* Light squares
*/

int grnds[] = { 4, 2, 1, 0, 13, 12,  8,  7 };
int apins[] = { 3, 5, 6, 9, 10, 11, 18, 19 };
int loops = 0;
bool dir = true;

void setup()
{
for (int i = 0; i < dir =" true;"> 100 && loops <> 500 && loops <> 700 && loops <> 900) { dir = false; }

if (dir) { loops++; }
else { loops--; }
}

void box(int low, int high)
{
for (int i = low; i < apin ="=" apin ="=" apin ="=" apin ="=" apin ="=" apin ="=">

Servo Plus Potentiometer

2009-03-02T20:04:00.001-08:00

I had to do one more of these before I took it apart.

Not too long ago I saw a link on Make: regarding using potentiometers and servos. To be honest, I never got around to watching the video. But after the last blog entry I made, adding in the potentiometer didn't seem all that hard.

The potentiometer takes 5v on one side, ground on the other. In the middle I hooked to one of the analog pins.

Analog read on the Arduino ranges from 0 to 1023. The servo however took a range of values from 375 to 2400. The leaves me needing to convert from 1023 to 2025. This is a fairly simple ratio, which I originally coded something like this:

pulse value = ((potentiometer value * 2025) / 1023) + 375

Using this formula introduced me to an interesting detail that I had not seen for a while. Not since a project I had done for the State of Minnesota. At the time I was working on a project for the Department of Education. I don't recall the specifics, but I had been doing some calculations with large numbers in Java. Every so often the numbers would turn negative. This is exactly what I started seeing here when multiplying the potentiometer value with 2025.

What's going on is something I learned about much further back in college. The type value I was using was too small for the value I was putting into it. Every bit of the value - or perhaps just one particular one - was overwriting the slot that holds the negative/positive indicator. Very annoying.

To solve the problem on the DOE project I ended up using a larger type. I tried a few different types with the Arduino (doubles, long ints, floats) but to no avail. Instead of digging into a solution further in that direction, a different solution occurred to me - change the calculation:

pulse value = ((2025 / 1023) * potentiometer value) + 375

This forces the division to occur first, which winds up with some value like 1.979 and so forth. This is a much smaller value that when multiplied by the pot value and added to 375 is still managable.

Anyway, here's the code:


/*
 * Servo plus potentiometer - a match made in... 
 * well, a match made on an Arduion at least.
 */

int potPin = 1;
int potVal = 0;
int servoPin = 3;
int baseChar = 48;
int maxCycles = 40;
int minPulse = 375;
int maxPulse = 2400;
int maxAnalog = 1023;
int distance = maxPulse - minPulse;
int list[4] = {-1, -1, -1, -1};
int input = 0;
int pulse = minPulse;
int lastPulse = maxPulse;

void setup()
{
  // setup serial schtuff
  Serial.begin(9600);
  pinMode(servoPin, OUTPUT);
  
  // say hello
  Serial.println("Servo with potentiometer control - start");
  
  // get first potentiometer value
  potVal = analogRead(potPin);
  
  // calculate pulse from it
  calcPulse();
    
  // then go there
  specific();
}

void loop()
{
  // read from potentiometer 
  int tmpVal = analogRead(potPin);
  
  // if this is a new value
  if (tmpVal != potVal)
  {
    // keep it
    potVal = tmpVal;

    // calculate pulse from it
    calcPulse();
    
    // then go there
    specific();
  }
}

void calcPulse()
{
  double ratio = distance / maxAnalog;
  
  if (potVal == 0) 
    pulse = minPulse;
  else if (potVal == maxAnalog)
    pulse = maxPulse;
  else
    pulse = ratio * potVal + minPulse;
    
  Serial.print("potVal: ");
  Serial.print(potVal, DEC);
  Serial.print(", ratio: ");
  Serial.print(ratio, DEC);
  Serial.print(", pulse: ");
  Serial.println(pulse, DEC);
}

void specific()
{
  if (pulse >= minPulse && pulse <= maxPulse)
  {
    //Serial.print("Last pulse ");  
    //Serial.println(lastPulse);  

    //Serial.print("Current pulse ");  
    //Serial.println(pulse);  

    int travel = max(lastPulse, pulse) - min(lastPulse, pulse);
    //Serial.print("Travel ");  
    //Serial.println(travel);  
    //Serial.print("Distance ");  
    //Serial.println(distance);  
    
    float cut = (float)travel / (float)distance;
    //Serial.print("Cut ");  
    //Serial.println(cut, DEC);  
    
    unsigned int cycles = (maxCycles * cut) + 1;
    cycles = max(cycles, 5);
    //Serial.print("Cycles ");  
    //Serial.println(cycles);  
    
    for (int i = 0; i <= cycles; i++)
    {
      digitalWrite(servoPin, HIGH);
      delayMicroseconds(pulse);
      digitalWrite(servoPin, LOW);
      delay(20);
    }
    
    lastPulse = pulse;
  }
  else
  {
    Serial.print("Pulse given ");  
    Serial.print(pulse);  
    Serial.print(" is outside of range: ");  
    Serial.print(minPulse);  
    Serial.print("-");  
    Serial.println(maxPulse);  
  }
  
  pulse = 0;
}

Servo Control

2009-02-23T19:40:00.000-08:00

Here's another one I did a while back & never got around to posting here. Further back, like years (don't remember how many - Evy was small) I got a rather nice RC car kit from my dad. It was a Tamiya "Baja Champ" - the whole deal, dissassembled, two servos, drive motor, trigger controller and such. He also got me a charger for the main power source. It was cool.

So I quickly put the thing together and discovered something interesting - and relevant to this post, I assure you. There were spare parts. Extra cogs, some plastic bits, but also a completely spare servo. I got the thing done and it ran fine, but I was still scratching my head over the spare servo. The answer came later. One of my wife's cousins and family were over for a visit and it turned out her husband had built some of these kits before. He said that the extra servo was kind of a hold over from before there was electronic speed control for the motor. The servo actually was the throttle, or whatever. But my kit came with a component that did the work. One servo for the steering and then this board in some box doing the throttle.

So I've got this extra servo gathering dust for a few years until I get my Arduino. Once I got that every extra electronic gew-gaw and gadget in my house becomes an opportunity. Before I started though, I did some research. The servos I got with the Tamiya were Futaba, specifically S3003. I found a tech sheet on Futaba's site, but wasn't entirely convinced I had the right one. There were some useful links - here and here - that were somewhat close to what I had and were enought to get me started. The best link, though, I seem to have misplaced, so I can't share that.

The servo has a three wire cable coming off of it: black for ground, red for voltage - in the case I fed it the 5v, and white for control. There were warnings here and there about not using the Arduino to directly power the server - something about it needing more amps than the Arduino can provide - but I decided to just blindly ignore this warning and forge ahead.

The pulsing of voltage to the white turned out to be the tricky part. It needs voltage for a given number of miliseconds and then off for like 20 miliseconds to drive it to a particular position. The number of times pulsed - on for a specific number of miliseconds, off for 20 milis, then rinse and repeat - also had some impact. I did not know what the minimum or maximum my servo wanted to move it's full range. I did get a few lines of code that would get it to move, but had no idea how it was working.

After a bit of trial and error I found the limits: 375 miliseconds for minimum position, 2400 miliseconds for maximum position, or 0 to 180 degrees, give or take. I also found that the distance travelled dictated how long you needed to pulse the cycle for. If you were travelling from 375 all the way to 2400 and you stopped pulsing before the servo completed the motion it would indeed stop halfway. Or three quarters or however long you actually pulsed for. So in my code I added some calculation to figure out how long the travel was and ensure a minimum number of cycles before cutting out. This minimum was whatever it absolutely needed to got the max distance cut down to whatever the travel was.

Anyway, here's the code. There's not much for comments in this version, but I'll eventually go back and put some in.


/*
* ServoTest5
*/

int servoPin = 3;
int baseChar = 48;
int maxCycles = 40;
int minPulse = 375;
int maxPulse = 2400;
int distance = maxPulse - minPulse;
int list[4] = {-1, -1, -1, -1};
int input = 0;
int pulse = minPulse;
int lastPulse = maxPulse;

void setup()
{
Serial.begin(9600);
pinMode(servoPin, OUTPUT);
Serial.println("Serial servo ranging - start");
specific();
}

void loop()
{
if (Serial.available())
{
  int count = 3;
  Serial.print("Input: ");
  do
  {
    input = intFromAscii(Serial.read());
    if (input > -1)
    {
      Serial.print(input);
      list[count--] = input;
    }
  } while (input > -1 && count >= 0); 
  Serial.println();

  //showList();
  pulse = intFromList();
  specific();
}
}

int intFromAscii(int ascii)
{
int temp = ascii - baseChar;

if (temp >= 0 && temp <= 9)     return temp;   else     return -1; }  int intFromList() {   int temp = 0;   int mult = 1;        for (int i = 0; i <> -1)
  {
    temp += list[i] * mult;
    mult *= 10;
  }
} 

clearList();

return temp;
}

void clearList()
{
for(int i = 0; i < i =" 0;">= minPulse && pulse <= maxPulse)   {     Serial.print("Last pulse ");       Serial.println(lastPulse);        Serial.print("Current pulse ");       Serial.println(pulse);        int travel = max(lastPulse, pulse) - min(lastPulse, pulse);     Serial.print("Travel ");       Serial.println(travel);       Serial.print("Distance ");       Serial.println(distance);            float cut = (float)travel / (float)distance;     Serial.print("Cut ");       Serial.println(cut, DEC);            unsigned int cycles = (maxCycles * cut) + 1;     cycles = max(cycles, 5);     Serial.print("Cycles ");       Serial.println(cycles);            for (int i = 0; i <= cycles; i++)     {       digitalWrite(servoPin, HIGH);       delayMicroseconds(pulse);       digitalWrite(servoPin, LOW);       delay(20);     }          lastPulse = pulse;   }   else   {     Serial.print("Pulse given ");       Serial.print(pulse);       Serial.print(" is outside of range: ");       Serial.print(minPulse);       Serial.print("-");       Serial.println(maxPulse);     }      pulse = 0; }

Open Heart Kit

2009-02-16T20:31:00.000-08:00

For Valentine's day I decided to create a heart shaped LED display. I had been trying to learn Charlieplexing for a while, but the concept was, for some reason, a difficult one for me. There is an Instructable on the open heart kit, but the photos of the wiring didn't make any sense to me. There was also a schematic (somewhere) along with it, but that wasn't helping me for some reason. I also wanted to make it a surprise for my wife. Its easy to research the idea with her watching, but once I started my trial and error with a heart shape she'd probably wonder. All this coupled with the fact that Valentine's day was fast approaching, I decided to order a kit.

The kit was created by Jimmie Rodgers. I am fairly impressed with it. He doesn't actually sell the kits off of his site. Instead he went with the Maker shed site here. One a side note I wasn't impressed with the size of box they sent. Adafruit and Sparkfun both sent my stuff in a small box which fit in my mailbox. Maker shed sent a huge box with a small envelope inside. Since I sent it to work, it wasn't too hard to hide it from my wife, but still.

Soldering PCB wasn't all that difficult, though I did have trouble keeping the LEDs straight (I need to get a 3rd hand or vise or something). I had that bit done in about an hour or tow.

The real problem came in when I started with the cable. Jimmie Rodgers admits it isn't the best solution, but was the best that fit the need. The PCB needs 6 pins off of the Arduino to go HIGH, LOW, or Input. The cable is there to pass these states on to the board. The problem I had with it is it was a bit stiff and difficult to work with.

I found the connections in the back a bit odd. I don't completely understand why there are three separate plugs. I suspect its that way to accomodate a flexible configuration - the open heart kit can also be sewn into material and connected via conductive thread.

The problem I had with these connectors was that I couldn't get the individual wires to the right length. So the bottom two were fine, but the middle/top was a bit short and kept coming unconnected. I never got around to fixing this because it worked for the most part.

The other problem I had was with the connectors to the Arduino. Included with the kit was a set of break-away headers. I initially just stripped the wires on the other end and attempted to solder them to the headers. Without a third hand or vise I couldn't quite get them to solder very well. They kept breaking. I did get them to stick well enough to prove all my LEDs were connected right before giving up that first night.

The next night I tried breaking up the headers with the thought I could reconfigure them how I liked. This didn't work so well, so I tried some heat shrink tubing to hold the solder joint on. Still didn't keep a good connection. I also tried some super glue, but that was a bit of a mess.

I made one more attempt at getting pin connectors at the other end. I still had some headers left over from an order I'd made from Sparkfun. I cut six off of that and again soldered the wires directly. I did switch them around so the order was correct if I plugged it in directly to a set of pins on the Arduino.

I also used some heat shrink tubing to pins the solder down so it wouldn't come off. This seems to work, but I still wonder whether there's a better solution somewhere.

Jimmie Rodgers took this whole thing a step further and provided a rather nifty way to program it. It's flash site that shows an image of the LEDs that you can click on. You click on each LED to light in a given frame and then add a new frame, click on more, and so forth. You really just have to check it out to understand. Once you've made all the frames you're going to make, you click generate and get some cut/paste-able code you can load into your Arduino.

I wrote a few different animations so I had some variety to show on Valentine's day. My wife and kids thought it was pretty cool. That along with flowers, chocolate, and wine made the day a success.

Here is the code I said I would, eventually, post. Again, I have to point out I did not write this code. This was generated using the Flash tool on Jimmie Rodger's site. To me the coolest part of this project is this code, or possibly cooler the generator. Having the code gives me some great examples of how he did it. Eventually I plan to apply that to a later project that involves a square array of LEDs and an accelerometer. More on that later (hopefully).


//**************************************************************//
//  Name    : Charlieplexed Heart control                       //
//  Author  : Jimmie P Rodgers   www.jimmieprodgers.com         //
//  Date    : 08 Feb, 2008  Last update on 02/13/08             //
//  Version : 1.3                                               //
//  Notes   : Uses Charlieplexing techniques to light up        //
//          : a matrix of 27 LEDs in the shape of a heart       //
//          : project website: www.jimmieprodgers.com/openheart //
//****************************************************************   //
#include   //This is in the Arduino library 
int pin1 =1;
int pin2 =2;
int pin3 =3;
int pin4 =4;
int pin5 =5;
int pin6 =6;
const int pins[] = {
  pin1,pin2,pin3,pin4,pin5,pin6};
const int heartpins[27][2] ={
  {pin3, pin1},
  {pin1, pin3},
  {pin2, pin1},
  {pin1, pin2},
  {pin3, pin4},
  {pin4, pin1},
  {pin1, pin4},
  {pin1, pin5},
  {pin6, pin1},
  {pin1, pin6},
  {pin6, pin2},
  {pin4, pin3},
  {pin3, pin5},
  {pin5, pin3},
  {pin5, pin1},
  {pin2, pin5},
  {pin5, pin2},
  {pin2, pin6},
  {pin4, pin5},
  {pin5, pin4},
  {pin3, pin2},
  {pin6, pin5},
  {pin5, pin6},
  {pin4, pin6},
  {pin2, pin3},
  {pin6, pin4},
  {pin4, pin2}
 };
int blinkdelay = 200;
//This basically controls brightness. Lower is dimmer
int runspeed = 50;
    //smaller = faster
byte heart[][27] PROGMEM ={
{0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,1,1,0,1,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,0},
{1,1,1,1,1,0,0,1,0,0,1,1,0,0,0,0,0,1,1,0,0,0,1,1,0,1,1},
{0,0,0,0,0,1,1,0,1,1,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,0},
{2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
void setup() {
//  blinkall(2); // useful for testing
}
void loop() {
// sequenceon(); // useful for testing
play();
}
void turnon(int led) {
  int pospin = heartpins[led][0];
  int negpin = heartpins[led][1];
  pinMode (pospin, OUTPUT);
  pinMode (negpin, OUTPUT);
  digitalWrite (pospin, HIGH);
  digitalWrite (negpin, LOW);
}
  void alloff() {
  for(int i = 0; i < 6; i++)   {
    pinMode (pins[i], INPUT);
  }
}
void play() {
  boolean run = true;
  byte k;
  int t = 0;
  while(run == true)   {
    for(int i = 0; i < runspeed; i++)     {
      for(int j = 0; j < 27; j++)       {
        k = pgm_read_byte(&(heart[t][j]));
        if (k == 2)         {
          t = 0;
          //run = false;
        }
        else if(k == 1)         {
          turnon(j);
          delayMicroseconds(blinkdelay);
          alloff();
        }
        else if(k == 0)         {
          delayMicroseconds(blinkdelay);
        }
      }
    }     t++;
  }
}
void blinkall(int numblink) {
  alloff();
  for(int n = 0;n < numblink;n++)   {
    for(int i = 0; i < runspeed; i++)     {
      for(int j = 0; j < 27; j++)       {
        turnon(j);
        delay(blinkdelay);
        alloff();
      }
    }
    delay(500);
  }
}
void sequenceon() {
  for(int i = 0; i < 27; i++)   {
    turnon(i);
    delay(800);
       alloff();
    delay(800);
     }
}

Dark sensor

2009-01-22T21:29:00.001-08:00

This is really a test of a light sensor, or Light Dependent Resistor (LDR). I got one of these with my prototyping kit from Adafruit and figured I should learn how to use it. There is actually a much more useful article on Libelium that shows how to hook it up more clearly and even gives schematics.

The 5v is dropped a bit with a 1k resistor. The LDR is dropped into ground with the other end sitting between the dropped 5v and one of the analog ports. As voltage varies through the LDR the analog port sees the difference and reports it.

In my code whatever is found on the LDR/analog port (0-1023) is translated into a number of LEDs to light. The lower the value - or less resistance to ground - presented by the LDR shows up as a lower value on the analog port. This means less LEDs lit. The higher the values and the more LEDs are lit.

I built several versions of this setup, but the one pictured is the last version. It uses 9 LEDs I took from a Christmas light string I got from Gerten's. The LEDs aren't fancy, but I've got a lot of them, so I figured on the last incarnation of this thing I'd use as many as I could comfortably fit on the proto-shield.


/* 
 * LightSensor4.pde
 * Controls 9 LEDw which get turned on or off in relation
 * to values read from the LDR. None on for darkest up to
 * all on for brightest.
 */

// Light Dependent Resistor (LDR) - or analog pin we'll listen to
int LDR = 0;

// various levels of analog read - total range is 1023 (dark) to zero (light)
// int level[] = { 1024, 896, 768, 640, 512, 384, 256, 128 };
int level[] = { 1000, 900, 800, 700, 600, 500, 400, 300, 200 };

// establish an array for our LED pins
int ledpin[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

// other working variable schtuff
int leds = 9;
int count = 0;
int val = 0;
int set = 0;

/*
 * The "run once" setup method
 */
void setup() 
{
  // set up to communication with serial
  Serial.begin(9600);
  
  // set this pin (analog/light sensor) to input
  pinMode(LDR, INPUT);
  
  // set all the LED pins to output
  for (count = 0; count < leds; count++)
  {
    pinMode(ledpin[count], OUTPUT);
    // and turn on those LEDs
    //digitalWrite(ledpin[count], HIGH);
  }
  
  // say that we're done if anyone's listening
  Serial.println("Setup has run");
}

/*
 * Main processing method
 */
void loop() 
{
  // fetch a value from the light sensor
  val = analogRead(LDR);
  
  // show us what analog/LDR val is
  Serial.print("val: ");
  Serial.println(val, DEC);

  // initially set LEDs to light to max # possible
  set = leds;

  // look through range of levels
  for (count = 0; count < leds; count++)
  {
    // if value less than a given level, drop # of LEDs to light by 1
    if (val < level[count]) { set--; }
  }

  // show us what we think the number of LEDs to set is
  Serial.print("set: ");
  Serial.println(set, DEC);
  
  // if there's anything to set
  if (set > 0)
  {
    // loop up to only the number to set
    for (count = 0; count < set; count++)
    {
      // and turn on those LEDs
      digitalWrite(ledpin[count], HIGH);
    }
  }
  
  // loop through the remaining LEDs
  for (count = (leds - 1); count >= set; count--)
  {
    // and turn 'em off
    digitalWrite(ledpin[count], LOW);    
  }
  */
}

Triple Axis Accelerometer

2009-01-14T22:20:00.000-08:00

Another post-holidays item I ordered from SparkFun was a triple-axis accelerometer (MMA7260Q). This was probably the most expensive item in my order and the one I was the most twitchy about working with. If I wrecked it - soldered it wrong or fed it too much voltage - well, that was $20 gone.

What I got was fairly easy to work with, though. SparkFun pre-mounts the chip onto a breakout board for convenience. From there all I had to do was solder on some headers so I could slot it into a bread-board.

SparkFun frequently provides a link to the datasheet PDF, which helps with some of the basics of what each given item's specs, limitations are - what it can do. They also provided another helpful link to Tom Igoe's site to a page describing the MMA7260Q. The data sheet was helpful, but Tom Igoe's description was more so. This description didn't discuss using it with the Arduino specifically, but I could infer enough to get things going.

Once I had the break-out soldered, I plugged it into the proto-board and started into it. The pins on the breakout were as follows:

The first pin accepts 3.3v, of which the Arduino provides one.
The next pin is ground (there are lots of places to put this to on the proto-board).
The X axis went to analog 0.
The Y axis went to analog 1.
The Z axis went to analog 2.
The next two used in combination control sensitivity, i.e. combinations 3.3v or ground will change sesitivity from 1.5 g to 6 g. I put both to ground which sets it to the most sensitive setting.
The last pin controls sleep mode.

The meaning last pin wasn't immediately apparent to me. It puts the accelerometer to sleep, sure, but I didn't understand how. I started with no signal - nothing hooked up - and then ground. I spent the next half hour wondering why I was getting nothing from the accelerometer & assuming I'd broken it before I tried throwing 3.3v through it. Then it woke up and I started getting real data off of the analog pins from which I was reading. No signal or ground means sleep, 3.3v means wake up.

My initial testing with the chip involved just watching what I'd get from Serial.read off of the three analog pins. The max voltage going in was 3.3v, so that's the max that would come out of the analog - or X/Y/Z - ports. The range of values the Arduino analog pins could read was 0 to 1023 - or for 5v. This meant my max value possible from the accelerometer was somewhat lower; 0 to 675 or there abouts.

After a couple tests the prototype I came up with involved 6 LED's that would dim or brighten based on which axis were leaning in a given direction. This meant splitting the values produced by analog in half and then converting that range of values to something from 0 to 255 - the digital pins outputting voltage to the LEDs only have resolution from 0 to 255.

The X and Y axis worked great - one LED would dim as the other brightened. At level both on the same axis would be dark (or close) and so forth. The Z axis was a bit of a let-down though. I wasn't exactly sure what to expect. To get it to do anything, though, I had to sort of shake the whole unit up and down. Otherwise, one of the LEDs was on all the time and the other off. I think the Z axias is used for free-fall detection. for my simple little rig, it wasn't much use.

The final code to run the configuration pictured was:


/*
* TripleAxisAccelerometer3.pde
* This next test of the triple-axis accelerometer
* involves using it's info to dim and brighten 6 LEDs,
* one for each possible direction, or a cube.
*/

// axis analog pins
int xAx = 0;
int yAx = 1;
int zAx = 2;

// values from those pins
int xVal = 0;
int yVal = 0;
int zVal = 0;

// the LED pins
int xPins[] = { 9, 6 };
int yPins[] = { 3, 11 };
int zPins[] = { 10, 5 };

// calculated values - remove later?
int xl = 0;
int xr = 0;
int yl = 0;
int yr = 0;
int zl = 0;
int zr = 0;

// calculations
float hafRange = 337.59;
float maxAnlog = 255;
float adjuster = (float)maxAnlog / (float)hafRange;

// other working variable schtuff
int mid = 337;
int set = 0;


/*
* The "run once" setup method
*/
void setup()
{
 // set up to communication with serial
 Serial.begin(9600);

 // set axis/analog pins to input
 pinMode(xAx, INPUT);
 pinMode(yAx, INPUT);
 pinMode(zAx, INPUT);

 showCalcs();

 // say that we're done if anyone's listening
 Serial.println("Setup has run");
}

/*
* Main processing method
*/
void loop()
{
 // message to show once
 if (set == 0)
 {
   Serial.println("Loop has started");
   set = 1;
 }

 // fetch value from various analog
 xVal = analogRead(xAx);
 yVal = analogRead(yAx);
 zVal = analogRead(zAx);

 // calculate values 
 xl = adjustLeft(xVal);
 xr = adjustRight(xVal);
 yl = adjustLeft(yVal);
 yr = adjustRight(yVal);
 zl = adjustLeft(zVal);
 zr = adjustRight(zVal);

 // show us
 Serial.print("xl ");
 Serial.print(xl);
 Serial.print(", xr ");
 Serial.print(xr);
 Serial.print(", yl ");
 Serial.print(yl);
 Serial.print(", yr ");
 Serial.print(yr);
 Serial.print(", zl ");
 Serial.print(zl);
 Serial.print(", zr ");
 Serial.println(zr);

 // write to pins
 writePin('X', 'L', xPins[0], adjustLeft(xVal));
 writePin('X', 'R', xPins[1], adjustRight(xVal));
 writePin('Y', 'L', yPins[0], adjustLeft(yVal));
 writePin('Y', 'R', yPins[1], adjustRight(yVal));
 writePin('Z', 'L', zPins[0], adjustLeft(zVal));
 writePin('Z', 'L', zPins[1], adjustRight(zVal));
}


/*
* Adjust the value incoming from analog
* to something between 0 and 255.
*/
int adjustLeft(int valRead)
{
 int adjusted = 0;

 if (valRead < adjusted =" maxAnlog" adjusted =" 0;"> hafRange)
 {
   adjusted = (valRead * adjuster) - maxAnlog;
 }

 return adjusted;
}


/*
* Do the work of writing one value to
* one pin here so we can print some info.
*/
void writePin(char axis, char dir, int pin, int val)
{
 /* 
 Serial.print("axis ");
 Serial.print(axis);
 Serial.print(", dir ");
 Serial.print(dir);
 Serial.print(", pin ");
 Serial.print(pin);
 Serial.print(", val ");
 Serial.println(val);
 */

 analogWrite(pin, val);
 // analogWrite(xPins[0], adjustLeft(xVal));
}


void showCalcs()
{
 unsigned int temp = 0;

 temp = hafRange * 100;
 Serial.print("hafRange: ");
 Serial.println(temp, DEC);

 Serial.print("maxAnlog: ");
 Serial.println(maxAnlog, DEC);

 temp = adjuster * 100;
 Serial.print("adjuster: ");
 Serial.println(temp, DEC);
}

Seven segment LED

2009-01-11T21:52:00.001-08:00

Over the holidays when gift giving was over and I could spend money again (don't ask), I made an order to both Adafruit and Sparkfun. From the latter I ordered a number of things (in later blogs) including 4 seven-segment LEDs. I mean, c'mon - they were only 95 cents.

Using my Arduino Duemilanova and protoyping kit I got one of these things working. I could display 0-9 and then turn off at the touch of a button. In the interest of sharing, here are my notes.

The image shows the finished product. A prototyping shield on top of my Duemilanova. On that is one of my single 7 segment LED (SparkFun COM-08546). The unit has 10 pins coming out of the back of it - 5 on top, and five on bottom. They fit nicely into a breadboard.

Eight of the pins are used to control the segments - one of those being the decimal dot to the right of the number. There is a dot to the left of it, but it doesn't do anything. One of the pins - dead center at the top - accepts voltage. According to the specs on SparkFun it should take only 2.2 volts, but I set the full 5 that the Arduino would deliver before I realized I probably shouldn't do that. It didn't blow it out or anything, but it was real bright. I put a resistor in line with one of the 5 volt outputs and this dimmed it a bit, but I still haven't figured out how to be more specific about controlling voltage/amps, etc. Probably a diode?

I wired up a switch same as described in LadyAda's tutorial because it was useful in counting presses - exactly what I wanted to do here. Each press of the button would increment the digit displayed, 0 through 9. After 9 it'd go dark and then repeat. The code I developed to accomplish this is as follows:


/* 
 * SegmentLEDTest4.pde
 * Test code to tick up the display
 * along with hits to the button.
 */

// state which pin will switch
int switchPin = 13;

// establish an array for our LED pins
int ledpin[] = { 11, 3, 12, 2, 5, 8, 6, 9 }; 

// establish multi-dimensional array to show numbers
int numbers[][11] = {
  { LOW,  LOW,  LOW,  HIGH, LOW,  LOW,  LOW,  HIGH }, // 0
  { HIGH, HIGH, LOW,  HIGH, HIGH, LOW,  HIGH, HIGH }, // 1
  { LOW,  HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  HIGH }, // 2
  { LOW,  HIGH, LOW,  LOW,  HIGH, LOW,  LOW,  HIGH }, // 3
  { HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  HIGH, HIGH }, // 4
  { LOW,  LOW,  HIGH, LOW,  HIGH, LOW,  LOW,  HIGH }, // 5
  { LOW,  LOW,  HIGH, LOW,  LOW,  LOW,  LOW,  HIGH }, // 6
  { LOW,  HIGH, LOW,  HIGH, HIGH, LOW,  HIGH, HIGH }, // 7
  { LOW,  LOW,  LOW,  LOW,  LOW,  LOW,  LOW,  HIGH }, // 8
  { LOW,  LOW,  LOW,  LOW,  HIGH, LOW,  HIGH, HIGH }, // 9
  { HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH }  // off
};

// other working variable schtuff
int leds = 9;
int count = 0;
int state = HIGH;
int val = LOW;
int digit = 10;


/*
 * The "run once" setup method
 */
void setup() 
{
  // set the switch pin to read
  pinMode(switchPin, INPUT);
  
  // set all the LED pins to output and high - in this case NOT ground
  for (count = 0; count < leds; count++)
  {
    pinMode(ledpin[count], OUTPUT);
    digitalWrite(ledpin[count], HIGH);
  }
}


/*
 * Main processing method
 */
void loop() 
{
  // read the switch
  val = digitalRead(switchPin);
  
  // if it's pressed, or at least state has changed
  if (val != state)
  {
    // AND that state is low, or the button is DOWN
    if (val == LOW)
    {
      // increment digit
      digit = digit + 1;

      // reset if we exceeded our limit of what we can actually display
      if (digit > 10) 
      { 
        // reset it to zero
        digit = 0; 
      }

      // show the digit
      Display();
    }
    
    // keep last
    state = val;
  }  
}


/*
  * Given a specific value, pluck out that row
  * in the multi-dimensional array and show that
  * combination of HIGH and LOW values
  */
void Display()
{
  // loop through LED pins
  for (count = 0; count < leds; count++)
  {
    // writing on (LOW or accept ground) or off (HIGH or do not accept ground) depending on digit
    digitalWrite(ledpin[count], numbers[digit][count]);
  }
}

Introduction

2009-01-11T21:15:00.000-08:00

I've never had a blog before, and for that matter, never had a reason. Now I do, or at least now I want to get some things down before I forget. If any of this winds up being useful to other people, great. If not, well, I've got notes out in the cloud I can get back to from anywhere. It has come to my attention that computers are better at remembering things than my own brain - more on that later...

For a while I've had a number of ideas regarding various gadgets I wanted to build. Most of these gadgets are of an electronic nature. I am a Software Engineer by trade. While I've got 15+ years of experience programming in various languages, I've got little or no experience with electronics. This has, until recently, stopped me from acting on any of these ideas.

With software you can debug and you can try again with little or not consequences. With electronics sometimes if you make a mistake you can fry a component - and you're out real money. I hadn't gotten into it because I was afraid. That and I didn't know where to start.

I had been trolling the web and other blogs for a while to see how other people build their stuff. It was during these trolls - and this is recently - that I discovered Arduino. It was open souce - which means something to me coming from the software industry - and low cost. The barriers to entry were all but dropped, so I plunked down some cash and bought one.

What I bought was an Arduino "Duemilanove" (2009) and a prototyping kit from Adafruit. The Arduino itself was assembled and I got a USB cable with the kit. Adafruit pointed me at a great tutorial written by one of the owners (LadyAda if you don't already know) that walked me through getting familiar with the Arduino as well as teachning me how to assemble the prototyping kit.

Some soldering and electronics indoctrination (?) later, I was hooked. I've created a number of little "projects" of my own. I wouldn't call these finished product - more doodles, or sketches designed to teach myself how to work with something in particular.

Don't get me wrong - I'm not saying I'm doing this just to learn things. It's fun playing with the thing and getting it to work. If anyone else in the programming field is reading this then they know the joy behind fiddling with code to accomplish a complicated goal. Its fun to try different things - some that work, some that don't - but to eventually come up with the solution and see your application running on the screen. Working with electronics - and the Arduino in particular - is that same joy on a different level. When I get it working I can show my wife and kids and it's not just on a computer screen; it's there in front of them, blinking, or moving a motor, or what have you.

I've created a number of projects of my own that mimic some of what I've seen out out on the web to some degree, some don't. With this blog I intend to try and post info on what I don't see many examples of. Images, code, and - if I can figure out how to write them - schematics will also be posted here.

Whenever I find errors in my own stuff, I will endeavor to correct them. I can make no claims as to how fast that will happen or how quickly new material will appear. I have a full time job, a wife, 2 kids, and many other interests all of which I must spend my limited time nurturing and caring for.

That said, enjoy and thanks for listening...