The release of Raspberry Pi is just around the corner. This computer, produced by the charitable foundation of the same name, is the size of a credit card and comes in at just $25 ($35 for the beefier version that will be available first). Yet it is a full-on personal computer, a 32-bit Linux machine based on the ARM processor architecture. It can even run Java, my language of choice. Take a look at this incredible thing.
The Raspberry Pi: a 32-bit ARM processor; USB, HDMI, RCA video and audio jacks; and an SD card reader for storage. All in a credit-card sized package that weighs 40 grams.
Plug in a keyboard and a TV and the Raspberry Pi becomes a traditional personal computer. That’s very cool, considering the mind-blowing price point, but I’m more interested in it as a physical computing platform.
To date I’ve focused my explorations in physical computing on Arduino, as I’ve mentioned in previous posts. Interestingly, the Arduino platform is also moving to 32-bit ARM from the existing 8-bit ATmega328 chip. They have a new board, also coming soon, called the Arduino Due. It’s also expected to maintain the $30-or-so price point of previous Arduinos.
The upcoming Arduino Due, also sporting a 32-bit ARM processor, USB and along the edges, dozens of GPIO pins.
Both of these computers are open source; that is, anyone can download the hardware specs and software and make their own clone. (Here, by the way, is another instance of the open model coming to life.) Both are ARM-based and are about the same size and price. Yet the two are not quite equivalent, because they represent different computer design philosophies. The Raspberry Pi is like a very tiny PC, whereas the Arduino is more of a prototyping platform, essentially a microcontroller with no operating system. It’s the kind of computer that would be embedded in a car or a washing machine. That means it two things: it has had (up to now anyway) a very weak but cheap processor; and that it has built-in general purpose IO (GPIO). Think of GPIO as all the pins that allow the Arduino to flash LEDs, drive motors or read sensors. Without it, physical computing is impossible.
Unfortunately, Raspberry Pi does not have integrated GPIO the way the Arduino does. Fortunately, a guy named Gert van Loo is creating an add-on GPIO expansion board for it known as the Gertboard. Combine the two and you have a full physical computing hardware platform. I predict it won’t be long before there’s a 2nd generation Raspberry Pi, or a clone, that unites and miniaturizes both into a single package. It’s an obvious move, especially considering the motivation of the foundation, which is to stimulate engineering creativity in education.
And it isn’t just the Arduino Due and Raspberry Pi; there’s a whole swarm of tiny, cheap ARM-based computers headed our way or already here. Some are Arduino clones or spinoffs, like the LeafLabs Maple, Olimex OLIMEXINO-STM32, Xduino and Netduino. Others aren’t Arduino-related but are still ARM-based controller boards, like the Technologic TS-7500 and the Chumby board. Some are Raspberry Pi-style personal computers, like the FXI Cotton Candy and the BeagleBoard. This broad technical convergence indicates the ARM processor architecture looks set to define a new sweet spot of physical computing, much as Intel did to personal computing in the 80s with the x86 architecture. Why? Two reasons. One, because in terms of bang for the buck, ARM is virtually unbeatable; two, because it requires so little electricity to run, which is crucial for battery-powered applications. Both of these qualities are of paramount importance in this corner of computing. Effectively, through ARM, Arduino and its friends are expanding the microcontroller into the same spot into which the Raspberry Pi and its friends are shrinking the personal computer. I think this is a very important development that blurs the line between these two forms of computing and will explode the creative possibilities of both. It’s the advent of what could be termed nanocomputing* after the quite similar homebrew microcomputer revolution of the 70s.
History does not repeat itself, but it does rhyme.
– Mark Twain
The beauty of using Raspberry Pi as a platform is that it really functions as an ordinary computer. You can write email, play video games or hit Google on it. Most importantly to me, you can write and debug code in virtually any mainstream language on it. This gets away from the traditional microcontroller-style “compile on one machine, run on another” dance that Arduino imposes, with feature-barren languages designed to produce code for weak chips. With Raspberry Pi, I can code and debug on the very machine. That’s much less of a pain in the ass; I don’t have to do crude debugging with serial communication back to my Mac. Since it can execute Java bytecode in a 32-bit JVM, I can code in Java if I choose. I should be able to use Java for direct GPIO communication, eliminating the need to write in the specialized Processing language, as you do for Arduino. That means I get object oriented programming semantics, garbage collection and access to the vast ecosystem of third party code, the three aspects of Java I appreciate the most. None of this has really been available in the physical computing space up to now. With it, I can write software of much greater complexity and sophistication, with less work, that’s easier to maintain.
For physical computing applications, I want to write and debug code directly on the hardware and I’d prefer to write Java code in a full-fledged operating system like Linux. By combining Raspberry Pi with the Gertboard, it looks like I can have it all. Courtesy of the new ARM-enabled nexus of computing.
* Though the term implies nanotechnology, which isn’t particularly relevant to the level of platform architecture. Still, I like the term.
