For a few months after Raspberry Pi came out, the choice was pretty simple. If you wanted to talk to arbitrary electronics, your best bet was to buy an Arduino microcontroller board; if you needed the power of an ARM-based processor to run Linux, the Raspberry Pi single-board computer (SBC) was the obvious choice (that is, if you could get your hands on one. Delivery issues are mostly resolved, but last year some people waited more than six months for their Pi).
Before Arduino and Raspberry Pi, things were more complicated. Going forward, things aren’t just complicated again — they’re bewildering. We’re now seeing an explosion of new boards coming to market, and there’s no reason to expect the trend to slow in the next year or two. If anything, I’m expecting more new boards to appear, not less — although most of them will disappear just as rapidly. If you’re old enough to remember the wide range of personal computers that sprung up in the early years of that industry — each with a different manufacturer, each based around a different CPU — then the state of the modern microcontroller board market may seem familiar. One looming question is whether, on the heels of this explosion in diversity, we’ll see the rise of a monoculture, as we did in the desktop market. Or whether, perhaps, a more interesting ecosystem will emerge.
Life Before Arduino
The commercial microcontroller story starts, arguably, in 1971, with the arrival of the 4-bit Intel 4004. It was the second complete single-chip CPU in history, and the first to be commercially available. Its successor, the 8-bit 8008, would form the basis of the first personal computers.
Other processors from the era — like the Z80 that powered the TRS-80 in the U.S. and the Sinclair ZX Spectrum in the U.K., as well as the 6502 that powered the Apple II — are still around. Or at least their immediate descendants are still around, and now used in so-called “embedded systems.”
But it was Microchip Technology’s PIC microcontroller, dating from 1975, that became the backbone of the hobbyist market for many years, due to a combination of factors including low cost, ready availability, and a proliferation of free programming tools. The PIC is an MCU — a complete microcontroller unit — with on-board processor, memory, and programmable I/O.
Still available off-the-shelf today at less than $2 a chip, the PIC is a workhorse. Bare PIC microcontrollers can be a bit tricky to deal with if you’re not used to low-level C programming, so Picaxe chips — standard PICs preprogrammed with firmware allowing them to “understand” BASIC or easy graphical flowchart languages — have become a popular way to use the PIC, especially in education.
While you can buy bare Picaxe chips, if you’re new to the scene it’s probably better to get a Picaxe starter kit designed to allow easy experimentation. In general these kit boards are made for prototyping and teaching rather than as bases for standalone projects.
The Parallax BASIC Stamp board — which is programmed in another variant of BASIC — is also a good alternative if you want to use the low-cost PIC microcontroller. Unlike Picaxe development boards, the BASIC Stamp is sold in standalone, single-board modules, like the more modern Arduino, that are intended to be the heart of a project. The BASIC Stamp also exploits the concept of add-on “carrier boards,” like the Arduino “shield” system, except the Stamp sits on top of the add-on, rather than underneath. These carrier boards look a lot like Picaxe starter kits.
The March of Arduino
Every so often a piece of technology can become a lever that moves the world, just a little bit. The Arduino is one of those levers.
It started off as a project to give artists access to embedded microprocessors for interaction design projects, but I think it’s going to end up in a museum, someday, as a building block of the future world. Arduino allows rapid, cheap, prototyping for embedded systems. It turns what used to be fairly tough hardware problems into much simpler software problems. And it’s become the poster child of the Maker Movement.
Based around the 8-bit Atmel AVR microcontroller line, the Arduino board breaks out digital, analog, and other pins from the controller in an idiosyncratic footprint that’s become a de facto industry standard. It’s a solid development platform, both for experienced hardware hackers and absolute beginners.
The real power of Arduino isn’t really in the hardware, but the software — the Arduino IDE. While there are many other boards offering similar functionality, the Arduino has best succeeded at packing the complex, messy details of microcontroller programming in a user-friendly package. It has spawned many imitators and derivatives, and a huge community.
For now, at least, Arduino sits apart from the rest of the microcontroller market, and 20 or 30 years in the future we may look back on it like the Commodore 64, the Apple II, or (for the true old-timers) the PDP-11. These days Arduino is almost always a newbie’s “first board,” and it’s influencing an entire generation of makers.
The latest board in the series, the Arduino Leonardo, differs from its predecessors in that, in addition to the virtual serial port necessary to transfer code from the IDE to the board, it can also appear to a connected computer as a USB mouse and keyboard.
The Tessel will ship with an Arduino extension board for plugging in shields. It should even be able to use Arduino libraries and run sketches directly. It’s a board designed from the ground up to be part of the Internet of Things.
Alternatives to Arduino
The Arduino-and-derivatives phenomenon has driven interesting innovation, and convergence, in the microcontroller marketplace.
The LaunchPad MSP430
The Texas Instruments MSP430 is very similar to the Atmel ATmega microcontroller chip. Notable differences include a very low price point, as well as some interesting refinements for low power consumption. It’s also readily available in the through-hole DIP form factor, while dual-inline-packaged ATmega chips often seem to be in short supply. If through-hole mounting is important to you, take a look at the MSP430. The easiest way to get acquainted is to pick up a TI LaunchPad developer board.
The major difference between LaunchPad and Arduino is cost. While a new Uno will run you $30, and a Leonardo $25, the LaunchPad MSP430 rings up at just $10 directly from TI or a major distributor (and that includes a USB cable). The upcoming USB LaunchPad MSP430 adds on-chip USB for only $2 more. I’ve seen LaunchPad boards available for less than $5.
Although the MSP430G2553 chip, the version that’s used by the LaunchPad, has only 14 I/O pins and 16K of program memory in comparison to the Uno’s ATmega328 (with 32K and 20 I/O pins), this may well be all you need for your particular project.
Until recently, the MSP430’s programming environment was a bit of a hitch. For a generation of makers accustomed to the user-friendly Arduino IDE, the MSP430’s old Eclipse-based development environment seemed overly complicated and hard to use. The new, open source Energia prototyping platform has changed all that. With cross-platform support for Windows, OS X, and Linux, it brings the Wiring and Arduino frameworks to the MSP430 in style. Energia lets you take your Arduino source code — your sketch — and simply drop it directly onto the MSP430.
Of course a lot of the power of the Arduino is in its community code libraries, but a lot of these have been ported over. Unless you need something fairly obscure, the arrival of Energia means that you can use the TI LaunchPad almost exactly as though it were an Arduino.
Picaxe Strikes Back
The near-ubiquity of the Arduino platform has driven many systems that aren’t software-compatible to be at least physically compatible. The Picaxe-28X2 Shield Base replicates the Arduino form factor, establishing compatibility with the hundreds of Arduino shields already on the market.
The runaway success of Arduino has stolen some love and attention from the Wiring board and its programming environment. It probably deserves more. The board is based around the same Processing-derived development environment from which Arduino came — although by now it’s a somewhat different branch of the family tree — and should feel familiar to anyone used to the Arduino IDE. It’s possibly just different enough, however, to trip you up if you get careless.
The Wiring programming environment supports any hardware based on the Atmel AVR series of processors, not just the Wiring boards themselves. And this includes the Arduino line.
As of this writing, support for the AVR XMEGA, the tinyAVR, the TI MSP430, the Microchip PIC24/32 Series, and the STM M3 ARM cores is billed as “coming soon.” Delivery on that promise, if it happens, will be a very interesting development, as it will allow Arduino-compatible code to be deployed onto a range of microcontroller architectures.
The latest board, the Wiring S, is similar to the older Arduino Diecimila, but with a bigger processor. Like the Picaxe Shield Base, pairing the board with a Wiring S Play Shield makes it pin compatible with the Arduino form factor so you can reuse your Arduino shields with your Wiring boards.
The Netduino, too, adopts the Arduino form factor — you can attach most existing Arduino shields. But that’s where the similarity ends. There are several Netduino boards available, and unlike the boards we’ve met so far that have all been based around 8- or 16-bit microcontrollers of one type or another, the netduino is an ARM Cortex-based board built around the 32-bit STMicro STM32Fx microcontroller.
The operating system on the board is the .NET Micro Framework. These boards are programmable in C#, directly from Microsoft Visual C# Express 2010, and are extremely powerful and flexible. C# developers on non-Windows platforms aren’t entirely out in the cold, as there is some support for OS X and Linux.
The Parallax Propeller
This is an interesting alternative to other microcontroller chips on the market. Where almost every other one has a single processor core, the Propeller has eight.
That means eight separate processes can be running simultaneously, monitoring and responding to sensor and other inputs. Think about it as eight simultaneously-running Arduino loop( ) functions.
Depending on your application, running parallel processors instead of using interrupts can be surprisingly powerful, and at $50, it’s not much more expensive than the other microcontroller boards we’ve talked about.
While the Propeller is available in a variety of form factors — including a bare chip in both DIP and SMT (Surface-Mount Technology) packages, if you want that for prototyping — like many other manufacturers Parallax has adopted the Arduino form factor for its Parallax Propeller ASC+ board.
As discussed, the success of the Arduino has led to numerous copies and compatible boards arriving on the market. The crowdfunding site Kickstarter is littered with them, some amazingly successful, some not so much. It’d be impossible to list them all, but there are some that stand out, chiefly because of their size (or lack thereof).
The TinyDuino, for example, is an Arduino-compatible microcontroller using the same processor as the Arduino Uno, but at the size of a U.S. quarter. The main processor board includes the microcontroller and supporting circuitry, while the USB and DC power regulators (among other things) have been offloaded to shields. If you don’t need them for your project, you don’t have to install them. However, despite its size, or more probably because of it, the TinyDuino costs $20 for the main processor board, plus another $18 for the USB/ICP programmer shield you’re likely to need. Miniaturization doesn’t come cheaply.
The DigiSpark is another tiny Arduino-compatible board. It is built around the ATtiny85 microcontroller, making it much less powerful than the TinyDuino. It only has 6 I/O pins but, on the other hand, it costs just $9. Like the TinyDuino, it has a variety of interesting shield kits allowing you to easily extend its capabilities.
There is a sea change going on in the microcontroller world: Everything is going wireless. A range of shields is available for Arduino and Arduino-compatible boards boasting GSM cellular, wi-fi, Bluetooth Low Energy, and other wireless capabilities.
Announced in May at Maker Faire Bay Area by Massimo Banzi himself, the Arduino Yún is the first in a series of embedded Linux boards to bear the Arduino name, and it comes with integrated wi-fi.
The board is fundamentally an Arduino Leonardo, sporting an ATmega32U4 microcontroller, plus a separate embedded AR9331 processor running a MIPS Linux variant based around the OpenWRT distribution. You can program it remotely via wi-fi or with the usual USB cable. Suggestively, perhaps, they’ve also partnered with Temboo for one-stop API access to data from Twitter, Facebook, Foursquare, FedEx, PayPal, and more.
The board should come in at $69, which isn’t bad when you consider the price of bundling an embedded Linux board, an Arduino, and a wi-fi dongle or shield all together.
Bluetooth Low Energy
The arrival of BLE has changed the playing field for wireless in embedded devices. Fixing most of the (numerous) problems with the old standard, the new Bluetooth LE protocol is much easier to work with than “classic” Bluetooth. While some smartphones, including the iPhone, have had Bluetooth LE support on board for awhile, there has been a delay in getting support for it out into the hands of makers. About six months ago, boards like RedBearLab’s BLE Shield and BLE Mini started to arrive, and now we’re seeing a spate of Arduino-compatible boards with integrated Bluetooth LE.
Interestingly, both are small form-factor boards, which is indicative of their intended uses.
If you need to cover a large geographical area with a wireless network, mesh networking is an ideal solution. Each board talks to every neighboring board, transferring packets across the ad-hoc network to the edge, where there is a router or a gateway out into the wider world and the internet.
Another runaway success on Kickstarter, the Pinoccio is an Arduino-compatible board with built-in 802.15.4-based mesh networking and a LiPo battery, with additional wi-fi capability via a shield (see The Tale of Pinoccio). It looks like a perfect platform to build a distributed sensor network with very little effort.
The Geogram One is an Arduino-compatible board intended for tracking applications. It has both a GSM cellular modem and an on-board GPS receiver. Despite that, it’s still an Arduino under the hood, with all the flexibility that implies.
The Arrival of the Raspberry Pi
The single-board Linux computer, existed well before the arrival of the Raspberry Pi; I personally was using Gumstix boards fairly extensively about 10 years ago. Recently, however, like the Arduino before it, the Raspberry Pi has single-handedly rebooted the market, this time for single-board computers. Also like the Arduino, it has brought an explosion of would-be competitors.
Unlike the Arduino, the Raspberry Pi was never really designed as a platform for makers. But the rock-bottom $35 price created a large market for single-board computers almost overnight, and it was months after the official release before the Raspberry Pi supply caught up with demand.
It was designed from the start as a low-cost platform for kids to learn programming — a cheap educational tool. Despite that, rather than because of it, thousands of creative computer-embedded projects are being built around the board. Like with the Arduino, it’s the Pi’s flourishing community that has made it a success.
While expensive at $89, TI’s BeagleBone was designed from the ground up to talk to arbitrary bits of hardware — sensors, actuators and other electronics. It was a board designed from the start for makers, rather than as an education platform like the Pi.
Unfortunately the price break with Pi was just too tempting for most buyers; while the BeagleBone developed a small but dedicated following — for instance the Ninja Block system was built around BeagleBone — it was never really a rival for the Raspberry Pi.
That all changed with the arrival of BeagleBone Black. Besides the new color, the newer board looks pretty familiar; it has the same footprint as the original BeagleBone, and a similar layout. Among other interesting new features, BeagleBone Black moves the operating system off the SD card to on-board flash memory, freeing up the microSD card slot for other purposes.
Most crucially, however, the board has dropped in price from $89 to $45, which is real competition for the Pi’s $35 retail price point. Especially when you consider the Black’s better specs, greater flexibility, and generally better user experience.
The pcDuino is another embedded board running Linux. Interestingly, though it is Arduino pin-compatible, it is not form-factor compatible. All the pins you’ll need to use most Arduino shields are “broken out” of the ARM Cortex-A8 processor.
You can write code directly on this board, as if it were an Arduino, then run it natively on the board. SparkFun is even in the process of putting together an adaptor to make the board footprint- and pin-compatible with Arduino. At $60, it’s an attractive option, and looks easy enough to set up.
The x86 Fights Back?
Single-board computers running Linux have traditionally made use of ARM processors; it’s only recently that x86 boards have started to appear. Perhaps the best example of this is AMD’s Gizmo Board.
Essentially a laptop on a single board, Gizmo is blindingly fast, extremely flexible, and hugely powerful by the standards of those of us coming from the microcontroller world. But that performance does come at a price — at $200, it’s not cheap.
Today there’s a proliferation of boards that seem to want to be all things for all users, combining a Raspberry Pi-like SBC with an Arduino-like microcontroller. In addition to the Arduino Yún, the Udoo, for instance, made a huge showing on Kickstarter. It’s an ARM-based Linux board like the Raspberry Pi, built around an impressive dual- or quad-core ARM Cortex-A9 CPU, with a second ARM processor, the SAM3X, alongside to mimic the Arduino Due. It’s priced to match its performance at $130.
Starting in 2007 or so, the phrase “wearable microcontroller” was pretty much synonymous with the LilyPad Arduino, a system of sewable electronic modules designed by Leah Buechley.
In 2012, Adafruit Industries introduced the first major LilyPad competitor — the Flora. Though the Flora is designed to be more beginner-friendly than the LilyPad, the two platforms are still fairly closely matched. Adafruit promises a second smaller, wearable board later this year, and it looks like the wearables space, which has been static for a few years, is going to start heating up.
FPGAs (field-programmable gate arrays) represent an entirely new class of boards. With microcontrollers, you have control over the software, the code living on the chip. With an FPGA, you start with a blank slate, and design the chip itself at the hardware level. There is no processor to run software until you make it happen.
It might sound crazy, but it gives you flexibility. If you need more than one serial port then you just add another to your chip design. It also means that you can design the hardware to be a processor that you can write software for. Many companies, like Intel, use FPGAs to prototype their chips.
The Gadget Factory’s Papilio One is an open source FPGA project board intended for hobbyists and newcomers. Based on the Spartan 3 FPGA chip, it’s got 48 I/O pins and comes with two Arduino-compatible “soft processors” ready to load into the array, so you can quickly get up and running using the Arduino IDE. Starting at $38, it’s a solid entry-level FPGA. For something more capable, look at the Papilio Pro ($85) or Embedded Micro’s Mojo board ($75), which gives you a Spartan 6 chip, 84 I/Os, 8 analog inputs, and 9 on-board LEDs.
Around the Corner
For a couple of years, there was a phenomenon among programmers where everyone’s first “serious” application was a Twitter client. Before Twitter existed, everyone seemed to write a text editor the first time out. Why? Everyone used a text editor, and later a Twitter client, and so everyone had an opinion about how they should work. Among existing programs, the buttons weren’t in just the right places or the workflow was slightly wrong. So everyone just wrote their own — they scratched their own itch.
I think that’s exactly what’s happening with the current explosion of Arduino-compatible boards on Kickstarter. Everyone uses the Arduino, but everyone uses it for slightly different purposes. So as their first “serious” hardware project they decide to build their own version and scratch that itch. I fully expect that many of these boards will disappear after one short run, for the same reasons that most of those new Twitter clients quickly disappeared: The costs of supporting them will greatly exceed the income they generate.
But then, a lot of very serious people in the open source world got their start writing text editors or Twitter clients, and like them, many of these fledgling pro-makers might well go on to do much more interesting things than designing Arduino derivatives.
In circuit boards, the gap between concept and production-ready prototype is shrinking so quickly right now that it’s very hard to anticipate what the next big thing will be. But the prevalence and proliferation of wireless microcontrollers is, I think, giving a big hint.
Everyday objects are already becoming smarter; in 10 years, every piece of clothing you wear, and every object you carry on your person, will be measuring, weighing, and calculating. By then, the world will be full of sensors, and those sensors will need to talk to each other.
So, um, which board should I buy anyway?
Because of the communities that have grown up around them, I would unhesitatingly recommend an Arduino if you need an 8-bit microcontroller, or a Raspberry Pi if you need a single-board computer running Linux.
If you’re leaning toward the Pi, but worried it may not suit your application, the decision gets more complex. The Raspberry Pi is yet to become an unstoppable force, or an immovable object, like the Arduino. The most serious alternative, around the same price point, is BeagleBone Black. On the other hand, BeagleBone Black is relatively new, and its community is much smaller, so you might end up having to solve a lot of your own problems.
If you’re leaning toward an Arduino, but have specific needs (like wireless connectivity) that it doesn’t meet out of the box, then you should probably look first among the myriad of Arduino derivatives. You’ll probably find your desired feature set baked right into one of them.
Finally, if your project’s I/O requirements permit it, take a serious look at the TI LaunchPad MSP430. Its low-price, low-power requirements, and user-friendly development environment make a very strong case.
This article first appeared in MAKE Volume 36, page 48.