Building Your Own Glowing Cyber-Balls?

krezel asks: "So I've been drooling over the Ambient Orb, a cool little gadget 'glowing ball' that you changes colors based the 'health' of things you specify. It can do stuff like fade from red to yellow to green as your stock portfolio improves. However, being a poor college student I can't afford its $200 price tag. I've found lots of sources for super bright multi-color LED's. Cast a couple of them in some translucent resin, hook them up to a power source, and you've got yourself a cheap glowing ball. But I've yet to find any good information on how to build hardware that will let me control relays for devices like this through my serial or parallel port. Basically I'm looking for a cheap way to build a board that will let me control 4-8 relays (for each color) over my serial port, and some info on how to write the software for it. This could be a very cool project, and I plan on making the plans available, and the code Open Source, when I'm done with it. Any ideas?"

Comments

More than 8 colors?

[diegoq]

Don't you want more than 8 colors? If you use relays, you can only turn on or off each of the red/green/blue colors. But if you vary the current through each led, or vary the duty cycle by pulsing the leds quickly, then you can get more colors (like 24 bit color!).

Re:More than 8 colors?

[adri]

how high?

dot-array LED signs are generally built using some form of scanning setup - you enable a row, then shift-on the bits. Then, next row, shift on the bits, etc. Not all the LEDs are on at any given time.

So you can get away with pulsing them with higher current than they're rated at. Which is a bit of a bugger - if you hit the 'stop' button or the sign crashed, any on LEDs would burn out. I used to work making LED signs for a little while - we had a set of damaged signs to test code on.

(Which got real expensive when Blue LEDs came out so I _think_ the guys implemented some 'no clock? no driving power!' circuitry in case the testing code crashed.. :)

(A cute tidbit: our signs had 4-LED RGB elements - one blue, one green, two red. the red leds weren't as bright to the eye, so we needed two of em..)

That's missing a key point...

[eric434]

the Ambient Orb runs off a wireless network... no computer needed, and you can control it from anywhere in the world (theoretically). To manage that, you'd have to build an 802.11b -> relay interface, at least - if not a cellular one.

Now, assuming you don't want to muck about with that (and who does), your best bet would be to not use relays in the first place - they're loud, slow, and not gradual. Use a Basic Stamp from Parallax and write some code to output a PWM (Pulse Width Modulated) voltage to three different pins - one for each color. (Chances are you'll be using either one 4-pin, 3 color LED or 3 leds (red, green, blue). Infrared or UV leds could be interesting, but aren't recommended...) Then you can either leave the BASIC stamp connected to your serial port and controlled via DEBUG or SERIN (IIRC) commands from your host computer (and write some corresponding code for the host), or you can leave it standing alone and interface to it using any one of the who-knows-how-many add-on boards Parallax sells. (you might want to check out the Communications page - that modem looks like a good thing to try)

Re:That's missing a key point...

[spongman]

alternatively, scrounge some simple electronics components (bread board, power supply), build yourself an oscilloscope, get an Atmel AVR microcontroller, connect it to your computer using a parallel port interface, compile code with GCC and upload it to your device.

Note: some assembly required, batteries not included.

Re:That's missing a key point...

[cybermace5]

Don't use a Basic Stamp. They're overpriced and low on performance. The interpreter really takes the zing out of the microcontroller...say, in a similar way that certain OS's can change the operation of your desktop computer....

Really, you can get a small PIC (since that's where most of the hobbyist development resources are right now) in a 16-or so pin package you can toss on a Rat Shack breadboard. Get one with an onboard UART and life gets even simpler. The next step is to write code to take a string of values, and PWM a few pins according the the values. After that, everything depends on the computer side.

My room at school had indicator LEDs (one mounted in the door peephole - go figure) for new email, and a robotic webcam running off a 486 webserver.

If you want to get fancy, use USB.

I have a PIC board (way overspecced for this application, of course) and two USB boards on my desk right now, that could do the task with an hour of coding and soldering a few LEDs.

Casting resin ain't that simple either...

[Olmy's Jart]

Having done some large castings in casting resin (clear and with opaque or translucent dyes), I can tell you that it's not all that simple to just cast a ball that size either. The casting material is going to be expensive to begin with. And if you don't get the hardner mix ratio just right, that stuff it going to crack and craze like crazy (split a few "paper-weights" in half). It gives off heat (from the chemical reaction as it "cures") which can damage really thick objects, like a 6 inch ball. I'd be willing to bet that what they have is not "hobbiest grade" casting material. It's more likely commercial grade plexiglass type material with a translucent dye added. It might not even be chemically cured like epoxy resins but may be cure thermally or by UV light (former - likely, later - possible but highly unlikely). Plexiglass resins become soft and pliable as you warm them (within reason - moderately high heat burns them easily) but casting resin does not - it cracks and crazes and shatters. The dye would be similar to the casting dyes you would get at a hobby shop. You MIGHT be able to cast a ball that size, if you are lucky, in casting resin but keep it away from large temperature changes and bright sunlight (which damages through both large temperature gradients and UV breakdown damage). You may find that this isn't a cost-effective "do it yourself project" after all.

Amen to the PIC chip! Here's some code...

[wirelessbuzzers]

Just to get you started. It's mostly left over from my wireless buzzer project. Since PICs don't come with 3 PWM units, you can just:

do_red: // software PWM for red color
DECFSZ $redtemp, F //0x41, for instance
GOTO do_green
MOVF $red, W //0x51
MOVWF $redtemp
XORLW -1
MOVWF $red
MOVLW $redbit //bit number of red LEDs on the port, say 0x1
XORWF PORTA, F

do_green: s/green/blue/; s/red/green/;
do_blue: s/blue/red/; s/green/blue/;

If you want it to pulsate, substitute GOTO do_counter for the last GOTO do_red:

do_counter:
DECFSZ $counter_divide_1
GOTO do_red

// Check if the interrupt code wants our attention
BTFSC $interrupt_attn, $attn_bit
GOTO get_new_params // get new pulsation parameters, you can write this

DECFSZ $counter_divide_2
GOTO do_red
MOVLW 0xF // approximate delay loop for 30 HZ update
MOVWF $counter_divide_2

// if you're running at 4MHz, this code will be called about 30 times per second.

BTFSS $pulsate_control, $pulsate_bit // Are we pulsating?
GOTO do_red
MOVLW $redbit || $greenbit || $bluebit
MOVWF PORTA // reset the LEDS
DECFSZ $step_counter // check if we should go opposite
GOTO calccolors

BTFSS $pulsate_control, $fixed_num // Do we have a fixed number of cycles?
GOTO invert_deltas

DECFSZ $num_pulses
GOTO invert_deltas

CLRF $pulsate_control // not pulsating anymore
GOTO do_red

invert_deltas:
MOVF $num_steps, W
MOVWF $step_counter // reload the step counter
COMF $red_delta, F
INCF $red_delta, F // invert the delta registers
COMF $green_delta, F
INCF $green_delta, F
COMF $blue_delta, F
INCF $blue_delta, F

calccolors: // actual color adjustment
MOVF $red_delta, W
ADDWF $red, F
MOVF $blue_delta, W
ADDWF $blue, F
MOVF $green_delta, W
ADDWF $green, F
GOTO do_red

I'm a bit rusty on my PIC, so check the mnemonics and look for typos. Initialize $steps to be the number of "frames" to take to wax or wane in color, $red / $green / $blue to the initial color (in 256ths), and $red_delta, $green_delta, $blue_delta to be the change per step. You can control these from a USB or serial interface without too much pain. Just have your interrupt code set $interrupt_attn bit number $attn_bit. To do only a fixed number of pulses, set the bit $pulsate_control -> $fixed_num, and set $num_pulses to the number of half-pulses you want to do. IE, set it to 1 for a fade, 2 for a pulse, 3 for a pulse then a fade...

In terms of hardware, you'd need the jack for the port, the power cord, a PIC chip, a transistor for each color, and a bunch of LEDs/resistors of each color. Easy stuff really. Let me know what you come up with. If you use USB, I'd be especially interested, as I have a Mac (no serial port). Good luck!