USB is moving up in the world. Specifically, it’s going vertical.

There are plenty of board-level standards out there and even more companies that support them. PCI Express, VMEbus, PC/104, S-bus (remember that one?), ATCA… the list goes on. Board-level standards are as ubiquitous as they are useful, and the healthy board-level market enables a whole layer of system-level integrators and developers. Not everyone wants or needs to develop all their hardware from scratch, so buying boards is a quick way to produce a custom system without ever reaching for the soldering iron.

So in a crowded market like this, you’d think there would be no room for yet another board-level standard, right? Au, contraire, mes amis – we have not heard the last word in this play. There’s still plenty of innovatin’ to be done.

Enter Micro/Sys, a maker of PC/104 boards. For the uninitiated, PC/104 is basically the x86 processor bus (aka, the ISA bus of older PCs) mated to small-form-factor boards. The boards are about the size of your hand and are stackable, one atop the other. Matching top and bottom connectors on each board allow the bus signals to pass through each board in the stack, combing them all electrically as well as physically.

Now Micro/Sys is leading the effort to standardize something called Stackable USB (www.stackableusb.com ). Like PC/104 boards, Stackable USB boards are, well, stackable. Up to 16 boards can be piled up to make a multi-story embedded skyscraper about six inches on a side. As before, connectors pass the USB signals from board to board, along with power and ground, so that the boards make a system-level sandwich. You can pop Stackable USB boards onto a motherboard as expansion cards, or you can use them by themselves, creating a modular stackable system.  
In short, Stackable USB is just like PC/104 but replaces the x86 processor bus with the USB 2.0 interface. The familiar USB cable connector is gone, of course, but the electrical specifications all stay the same. The silicon won’t know the difference. Like any USB 2.0 interface, it’s tolerant of older USB 1.1 devices, so you can safely plug in your old keyboard or memory stick.

There are plenty of advantages to Stackable USB – and a few downsides. In the plus column, USB is processor-agnostic. It doesn’t care what microprocessor or microcontroller you’re using, whereas PC/104 was heavily x86-centric. With PC/104 cards, you pretty much had to use x86 processors, usually the ’186 or ’386 from Intel or AMD. USB, on the other hand, shows up on everything from 8-bit Atmel microcontrollers to 32-bit PowerPC, ARM, and MIPS processors. Now your choice of board doesn’t have to dictate your choice of processor – and, by implication, your choice of software. 

This is especially important now that Intel has pulled the plug on its venerable ’186, ’286, and ’386 chips. After a long and productive life, these processors have finally been put out to pasture. The Pentium M is now Intel’s entry-level x86 chip, but that’s way too much processor for many embedded designers. It’s also not clear that that device will have a very long service life. Before you know it, Core 2 Duo or Itanium 2 might be considered embedded processors. The wheels of PC progress move quickly, and embedded designers looking for stability from their x86 vendors are repeatedly disappointed. Divorcing the board interface from the processor interface is one way to maintain some constancy in an impermanent world of continual processor upgrades.  

USB also lives up to its name of being universal, or at least ubiquitous. Finding processors and peripheral chips with a USB interface is a piece of cake. You can theoretically plug in anything from a webcam to a GPS receiver to your iPod with little or no trouble. (Granted, many commercial USB devices assume you’ll have Windows or MacOS drivers, but at least the hardware is compatible.) USB’s popularity gives you access to a big world of peripherals and components, cracking open the door to mass-produced products instead of just specialized embedded devices.

But like duct tape or The Force, there’s a dark side. Stackable USB is based, obviously enough, on the USB standard, and that means you’ll get 12 Mbit/sec of bandwidth, maximum. Compare that to the 64 Mbit/sec that PC/104 offers, and it’s clear you’ll take a big hit on bandwidth. Sure, future versions of high-speed USB may hit a whopping 480 Mbit/sec, but that’s still a way off and may require different connectors and/or signaling protocols. For now, Stackable USB might be a step backwards from PC/104.

But maybe not. The PC/104 bus is shared among all the boards in the stack, which have to take turns using the bus. USB, on the other hand, is a point-to-point topology, so each and every board gets its own private 12 Mbit/sec channel. With the maximum loadout of 16 boards, that’s 192 Mbit/sec of total aggregate bandwidth. So individually, each board has a narrower pipe but the whole stack has more total bandwidth. Got it?

Whether or not this affects you depends on how data-hungry your boards are. If you’re doing high-end machine vision, the USB interface probably isn’t fast enough. But if you’re plunking down industrial I/O cards, user interfaces, or other medium-speed peripherals you’re probably fine. Indeed, you might be better off with Stackable USB over PC/104 because the latter’s shared bus and arbitration overhead eat into individual boards’ share of the bandwidth pie.

Then there’s the software. For all its apparent simplicity, USB can be tough to use. First-time engineers are often aghast at the amount of software that’s required to make USB work. Its universal nature means you have to expect the unexpected; there’s no telling what kind of devices might be plugged in hot, while the system is running. Peripherals we’ve never imagined (who anticipated webcams or iPods in 1995?) have to integrate with the more mundane serial drivers, download cables, and memory sticks. That kind of real-time plug-and-play flexibility requires clever software and lots of it.

Fortunately, most USB-compatible chips come with USB drivers. Unfortunately, most of those drivers are for Windows hosts, with MacOS or Linux support if you’re lucky. So embedded developers will do what they’ve always done: write their own drivers and test them as much as their schedule allows. USB compatibility testing is notoriously difficult, however, and in all fairness, I think this is where most embedded programmers will take shortcuts. In a relatively closed, embedded environment, you’re not likely to see PlayStation game controllers or steering wheels suddenly appear on your USB ports, so you can safely omit support for those. Whole classes of USB devices can be ignored with impunity. But these prudent shortcuts will weaken the very universality that makes USB attractive in the first place. If USB becomes nothing more than your own private bus supporting your own pre-approved devices, then it’s not really USB. That may be fine, but it’s a decision that engineers should make with their eyes open instead of by accident. Full plug-and-play support is tough but pays off in downstream reliability and flexibility.

On the whole, I like Stackable USB, in part because it takes advantage of existing standards instead of creating new ones out of whole cloth. USB itself is certainly popular and well-supported. It’s easy to find USB-compatible chips and almost as easy to hire USB-compatible programmers. More than that, Stackable USB breaks the strong x86 connection that PC/104 has. Like a lot of early board and bus standards, PC/104 was little more than an extension of the processor’s own system bus. Stackable USB, in contrast, treats processors and peripherals from all vendors equally. Want to mix an ARM processor with your Freescale peripheral and Fujitsu microcontroller, all without cracking open a databook? Now you can. Surely that’s A Good Thing.