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

Hmmm...

[TWX_the_Linux_Zealot]

Usually I try to avoid being afflicted by glowing cyber balls, myself.

You know you need to get laid if "Hey baby, wanna cyber?" gets your balls glowing...

Nice headline...

[Gogl]

Looks like we have a new candidate for this old poll.

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..)

Better Investment

[limekiller4]

Karma be damned, this is easily one of the dumbest things I have ever seen. It's a ball. That glows. The glow shifts, for example, on the rise or fall of the stock market.

Cliff, give me $200 dollars. You can call me whenever you want. Sometimes I'll hum. Sometimes I'll hum louder.

Re:Better Investment

[dubl-u]

There are a ton of uses for it.

Note that people happily pay $30-50 for a little blinking light that tells them when they have voicemail. They'll pay a lot more than that for extra gauges on a car dash. And companies have paid millions for fancy "war room" conference rooms that continuously display important business data.

The basic prinicple is that people have to deal with a lot of invisible data, and if you can make it visible, it's easier for people to manage. Take a look, for example, at the many designs for in-house power meters. The idea is that if people have a better idea of how much electricity they're using, they'll waste less of it.

Personally, I would be tempted to hook it up so that it went slowly from green to red whenever I got behind on my email, a visible reminder of the people I'm ignoring when I get absorbed in a project. Or since I'm a freelancer, it'd be interesting to hook it up to a moving average of billable hours, so that I have a quick objective reference to check when I wonder whether a sunny day is better spent biking than coding.

Or at a company, I'd love to set it up so that it got redder and redder when people put in too much overtime on a project. Or you could hook it up so that it responded to an anonymous web poll on morale. And then perhaps another one tied to the number of open bugs. Or perhaps percentage of code covered by test suites.

I'd agree that $200 is too steep. But for $50, I could find a lot of uses for these!

Re:Better Investment

[Grab]

Win 9x has direct access to the ports. Win NT/XP needs you to go via the device drivers, but it's not a difficult problem - plenty of info for how to do it.

Beyond Logic
Parallel Port Central

Both the above have a bunch of useful stuff.

Also don't forget that you'll need to learn how to drive LEDs. I'm admin on an electronics board, so here's a blatant plug:-

BasicElectronics board, LED FAQ

(and kudos to David Bridgen and MacGregor who put that info together :-)

Grab.

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.

Re:You don't want relays

[markprus]

A solid state relay (S101S05v) is not a mechanical switch.

I need one...

[wikkiewikkie]

So I can easily keep track of the ever-changing terrorism threat level.

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.

Ah, glowing balls...

[nautical9]

... yup, this is pure /. gold for jokes...

But seriously, I've always wanted something like this for work. A simple status indicator whether the cluster of machines I'm responsible for is Working Fine (green), Having Issues (yellow), or Completely B0rked (red).

Currently, I keep a persistent browser window open to a simple web-based script that checks on the status of everything and sets its background to one of those colors based on what it finds (it's quite a bit more verbose than just that should something be wrong, but that's not the point). This is fine and dandy for my use, but for the sake of being interupted during an emergency...

It'd be really cool (and actually useful) to have a separate orb that glows the same color... so the next time my PHB runs in to tell me I forgot my TPS report cover sheet.. er.. to tell me that he's noticed a problem with the site, he'll first see the big red glow and realize I'm already aware of it.

(that, and when I'm deep into a Quake match, and can't see the little window...)

Re:Mr T.

[l810c]

I pity the fool touches my cyberballs!

Use parallel port or microcontroller

[AaronW]

One easy method of doing what you describe is with some simple microcontrollers. Years ago I worked with Motorola 68HC11s using a serial interface. If you want to control LEDs, you should be able to hook them up directly without requiring relays. You could even adjust brightness by pulsing them quickly in software. Many modern microcontrollers have built-in serial port support as well as embedded flash and RAM.

Of course controlling 8 relays or LEDs with the parallel port is much simpler.

Since the parallel port output is basically just TTL levels, just buffer it through a 74LS244 or something similar and use that to drive the LEDs directly. You can directly control each of the 8 data pins on a parallel port by writing directly to the base I/O port (i.e. port 0x378 is the default for LPT1). It's easiest to use inverting output with TTL driving LEDs.

Something like the following circuit:

D0 ---|>---/\/\/\---| D0 = parallel port data pin 0
|> is a buffer (i.e. 74LS244)
/\/\/\ is resistor
| (+5) is a 5 volt power source separate from the parallel port.

Make sure that the ground pin of the parallel port is connected to the ground of your circuit. For the 5 volts, a 7805 is a simple solution when using a separate DC power supply.

All of the above listed parts should be available at your local Radio Crap.

When D0 is 0 (low) current will flow from the 5 volt supply, through the LED and resistor and from the buffer to ground. When D0 is 1 (high), no current will flow.

When choosing a resistor, take into account the voltage drop across the LED. Blue LED's typically have a higher voltage drop than red or green. Red LEDs are typically around 0.7 volts whereas blue can be upwards of 3v.

Also make sure that whatever buffer you use can sink the appropriate amount of current. Most LEDs typically will take up to 15-20ma of current. It might also make sense to use an inverter instead of a buffer since the above circuit will cause a LED to light when the data bit is 0. a 74LS04 is a cheap easy-to-use inverter chip that is readily available.

With 20ma of current, choose a resistor based on the voltage.

Use the basic equation, V = I*R, where V is voltage in volts, I is current (in amps) and R is resistance in Ohms.

For example, for a red LED with 20 ma with a 5 volt source use:

R = (5 - 0.7) / 0.020 = 215 ohms. Since resistors come in standard values, choose the next highest value, i.e. 220 Ohms.

For blue, with a 3.6 volt drop you would use

R = (5 - 3.6) / 0.020 = 70 ohms. The closest match is 68 ohms, but it's usually best to error on the side of caution so choose the next larger value.

One thing you do not want to do is use the parallel port to drive LEDs or relays directly as you could possibly damage it. TTL outputs typically are not designed to output much current and are typically better at sinking current than sourcing it.

Note that I'm no expert on this and I'm sure you'll see better solutions listed here.

-Aaron

Lots of solutions...

[morcheeba]

Quick answer: combine RJ45 web server with serial relay driver and presto!

There are lots of these serial relay drivers ... google for it. They have all sorts of nice features (current limit, fault detection, cascadability and are controlable through the parallel port (you have to bitbang the data and clock bits). The webserver above has 3 general purpose I/Os - enough to control a relay driver.

But, you probablly want an actual A/D converter (preferably with a current output) or a digital potentiometer. There are lots of mfgs of these products, but Maxim is pretty liberal with samples (plus they have some neat innovative products!)

Re:parallel vs. serial

[Uller-RM]

One thing to remember though is that you're not allowed access to the ports under Win32 NT-family kernels except through a Ring 0 driver. That can get a little ugly.

Google for "Beyond Logic" and you'll find a site that lays out more info on the legacy ports and on making peripherals for them (and for USB) than you could read in a day.

(Mind, it's pretty easy to make a serial one too. There's a UART called the CDP6402 that's specifically designed to run without a master uC; just add an osc to get 4x the desired baud rate and use an octal latch to maintain the output with an RC circuit to generate the rcv ack pulse, and you're set.)

Actually rather easy with the parallel port.

[fwc]

All you need are the following:

1) 25 PIN MALE DB Connector (like would plug into the parallel port) - OR, probably easier, grab like a 6' or longer 25pin Parallel Printer or extension cable and chomp the end which doesn't plug into the computer off.

2) 8 superbright leds.

3) 8 10K resistors.

4) 8 2N2222 or other NPN transistors (Just go to radio shack and get a bulk package of "NPN switchint ransistors")

5) 8 "smaller" resistors. Like roughly 500 ohm, but be prepared to experiment with the value. Lower value=brighter, but if you go too low you will burn out the LED. There *IS* a formula for the smallest permitted value. I won't go into that here.

6) Perfboard to put it all on

7) 9 or 12V DC wall-mount supply (or similar).

A little background:

The parallel port on the PC has 8 outputs, on pins 2-9 of the 25 pin connector. The ground for these are on pins 18-25.

You can technically get away with just wiring the led directly to an output port, then to a resistor which then connects to the ground. Google for "parallel port led"

However, it is likely that you will need more current than the parallel port will provide. For this you can use a transistor to act as a solid state switch.

Here's a description of the schematic:

For each output pin:

1) Wire the output pin on the parallel port to one side of a 10K resistor.

2) Wire the other side of the 10K resistor to the base pin on the transistor.

3) Wire the emitter pin on the transistor to circuit ground.

4) Wire from the collector pin on the tranmitter to the pin closest to the "flat edge" on the LED.

5) Connect the other LED pin to the "smaller value" resistor.

6) Connect the remaining pin on the "smaller" value resistor to the + wire of the power supply.

ALSO, do the following:

1) Connect the ground pins (18-25) of the parallel port connector to the "circuit ground" mentioned above.

2) Connect the "-" wire of the power supply to the "circuit ground".

You can test this before plugging into the computer by plugging the DC adapter in and then jumpering between the + wire of the power supply and each output pin on the cable you are going to plug into the computer. The corresponding LED should light.

I'd recommend just doing the first led first to make sure everything works.

NOTE: YOU CAN BLOW OUT THE COMPUTER PORT IF YOU DO THIS WRONG. I HAVE NOT CHECKED THE ABOVE DESCRIPTION SO IT MIGHT BE WRONG AND MAY CAUSE THIS EVEN IF YOU FOLLOW THE INSTRUCTIONS EXACTLY.

If you need more LEDS on a given output (like 2 or 3 to get enough light), you can just connect a LED/resistor pair in parallel with the existing one (all of the LEDS are connected to the transistor, all of the resistors are connected to the + power supply connection, and each led is connected to it's own resistor).

You basically drive this by outputting data to the parallel port. You output a single byte at a time - the most recent byte is what the leds are set to on or off.
If you want to vary the brightness of the LED's you can actually do it by turning them on and off quickly in software. A simple timing loop which have the leds on 50% of the time would result in the leds being 50% dimmer than if they were just left on. Of course you have to do this fast enough so they don't "flicker" or blink.

Use Atmel microcontrollers

[Sowbug]

Lotsa links here...

First of all, the 2002 Burning Man project I did that involved a couple hundred RGB LEDs spinning in a persistence-of-vision-based nighttime animated display. Here is the best picture of it. This is the page about the development details.

The LEDs I used were manufactured by Kingbright. The model I used, the LF819EMBGMBC, is big (10mm) and relatively bright for an RGB LED. I couldn't find any U.S. retailers that actually told the truth about whether they stocked them, so I ended up buying 400 directly from Kingbright for I think a little more than $2.50 each. I still have a few left.

Atmel AVR microcontrollers are just a few bucks each, easily programmable with the STK-500 programmer, also cheap at around $80. I used the ATMega8, which was more than sufficient for my needs. I imagine the original Slashdotter could use one of the ATTiny MCUs, since it really needs only 3 or 4 I/O lines (fewer depending on how many helper circuits you decide to use).

The boards were manufactured by PCBExpress and I was very happy with them. The CAD/CAM software was Eagle, which except for some crashing/redrawing bugs was really amazing. The version I used was free. I tried to buy it but CadSoft has (had?) a fairly crazy pricing scheme that actually left you worse off in terms of acceptable usage if you paid them money than if you used the free version.

The best part of using the Atmel MCU was that GCC can cross-compile for it. So you're basically writing regular old C code but it runs on a little tiny piece of silicon. You'll want to subscribe to the quite active avr-gcc mailing list. Save every message from Marek Michalkiewicz; in my opinion he's the god of GCC-for-AVR development.

Re:parallel vs. serial

[pirodude]

download a set of drivers called "PortTalk", they work very well for allowing programs to access the parallel port under nt/2k/xp and they include quite a bit of sample code for doing it also.

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!

Re:...Glowing balls?

[Jugalator]

I read the topic, and after reading the beginning "krezel says: So I've been drooling..." I didn't know if I should continue. :-O

Re:parallel vs. serial

[Gordonjcp]

I've actually done this with eight LEDs (four red, four green) and the parallel port on my firewall machine. I did it mostly because it had a cool smoked perspex cover that slides over the drive bays, and the LEDs shining through it looks pretty cool. Especially when you make them flash and do stuff. Have a look at some pics.

In this case, the LEDs have their anodes connected together, and brought back to the 5v rail, and their cathodes connected to the parallel port pins through 220 ohm resistors. You then bring the appropriate pin low to turn the LED on. There's a good reason for doing it "backwards" - the gates driving the parallel port can sink more current than they can source. That is to say, the transistor pulling the pin to ground is "stronger" than the one pulling it to +5v, so it's more suitable for turning on an LED. You could use two resistors and a small transistor per pin, too. If you like.

Re:parallel vs. serial

[MadCow42]

Actually you can get 12 "output" channels out of a parallel interface if you really want to... the 8 data channels, plus the "strobe", "autofeed", "init", and "select-in" channels (pins 1, 14, 16, 17, but 1, 14, and 17 are "inverted" watch out).

I use the parallel port to drive three stepper motors. Pretty easy to do, and your circuit would be just as easy. You could actually use the same circuit, but simply change the +12V input to the correct voltage, and hook the LED's in where the motor phases would be.

See my crude circuit diagram here:

www.lenticularshareware.com/downloads/stepper_circ uit.jpg

FYI, you can also get 4 "input" channels from the parallel port at the same time, I use them for limit switches to set the position of the steppers to "home". (see diagram)

MadCow.