It’s been a struggle, but I finally figured out how to use a Roving Networks RN-XV WiFi module as a remote switch.  It’s not hard now that I know how it works, but figuring out was quite difficult, as the manual is apparently incorrect and the firmware it shipped with was causing problems.  Read on for the solution!

Hardware

Simple! Here’s all you need:

• An XBee breakout board (so you can plug it into your breadboard)
• An XBee Explorer (not necessary with ad-hoc mode, but I had one around so this tutorial will use it)
• 3.3V regulator (ONLY—the module has a 10% tolerance, so anything beyond that will either not work or damage the module).
• 10µF and 0.1µF capacitors for good measure (clean power is especially important when using radio devices)
• Power and Ground (Pins 1 and 10, the top and bottom pins on the left side of the module)
• An LED connected to pin 9.  In practice you’d want to put a current-limiting resistor on it, i.e. 220 ohms, but for a quick test it won’t matter.  The module only drives 8mA on this pin.
• That’s it!

set wlan phrase <your wpa password>
set wlan ssid <your ssid>
save
reboot

ftp u

telnet <module's ip address> 2000

set sys mask 0x21f2

set sys output 2 2

set sys output 0 2

References

• RN-XV User Manual (API reference, etc.)
• RN-XV Datasheet (pinout and electrical characteristics)

Today I was attempting to paste parts of an Eagle schematic I found online into a new schematic, and I was getting the following error message:

Package variant PTH1 in the old version of device set RESISTOR is not present in the new version of this device set.

This is caused by a library in the original schematic having some different package definition than the library in the new schematic.  The fix is easy: In the original schematic, go to Library > Update All.  Then you can copy and paste without the error!

Recently I experienced a somewhat baffling, unexpected problem. I was using a line like:

Serial.println('test');

And getting a series of numbers like 25536 instead of the expected text. It turned out the problem was just the use of the ‘ instead of a “. Sigh.

If you’ve been getting an Arduino error like this:

avrdude: verifying ...
avrdude: verification error, first mismatch at byte 0x0007
         0xff != 0x7f
avrdude: verification error; content mismatch

It may be as simple a fix as moving your USB cable from a hub directly to your computer—that fixed it for me!

More information: I had also been getting errors like this from avrdude:

avrdude: 2 retries during SPI command

The title says it all: for my “Deconspectrum” installation, I am burning a program onto a bunch of ATMega328 chips using a USBtinyISP (In-System Programmer).  At first I was running into a perplexing problem: the program was running much slower than it should have been.  I could tell immediately because I had a short POST (Power-On Self Test) at the beginning of the program that flashes the LED Red-Green-Blue, and it was going far slower than it should have been.

My first thought was that there was a problem with the ATMega “fuses,” which are just settings for various esoteric details of the chip’s functioning, including clock rate.  But I had never had to bother with them before.  Then I made a further discovery that the only time the program ran correctly was if I installed the Arduino bootloader first and uploaded the program using it.  What gives?

Thanks to the plucky denizens of the ITP Physical Computing list, I learned that indeed, it was a matter of fuses—the Arduino IDE apparently only sets the correct fuses when burning the bootloader, not when burning a program directly using an ISP.

The solution: use avrdude, the program that Arduino uses to actually program the chip behind the scenes, directly.  This turned out to not only solve my problem, but to make the programming process much faster and simpler.  Avrdude takes a “hex” file as an input to transfer to the chip, which is the compiled bytecode that the ATMega actually runs.  This way, I only have to compile the program once, and burn it directly—and since I’m programming about 40 chips, this makes things far faster.

All you need to do is get the AVR “CrossPack” installed (for OSX; for Windows you can use AVR Studio or a number of other packages) and then find your hex file.  In the Arduino IDE, hold Shift while pressing the “Verify” button to produce a verbose debug output.  In there you’ll see a path like this:

/var/folders/9t/7qf1680d2pqgd0hy6qbfkqsr0000gn/T/build5025172614724793636.tmp/myProgram.cpp.hex

You can then copy that file to your project directory:

cp /var/folders/.../myProgram.cpp.hex ~/Projects/myProject/myProgram.cpp.hex

And program your chip like so:

avrdude -c usbtiny -p m328p -b 57600 -U flash:w:myProgram.cpp.hex:i -U efuse:w:0x05:m -U hfuse:w:0xde:m -U lfuse:w:0xff:m

Those settings are for the ATMega328; for the 168 use:

-p m168

To get a list of parts, type:

avrdude -c avrisp

And there you have it! You’ll find that this saves a lot of time if you have to program lots of chips. Besides, not using the Arduino bootloader will save a little space on your chip

Hooking up an RGB LED to an Arduino isn’t hard by itself, but controlling it can be—if you know what color you want to display, how do you know what R, G and B values that is?

Here’s some Arduino code, adapted and simplified from Kasper Kamperman, that I am using in my Deconspectrum art installation to do just that:

void setLED(int hue, int l){
	int col[3] = {0,0,0};
	getRGB(hue, 255, l, col);
	ledWrite(col[0], col[1], col[2]);
}

void getRGB(int hue, int sat, int val, int colors[3]) {
	// hue: 0-259, sat: 0-255, val (lightness): 0-255
	int r, g, b, base;

	if (sat == 0) { // Achromatic color (gray).
		colors[0]=val;
		colors[1]=val;
		colors[2]=val;
	} else  {
		base = ((255 - sat) * val)>>8;
		switch(hue/60) {
			case 0:
				r = val;
				g = (((val-base)*hue)/60)+base;
				b = base;
				break;
			case 1:
				r = (((val-base)*(60-(hue%60)))/60)+base;
				g = val;
				b = base;
				break;
			case 2:
				r = base;
				g = val;
				b = (((val-base)*(hue%60))/60)+base;
				break;
			case 3:
				r = base;
				g = (((val-base)*(60-(hue%60)))/60)+base;
				b = val;
				break;
			case 4:
				r = (((val-base)*(hue%60))/60)+base;
				g = base;
				b = val;
				break;
			case 5:
				r = val;
				g = base;
				b = (((val-base)*(60-(hue%60)))/60)+base;
				break;
		}
		colors[0]=r;
		colors[1]=g;
		colors[2]=b;
	}
}

void ledWrite(int r, int g, int b){
	analogWrite(LED_RED, 255-r);
	analogWrite(LED_GREEN, 255-g);
	analogWrite(LED_BLUE, 255-b);
}

This gives you a very straightforward setLED function that takes a Hue from 0-359 and a Lightness from 0-255 (it could easily be adapted to specify the Saturation as well, which I have fixed at the maximum).

Note that the ledWrite function is designed for common-anode LEDs, where the microprocessor is current-sinking instead of sourcing; if you are current-sourcing, just take out the 255-val inversion.

If you’ve never gotten a printed circuit board (PCB) manufactured, it’s pretty daunting at first, but well worth the trouble—it’s exciting to get a stack of fresh, neat circuit boards of your own design in the mail, and a whole lot more fun than hand-soldering perfboard!

I use EAGLE to design my schematics and boards, and now that I’ve gotten used to its seemingly inscrutable interface, it’s quite fast and effective.  Here are some tips I’ve learned:

• Get Sparkfun’s library of common and useful parts, and check out their tutorial.  Drop the library in {Applications}/Eagle/lbr.
• If you’re using an external mouse, holding the center button down pans the layout—extremely useful, hard to live without!
• Get to know the names of the commands, like ‘add’, ‘group’, ‘move’; and remember that you can type the first couple of letters (‘gro’) instead of click the button, which is much faster usually.
• Moving groups is a bit of a pain; you first define the group by selecting it with the group tool, and then move it as a separate command.  You can right click and choose “Move Group” or Command (Ctrl on Windows)-Right Click.
• When you are moving a part, right-clicking rotates it.
• If you want to put a part on the bottom of your board instead of the top, just middle-click while moving it (or use the Mirror tool).
• When adding parts, if you want to search for something, put asterisks around it, like ‘*battery*’, or else you probably won’t find anything.
• Use Sparkfun’s CAM job to output all the files you need to get boards made.  When I go through Advanced Circuits, I need these files:
• .drd, .GBL, .GBO, .GBS, .GTL, .GTO, .GTP, .GTS
• If you only need 1 or 2 boards, Advanced Circuits offers a “Student Special” on Standard Spec boards for $33 each.  Just put “Student” in the comments box when you order.
• Another great way to get a few boards to test is with Barebones boards, which have no solder mask (the green coating) and no silkscreening.
• This has a slight danger of making it possible to accidentally bridge traces while soldering, but if you’re careful, it’s a good savings.
• When you get the boards, use a green scrub pad (a soft scouring pad) to get the traces nice and shiny.
• You can put text or graphics on a copper layer if you’ve got the room for it, which is a neat way of making up for the lack of silkscreening!
• I also found a great way to use vector images on your circuit board, which I used to put the Limina.Studio logo on my newest project.
• Got any other tips or ideas?  Post a comment and I’ll add them!

If you’ve never made a breadboard Arduino, you really ought to try it (I have a quick tutorial)—you’ll suddenly discover that you rarely need an actual (and expensive) Arduino anymore.  The Arduino is built around the Atmel ATmega microprocessor, which you can buy from various places for roughly only $4-5!

However, there are a few things about it that aren’t obvious at first, such as how to connect it to your computer via USB and make it programmable.
First off, be sure that your ATmega chip has the Arduino bootloader on it.  If you bought it from a major supplier such as Mouser or Digi-Key, it does not have the bootloader.  Sparkfun (among others) sells them with bootloaders.

Second, you’ll need an FTDI USB breakout board.  This connects to the TX and RX serial pins on the microprocessor and supplies a USB interface and firmware that your computer can recognize and use.  You’ll need the FTDI drivers for your system, which come with the Arduino software.

Third: the real work.  You need to connect some pins from the USB board to your breadboard:

• GND
• TX
• RX
• DTR
• Optional: 5V (if your breakout board supplies it)

As you can see in the photo, I soldered up a handy little header so I can plug it right into a breadboard.  The serial pins are connected like so: TX→RX, RX→TX.  DTR is connected to a .1µF capacitor that goes to the RESET pin on the ATmega (pin 1).  That pin must also be connected to +5V via a 10kΩ resistor.

The DTR pin is the secret sauce: it pulls the reset pin down, which the Arduino bootloader requires to be programmed.  If you didn’t have this, you’d have to reset it by hand.  This way, it’s completely automatic, just like a regular Arduino board.

Let me know if this works for you!  Enjoy!

If you’ve been enjoying making stuff with the Arduino, but don’t want to buy more Arduino boards just to make a new project, fear not—you don’t need them!

The Arduino board is just a convenient wrapper around the ATmega microprocessor, and it’s easy to recreate on a breadboard.  Here’s what you’ll need:

• ATmega328 (with Arduino bootloader)
• 5V regulator (i.e. L7805)
• .1µF capacitor (the little yellowish disc kind that says “104″ on it)
• 16mhz resonator
• 10kΩ resistor
• >5V power supply (can be any power supply you have, such as wall-warts, since we’re using our own regulator)
• Optional: FTDI USB breakout board (for programming from a computer)

The bootloader is what makes the microprocessor easy to program with the Arduino environment.  You can also buy ATmegas without the bootloader for about a dollar cheaper, but they must have the bootloader manually loaded on to use Arduino.

The resonator is a handy package that combines a crystal, which is where the microprocessor gets its clock signal from, and two capacitors, so all you have to do is plug it into the ATmega.

If you have an ATmega that’s already loaded with your program, you can just build this board as-is without the capacitor and leave pin 1 (RESET) connected to +5V via the 10k “pull-up” resistor.  You can even program a chip on an Arduino, remove it and plug it into your breadboard setup.

The one part remaining that I haven’t mentioned is the programming header I made, on the top right of the top photo (fully visible in the second photo).  This connects to the FTDI USB board I describe in my easy breadboard Arduino programming tutorial.  The pins are, from top to bottom: Ground (Black), RX (White), TX (Green), DTR (Yellow).

Lastly, though not pictured here, it is good practice to use decoupling capacitors on your power supply to protect your microcontroller from any irregularities, as described in this tutorial (a few pages down).