Top View of the USB Power Shield v2.0

• Smaller Size – cost is determined by size, so I brought it down to the bare minimum – just enough to cover the Arduino pins.
• Power Planes – Added a 5V plane on top and a GND plane on the bottom to increase the reliability of the design, allow higher current, and also act as a bit of a heatsink
• Thicker Traces – the traces in v1.0 are only 8mil, which is pretty small and is really only good for about 200mA. Some devices powered here may need more than that. To support the USB spec of 500mA per device, I’ve bumped up all the traces to 16mil. There’s plenty of space for traces anyways.
• Remove the Vin LED – unnecessary.
• Flush caps – leave space so the caps can be bent down, so another shield can be fitted on top of this one. The regulator is also mounted on the edge to allow bending it down, although in many application it will need a heatsink so they may not clear even when bent down.

And here it is built:

Parts needed:
Keep in mind not all parts on the board are needed. For instance, if you’re powering a single pair of lights (or anything running at <300ma) you can just use the Arduino's built in DC-in with voltage regulator (USB power alone is not going to cut it). If that's the case, you can leave out the 7805 regulator, the 100uF capacitor (keep the 10uF), and the power diode D1. You also don't have to have the power indicator LED or its resistor RLED. And if you're only controlling one device, you only need one relay and one USB connector. All in all, you can get the parts cost for this board down to about $4 at the minimum configuration. If you want to go all out, here's what you'll need:

2x G6JU-2P-Y-DC4.5 Relays @ ~$2.85 each
2x USB A connectors @ ~$0.45 each
1x 7805 5V Regulator @ ~$0.37
1x DC-in 2.1mm Jack @ ~$0.63
1x 100uF 25V capacitor @ ~$0.03
1x 10uF 25V (10V ok) capacitor @ ~$0.03
1x 1N4004 standard Diode @ ~$0.04
1x 450-500 ohm resistor @ ~$0.04
1x 6x6mm pushbutton switch @ ~$0.24
1x 5mm LED (any type/color is fine) @ ~$0.08
1x 28+ pin row .1″ male header @ ~0.11

Total parts cost ~$8.17

You’ll also need a heatsink for the regulator if you plan on drawing more than ~200ma from it, those can range from $0.30 to $2, depending on size and complexity. There is a quite large one in the picture above as I was using it to charge my MP3 player, which draws a lot of current.

Stay tuned for an assembly guide. Also, I’ll be selling the few extra boards I have at cost to those interested, details to come soon.

That’s right, the very first prototype board actually functions. I’m amazed too.

The first working prototype

Of course, there are some changes I’d like to make – expect to see a v2.0 very soon. A few big things will be happening in the next revision, including addition of power planes and making the board smaller to reduce cost (by 30% ! ).

If anyone’s interested in ordering one of these from BatchPCB, email me and I’ll send you the link and parts list . I don’t want to make it completely public yet with the upcoming revision, which will be cheaper and more stable, but if you want to try it now let me know.

Also expect to see a basic Arduino library for controlling it soon, and we’re working on completing the WootOff application – the pressure’s on now that there is a working board!

As such, I made some modifications to the board and put it into Gerber files using Eagle, uploaded them to BatchPCB, and am now waiting for the first one to arrive so that I can populate and test it. In the meantime, I need to get around to packaging the WootOff software for distribution, and come up with some documentation of this project that’s more readable than this series of blog posts.

Here’s the board schematic of the Prototype board:

USB Power Shield v1.0 - Prototype

There are two USB ports for anything that takes USB power (5V) – of course, these ports are for power only (no data). You can use these to control the Woot-Off lights without cutting and soldering the cord, and something else (USB Fan? Light? Humping Dog?). There are also four pads toward the middle so you can solder in anything else that takes 5V power.

USB Power Shield board

Schematic here.

Since the Arduino can only supply maybe 300mA while on USB power and 600mA from its small 5V regulator (using DC in), I’ve included the stuff necessary to add a 7805 regulator and related components to allow up to 1A (if you use a heatsink). You can always leave these pads empty if you don’t plan on using that much power. The Woot-Off Lights will need at least the 5V regulator on the Arduino. There are also LEDs to show if the regulator and board itself are powered – these can be omitted as well.

The board uses four 2N3906 to control power of up to 200mA at 5V to four devices. By writing the corresponding pin LOW on the Arduino, you turn on the transistor and allow current to flow from 5V to the device (and then, hopefully, out to GND). Very Simple.

Serial control of the lights in Python took longer than expected – we could have saved over an hour of troubleshooting had we simply waited two seconds between opening the serial connection and transmitting the first byte (allowing the connection protocols time to complete), but instead we tried half a dozen Python libraries, thinking the problem was somewhere in the code library. Lesson learned – the exact specifics of interaction between software and hardware is not to be ignored.

We then were able to force the Woot Tracker to update it’s cache, pull down the XML file generated by the tracker, parse it for the value we are looking for (wootoff, true or false), and take action based upon it.

Now we’re simply trying to figure out how to package the program into an .exe that can be hidden in the tray, and also figure out how the timing should work – I would prefer that my server didn’t get a ton of update requests at the same time, especially during a Woot-Off. Right now it looks like we’ll run a custom version of the software on our machine to update the tracker, and the software we distribute publicly will simply pull down the XML (without first updating the cache, because our software has already done so).

On the hardware side of things, I’ve consolidated the driver circuitry onto a small piece of protoboard that pops into the Arduino like a shield. I’ve also cut up an Altoids tin and housed the assembly inside of it. Don’t forget the isolate the top/bottom of the board with electrical tape or similar so the metal case doesn’t short anything.

Here’s a few pictures of the assembly, with the lights being controlled via the Python application.

Quick and Dirty Schematic for Woot-Off Light Control

Let’s take it from left to right. USB input to the Arduino to send serial data. The current from the USB port is not sufficient to start the motors (they require a bit of boost when turned on and consume less current during normal operation), therefore we use the DC input on the Arduino board to supplement the USB. Feed it somewhere between 7-10V (up to 12V should be fine). The Arduino contains a regulator to lower the Vin down to 5V.

The 5V is then connected to the V+ of the lights (red wire). The GND of the lights is connected to Pin 18 of the ULN2803 IC. The ULN2803 also has it’s own 5V/GND connections (the 5V connection is necessary in this application because of the inductance of the motors). When the ULN2803 receives a HIGH input on Pin 1 (coming from Pin 9 on Arduino), it connects Pin 18 to GND (note that this is the same for all pins on the IC except 9/10 – i.e., Pin 2 controls Pin 17, etc). Thus, the lights are now fully connected to both 5V and GND, the circuit is complete, and we have spinny lights.

Work continues on reading a Woot-Off Tracker from a C++ application – if anyone has tips or ideas, they’d be appreciated.

On the other end of the pipe, the Arduino is listening to the serial communication. The sketch I have set up simply sets pin 9 to HIGH when it receives a 1, and LOW when it receives a 0. That’s it. Then the hardware is controlled as discussed in the previous post.

Prototype console application for Arduino Serial communication

So at this point we have:
a) Hardware control of lights
b) Windows console application for serial communication on/off

Which leaves:
c) Having the application read the tracker for wootoff status
d) Packaging it together in a nice, pretty package

So for those following along with an Arduino, I’m posting the Arduino sketch and the console application below. If you want to use a pin other than pin 9 on the arduino, just modify that part at the top of the sketch. Obviously, you should upload the sketch to the Arduino first, exit the Arduino software (since only one application can access the port at a time), identify which port your Arduino is on, and then run the console application. I AM NOT RESPONSIBLE FOR ANY HORRIBLE THINGS THAT RESULT FROM THE USE OF THIS SOFTWARE, largely because I started college as a CS major and switched to EE a year later because I hate coding. That said, it works fine on my and my roommate’s machines.

Arduino Sketch
Windows Console Application

Occasionally, Woot has extravaganzas where they post item after item in what is known as a woot-off. Little .gif lights spin round and round to alert visitors to this spectacle. Playing on this, Woot occasionally sells physical woot-off lights. They run off of USB power, with a switch in each light/motor piece. Since it’s a standard 5V connection, this opens the doors for all sorts of hackery.

The ultimate goal of this project is to have these lights come on whenever there is a woot-off.

If you aren’t already familiar with the Arduino, become familiar now. I’ll wait.

Ok, so the Arduino is a microcontroller system with a USB-serial input communication, a microprocessor with a bootloader to run “sketches”, and the ability to control over a dozen digital logic pins (including a few with PWM or Analog-In).

The setup will use a PC application for monitoring a “Woot Tracker” (many of these are available online to reduce load on Woot’s own servers). The application will check for the presence of the woot-off lights logo, indicating a woot-off – in the future, the lights will be activated by each changing of an item. The application will then send a byte over serial to indicate the woot-off status to the Arduino. Based on the input from the computer, the Arduino will turn the lights on or off.

Great – so in order to turn on the lights all we have to do is turn on one of the Arduino’s pins (they are 5V at digital high). Unfortunately each pin is only capable of supplying at most 50mA, and these lights run on over 100mA. Luckily, the 5V power regulator on the Arduino is capable of supplying much more current – up to 500mA or so if a good DC power supply is used. So if we hook up the positive lead of these unit to the 5V, we now need to control the ground connection to control the circuit – connect the ground and the lights go on because the circuit completes.

The ULN2803 chip provides this exact function. The chip is connected to 5V and ground. The ground from the device to be controlled is connected to a pin (remember that the positive of the device is already connected to 5V), and the control signal from the Arduino is connected to the corresponding control pin. When the control pin sees 5V (from the Arduino control signal), the ground lead from the device is connected to the ground of the chip, completing the circuit and sending current to the device. In this case, the lights spin up.

Early Woot-Off Light Software/Arduino Control

So far I have the hardware running, and have used the Arduino PC software to send input down the serial connection, turning the lights on and off. The next step will be to write an application to send serial information, and then to expand that application to search the textfile of the woot tracker for the lights.gif. The final stage will be to integrate all the hardware into a small package so the device can be used permanently.