Thinking this out from the beginning, there are several parts that make up this system:

1) Controller. I’ll be using the Arduino platform – quit moaning, I can hear you. Honestly, for something so simple (take serial characters from reader, activate servo), it’s not worth prototyping a little AVR board and programming through an FTDI cable. Plus the Arduino environment already has a Servo library and there is code written for the Parallax RFID module – if you’ve read the title of this blog, you might know why this appeals to me.

2) RFID reader. The Parallax module does all the work of generating a 125KHz signal and measuring the response, and converting that to a string of characters which it sends down by a serial connection. It requires a 5V supply which can be borrowed from the Arduino and there is a pin to enable the reader – HIGH is off, LOW is on. The state of the reader is reflected in the color of the LED; oddly, red is on/ready while green is disabled.

3) Servo. A standard, continuous rotation hobby servo will be used. Since the handle is rather hard to pull, I’ll want to use the maximum voltage the servo is rated for (6V) in order to get the most torque out of it. Another thing to keep in mind is that these servos can use a lot of current, especially when fighting against a load. A 1A power supply is probably recommended, although I wasn’t able to find anything other than rough estimates for the maximum current under load.

4) Door/Servo interface. For turning the handle of my door I’ve decided to mount a small spool on the continuous servo – it will spool up wire connected to the handle, pulling the handle down. The opening of the door is the aspect I’m most worried about – I’m no mechanical engineer and this method could fail depending on the amount of torque needed and how good my spool scheme is. A linear actuator might be called for but would probably be overkill.

So far I’ve hooked up the RFID reader and used the sample code to read the values off some tags. Only tags that have their unique code programmed into the Arduino will initiate a response. I’ve used the LED conveniently located on Pin 13 to signal that a valid code has been read by the unit (instead of, and eventually in addition to, activating the servo). Also, the enable pin on the reader will be brought HIGH to turn the LED on the unit green to give a visual response that the code has been identified.

My sample code uses Pin 12 to indicate denied tags – readings that have a valid 10-character RFID code but do not match the list of allowed codes. I doubt anyone else in the building has any 125KHz rfid tags and will be waving them around my door, but this will prevent all but the most dedicated of hackers from accessing our apartment, mainly because they would have to either try to brute-force crack the unique ID or be within inches of our keyrings to read the tags.

Right now I’m waiting on some drill bits and screws to attach the spool to the servo, a 6V supply for the servo, and an Arduino Pro to build into the device so I won’t have to permanently leave in my Duemilanove that I use for prototyping. I’m also thinking of adding a buzzer to indicate that the door is opening, or perhaps a dual-color LED inside of the peephole so you can see from the outside whether your tag has been accepted or not. Stay tuned.

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.

Normal relays are pretty simple – supply voltage/current to the coil and it generates a magnetic field, which pushes the switch to the ON position. You only need one pin to run it, although you may need a transistor to supply more current because most microcontrollers can only supply 50mA, which often isn’t enough current to create a magnetic field to move the switch. You must maintain the current to keep the switch on.

Latching relays are similar to this, but once put into position, it “latches” there and requires no further current to stay in that position. This uses less power and makes the switching more reliable – if there is a decrease in current supplied, the switch will still stay in position, unlike the regular relay which could flicker. The downside is that the common types require two pins. Sending current in one direction switches on, and reversing the current switches it off.

So how do you control it? Set two pins to be outputs (the USB Power Shield uses 12/11 and 10/9 for the two relays). Write one pin LOW and the other pin HIGH. After a sufficient time to make the switching happen (50ms or less, check the datasheet for the relay), switch the HIGH pin back to low. This gives the magnetic field a place to sink, as well as making sure no more current is supplied to the coil, preventing overheating and wasting power.

Ideally, with a normal relay you’d like to force the stored current from the magnetic field back through the coil by using a flyback diode across it, but with a latched relay and current running in both directions, a diode would be needed in each direction. And that would simply cause a short circuit both ways. I’ve tested the relays used in the USB Power Shield and they don’t harm the Arduino (even over thousands of cycles) so this isn’t a huge worry here.

Below is some sample code for using the USB Power Shield with an Arduino.

Simply set up the pins for relay1 and relay2:
//give the pins names
int relay11 = 12;
int relay12 = 11;
int relay21 = 10;
int relay22 = 9;
void setup()
{
//set the pins to outputs
pinMode(relay11, OUTPUT);
pinMode(relay12, OUTPUT);
pinMode(relay21, OUTPUT);
pinMode(relay22, OUTPUT);
//make sure they start in the off position
relay1(false);
relay2(false);
// do other stuff
}

Then add these functions to turn the relays on and off:
void relay1 (bool state)
{
if (state)
{
digitalWrite(relay12,LOW); //set the current in one direction
digitalWrite(relay11,HIGH);
delay(50); //hold long enough to switch
digitalWrite(relay11,LOW); //set both to ground to stop current
}
else
{
digitalWrite(relay11,LOW);
digitalWrite(relay12,HIGH);
delay(50);
digitalWrite(relay12,LOW);
}
}
void relay2 (bool state)
{
if (state)
{
digitalWrite(relay22,LOW);
digitalWrite(relay21,HIGH);
delay(50);
digitalWrite(relay21,LOW);
}
else
{
digitalWrite(relay21,LOW);
digitalWrite(relay22,HIGH);
delay(50);
digitalWrite(relay22,LOW);
}
}

Then simply write your main loop to do whatever you wish. Call relay1(true) to turn relay1 on, call relay2(false) to turn relay2 off, etc.

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.

Arduinos with Buzzers

The most basic way to create audio using the Arduino is essentially bit-banging one of the digital pins – write high and low at the frequency you wish to generate. The downside is that this creates a nearly square wave, which sound very harsh and unnatural. Also, the “high” is 5V, which is a very high amplitude to be supplying to headphones. Constant use at this amplitude (volume) will probably damage the drivers in earbuds – use the cheap earbuds that came with your MP3 player. Using a standard 8ohm buzzer is of course the preferred method if you have one lying around. I found a buzz function online to control this – pass it the pin to buzz on, the frequency, and the length, and it does the work for you.

void buzz(int targetPin, long frequency, long length) {
long delayValue = 1000000/frequency/2; // calculate the delay value between transitions
//// 1 second's worth of microseconds, divided by the frequency, then split in half since
//// there are two phases to each cycle
long numCycles = frequency * length/ 1000; // calculate the number of cycles for proper timing
//// multiply frequency, which is really cycles per second, by the number of seconds to
//// get the total number of cycles to produce
for (long i=0; i < numCycles; i++){ // for the calculated length of time...
digitalWrite(targetPin,HIGH); // write the buzzer pin high to push out the diaphram
delayMicroseconds(delayValue); // wait for the calculated delay value
digitalWrite(targetPin,LOW); // write the buzzer pin low to pull back the diaphram
delayMicroseconds(delayValue); // wait againf or the calculated delay value
}
}


The downside is that this uses the delay function. That means your controller can't do anything else while waiting for the end of the delay. You would also have to use a delay function between the notes to create spaces. This is sufficient for a small buzzer project, but if you're looking to do more complex things (especially signals other than square wave), try consulting the Arduino Playground.

I was able to find a script for the Mario Bros theme online, and covert it into a series of buzz and delay calls. Not all the notes are correct and some of the spacing is off, but it's good enough to get the idea. The entire Arduino script is available here.

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