This summer, we looked at two embedded computer boards: the Raspberry Pi (Model B) and the BeagleBone Black (Revision C). These two platforms are extremely similar in terms of software. Both of these systems feature 32-bit processors which are capable of running "desktop" operating systems. The operating system most heavily catered to is Debian/Ubuntu for both of the embedded boards, though a sizeable number of Pi users prefer the extremely lightweight (and hacker-y) Arch Linux. The main differences between the boards exist in hardware. The BeagleBone focuses much more on circuit-level connectivity; it features 5 times the number of hardware pins including two hardware SPI interfaces and 7 channels of analog input. The Pi, alternatively, seems more focused on simply being a tiny computer and has a emphasis on desktop-level connectivity; the Model B comes with multiple USB ports (where the beagle has just one) and a wider array of Video and Audio output options.
In terms of computing power, the BeagleBone is about 40% faster (1GHz vs. 700MHz for the Pi) though they both have 512MB of Memory. While running, the BeagleBone experiences significant heating even under normal operating conditions. If used for either large processing tasks (such as live signal- processing) or in space-confined applications I highly recommend a cooling fan. The Pi, in general, runs much cooler. However, when used with the stacking LCD daughter-card, the space between the two cards can also get quite hot. Interestingly, while the Beagle is generally faster and is excellent at integer calculations, it is actually slower than the Pi at floating-point computation. This could represent a significant advantage of the Pi for live signal processing. Besides the lower clock speed, I would reccomend the Pi over the beagle primarily because it has shown to be much more resilient and durable. The Pi that we have been working with this summer is now over a year old and has experienced no operating problems whatsoever. By contrast, Neither of the two Beagles we purchased this summer lasted an entire month before needing to be sent back to their facility for repairs (one of which entered this state in under 24hrs). This nuisance was further compounded by the repair process taking roughly a month between shipping times and minimal facility bandwidth (presumably they had quite a few of these to look at). While we certainly are extrapolating from a small sample size, it appears that the Pi is more difficult to break. For both proto-typing (which involves potentially component-dangerous testing) and release purposes (where it will have to withstand a certain amount of user-stupidity) the greater resiliency of the Raspberry Pi represents a significant advantage over the BeagleBone, probably offsetting the lower processor speed.
Despite the BeagleBoard having been on the market for longer than the Pi has, the Beagle has never been as popular as the Raspberry Pi and only very recently (with the BeagleBone Black) has it been carried by Adafruit's support network. I think this is mostly due to better marketing on the part of the Pi and the rough-edgedness of the Beagle. Whatever the origin, the enormous Pi community and extensive list of Adafruit tutorials and dedicated forums make developing on the Pi much easier and trouble-shooting faster. Installation of operating systems is also much easier on the Pi, due to its use of of an external SD Card for storage. On a Pi, installing most linux systems is as simple as grabbing an image from raspberrypi.org or adafruit.com (or some third party) and simply writing it to an SD Card; the preferred software for this is the Fedora ARM Installer (available on Linux and Windows). The Beagle has a slightly more difficult process involving more expensive microSD Cards which are then used to flash the eMMC (embedded multimedia card) which can take up to 45 minutes. Considering that the microSD Cards are really only used as a transfer medium, it's both surprising and frustrating that there is no way to install OS's directly to the Beagle from a computer. Having an eMMC as the "disk" of the Beagle seems like a good idea in on paper, but in reality, the fact that it cannot be removed means that stored files and data are more difficult to access and consequently problems are more difficult to fix without nuking everything and re-installing. Another ease-of-use feature of the Pi is that its video out ports actually do something right out of the box. This means it's possible to use and set up the Pi completely locally by simply attaching a monitor and keyboard, similar to a desktop. Conversely, preforming post-installation setup (installing programs, setting up networking, etc) with the Beagle requires connecting it to a computer and logging in over serial. Bizarrely, this part of the process seems to be heavily catered to Windows Users in almost every tutorial online (This could also be due to an attitude of: "Linux people can figure this out for themselves").Raspberry Pi Installation
As far as connecting to the internet, the Beagle and the Pi are effectively identical. Both (usually) run Debian or Debian-based operating systems and come with 10/100Mbps ethernet ports, but no embedded wifi. While both systems are full operating system and installing more complicated programs like network-manager or wicd are possible, the simplest way to set up networking is by editing
/etc/network/interfaces. For wifi, RTL8192cu USB wifi cards are supported out of the box by the Beagle and the Raspberry Pi; Adafruit also has setup tutorials for both the Beagle and Pi. The Rasberry Pi comes with support for IPv6 (sometimes necessary if using the StataCenter wifi network) but it is not enabled/loaded by default. To fix this, add "ipv6" in a newline at the end of
/etc/modules and comment out all the lines in
/etc/modprobe.d/ipv6.conf. Then reboot. Due to the power-use of the antenna the Beagle needs to be powered via the 5V/1A jack rather than the micro-USB port. Otherwise, the device will not have sufficient power to boot. When using the wifi antenna, the Beagle can take serveral minutes to power up and aquire an address.
/etc/network/interfacessyntax reference (using StataCenter settings; same for both boards):
iface eth0 inet dhcp
#Ethernet (Static IP)
iface eth0 inet static
dns-nameservers 184.108.40.206 220.127.116.11 18.104.22.168
iface wlan0 inet dhcp
One of the useful features of the BeagleBone is that it features 7 built-in Analog input pins. These do however, have a very narrow range of 0-1.8V, and exceeding this range can cause significant damage to the pins and possibly the board as a whole. Considering that almost all analog circuits run at significantly higher voltages than 1.8V, almost every input is going to need at least a voltage divider. Conversely, The Raspberry Pi does not come with any Analog conversion and requires the use of an ADC chip such as the MCP3008, which is communicated with via a 4-wire SPI interface. These chips are actually much better than the Beagle's built-in one, with 8 input channels and a wider 3.3V range (which encompasses all of the "accessory" sensors like the Accelerometer in the TBH project). Furthermore, they're quite fast and even with Software SPI are not noticably slower than the Beagle. Best of all, the MCP3008 is very cheap at $2.20/ea.
|BeagleBone||Raspberry Pi B (B+)||Intel Galileo||Arduino (Yun)||A13-OLinuXino||ODroid U3|
|Architecture||ARM v7||ARM v6||i586||MIPS 32||ARM v7||ARM v7|
|Speed||1 GHz||700 MHz||400 MHz||400 MHz||1 GHz||1.7 GHz|
|GPU||PowerVR SGX530||Broadcom VideoCore IV||No||No||Mali-400||Mali-400|
|USB||1x A||2x A (4x A)||1x microAB||1x A||3x A||3x A|
|Video||microHDMI||HDMI and RCA||None||None||VGA||HDMI|
|Analog input||7x 12bit 0-1.8V||None||6x 12bit 0-5V||12x 10bit 0-5V||None||None|
|Dimensions||3.4 x 2.1 in||3.4 x 2.2 in||4.2 x 2.8 in||2.7 x 2.1 in||4.7 x 4.7 in||3.3 x 1.9 in|
|Weight||1.4 oz||1.6 oz||1.8 oz||1.4 oz||~2 oz||1.7 oz|
|Best for Processing Power:||ODroid U3|
|Best for Usability/Support:||Raspberry Pi|
|Best for Digital Hardware Connectivity:||Beagle|
|Best for Price:||Raspberry Pi|
Several other boards are listed in the table to provide a comparison point to the Pi and the Beagle. Two of these are supported and sold by Adafruit (Intel Galileo and Arduino); in keeping with their style, Adafruit has provided extensive tutorials for these devices. These two boards were not selected for testing this summer due to their lower processing power as well as other drawbacks. In particular, the Galileo has a normal operating temperature of 60-65 C, peaking at 70 C (140-158 F), while the Arduino systems in general do not run full Linux operating systems and development for them is more complicated. Two other boards, the A13-OLinuXino and ODroid U3, also seem very interesting; the ODroid in particular with its much faster processor might be a good choice for live signal processing. However, these boards are less common and finding support for issues that arise may be difficult.
Another interesting project is the "Shimmer" system. This product seems to be going for a similar application to Esteban and Pablo's monitoring project (namely, portable medical monitoring systems). However, unlike a Pi or Arduino or ODroid, this is not a development board but rather a "finished product" designed to be sold to hospitals and other medical/health facilities and not developers. While fiddling with this device might be interesting and educational, its $4,000 price tag makes it a very expensive purchase to simply see what and how it does.
In addition to simply looking at embedded systems in order to reduce the price and weight of the TBH project, we also looked at how they might be able to provide immediate useful feedback to the medical and care staff that will hopefully eventually use this system. Primarily we looked at small programmable LCD screens (about the size of the boards themselves) for use with the Raspberry Pi and BeagleBone. Both of these screens had 320x240 pixel resolution and were driven by the ILI9341 driver. The first display we tested was platform-independent and communicated via 4-wire SPI interface while the second was specifically designed for the Raspberry Pi with the nickname "PiTFT" (though potentially could be made to work with other boards).
The first display we used did not have any existing native code for the Raspberry Pi or BeagleBone. Through reading of the datasheet and some Arduino code I was able to write a simple library for the display which can be found here on github. Since writing this code, Adafruit has published their own libraries and tutorial for this and other displays that use the ILI9341 chip with the Raspberry Pi or Beagleboard. Disappointingly, this display turned out to be very slow, even when using Hardware SPI, usually taking more than a second for full screen refresh. While it's possible that this is a product of the from-scratch python library, I still wouldn't reccomend it for vastly dynamic display applications (like a plotting program). By contrast, the "PiTFT" was both fast and extremely easy to use and set up. Adafruit provides fairly extensive tutorials on its use, including setting up the display as the main display for boot purposes (allowing for much better mobile applications). The "PiTFT" also has a touch screen and connectors for push buttons (sold seperately of course) to provide user input options.First display tested
|Interface||Price||Temperature Range||Temp Error||Humidity?||Humidity Error|
|SHT15||2-wire Digital||$28.95||-40C - 123.8C||+/- 0.3C||Yes||+/- 2% RH|
|DHT22||1-wire Digital||$9.95||-40C - 125C||+/- 0.2C||Yes||+/- 2% RH (typ, 5% max)|
|TMP36||Analog||$1.50||-55C to 150C||+/- 1C (typ, 2C max)||No||N/A|
|SHT15||Purchase from Sparkfun: with breakout or without||SHT1x Datasheet|
|DHT22||Purchase From Adafruit||Adafruit tutorial||DHT22 Datasheet|
|TMP36||Purchase from Sparkfun|