How does the PocketCHIP compare to the Raspberry Pi?

https://opensource.com/sites/default/files/pc_glamour.png" style="width: 600px; height: 669px;" title="PocketCHIP" typeof="foaf:Image">

PocketCHIP

I took the PocketCHIP with me to the All Things Open conference in 2016 as my conference computer. I had to bring a laptop along for a presentation that I was giving, because the presentation involved compiling and running applications specifically on x86_64 architecture, but I only used it for that. Otherwise, I successfully used my PocketCHIP for everything from working online to taking notes during meetings and tech talks.

One of the distinct advantages of the PocketCHIP over a Pi is that the PocketCHIP is designed as an all-in-one device. It has no hidden costs. You buy it, and you've got a self-contained computing device that has a screen, a keyboard, Wi-Fi, Bluetooth, power, and a repository full of all the best open source software.

Sure, you can buy a Pi, screen, battery pack, Bluetooth dongle, and (unless you get a Pi 3) a Wi-Fi dongle, and you'll have something approaching the PocketCHIP's portability. You might even go to the trouble of constructing a case for it. For an off-the-shelf experience, though, PocketCHIP is the way to go if you're looking for a "hiptop" computer.

Better yet, the PocketCHIP maintains the same modularity of the Pi, because the PocketCHIP can be taken apart easily to free the CHIP from the case. If you want only a portable hiptop device some of the time, and you prefer the smaller form factor of just the CHIP board other times, you get both with the PocketCHIP.

The glaring weakness in PocketCHIP's all-in-one design is the keyboard. While having a physical keyboard is great, and I wouldn't give it up, I only consider it a backup keyboard at the best of times. It's not that I mind typing on keys seemingly made of bubble wrap, it's that these key presses only register about 66% of the time. That's within tolerance for small one-off tasks, but if you're writing code, taking notes at a tech conference, or writing an article (like this one, in fact), it's not the best. I ended up resorting to a Bluetooth keyboard within days of owning the PocketCHIP, and now I don't bother taking one without the other—so much for all-in-one.

To be fair, however, I have the same feeling about touchscreen phones and tablets, but some people swear by them, so I may be hypersensitive.

The PocketCHIP has other downsides. Unlike the standard CHIP, it has no GUI interface for Bluetooth control. Pairing with a Bluetooth device, even a trusted one, is a process that requires several commands. Being hindered by the very keyboard you're trying to replace is recursively maddening, but you are using Linux, so you can avoid a lot of frustration with a script:

#!/bin/bash

ARG="${1}"
help() {
    echo "Connect a Bluetooth device to PocketCHIP"
echo "Usage: $ [MOD=1] ./blue.sh BLUETOOTH_ID"
    echo "Optional: put your device ID into ~/.bluechip"
    exit 0
    }

xkbfunc() {
    setxkbmap dvorak
    xmodmap $HOME/Xmodmap.logitech
    exit 0
}

if [ -e ~/.bluechip ]; then
    ARG=`cat $HOME/.bluechip`
elif [ X"$ARG" = "X" ]; then
    help
fi

echo "Using ID $ARG"

sudo systemctl start bluetooth || echo \
"Bluetooth already started or cannot be started."

sudo \
echo -e "power on\n connect $ARG \nquit" | bluetoothctl
xkbfunc 

Aside from the keyboard, the PocketCHIP is exactly what it appears to be, an ultraportable, pure-Linux machine. This isn't an Android phone with a Linux chroot inside of it, this is Linux on a portable, self-contained, Tricorder-sized device.

Raspberry Pi

The Raspberry Pi wasn't designed to be an all-in-one system. In fact, you might argue that one of its strengths is its modularity. The Pi itself isn't modular, it's a minimal configuration for a computer system with all components either burned into its chip or soldered to the board, but it's a computer that you can hook up to a tiny LCD screen, an HD monitor, an array of LEDs, or any other peripheral you please, or none of these things at all.

It's worth noting that the CHIP itself (without the case, screen, and battery that makes it a PocketCHIP) is equally versatile. But there's at least one thing that sets the two apart: one has removable storage.

Every Raspberry Pi, including the Pi Zero (which was released after the CHIP was Kickstarted, perhaps coincidentally), has featured an SD card slot. This makes it easy to copy a Linux distribution onto a Pi. Simply dd it over to an SD card, resize the file system as necessary, boot the Pi, and you're up and running.

Installing a Linux distribution is not as easy on the CHIP or PocketCHIP. The storage is embedded, meaning that to load a new OS on the CHIP, you have to flash the CHIP's chip, just as you would a mobile phone.

My first experience with embedded Linux was the Nokia N800. Being embedded, it required flashing to get its Linux-based OS, Maemo, loaded or updated. Flashing was done with a shell script from your computer to your connected N800; it was simple and effective. Playing with mobile phone OS images is trickier, since they usually require a special bootloader on the device and Android Studio for the ADB (Android Debug Bridge) toolchain.

The PocketCHIP's official method of flashing your device is done through a web browser. As such, it feels almost familiar, or at least nonthreatening. Maybe it's oversimplified and clunky for a serious geek, but for new users, it's a simple interface to use to freshen up or rescue the PocketCHIP when something goes amiss. It's not an SD card that you just pop in and go, but it's as close as you'll get with an embedded OS.

The CHIP isn't as popular as the Pi, so there's nowhere near as many choices when it comes to what OS to install. In fact, your "safe" choice boils down to one: the official CHIP distribution of Debian. There are advanced instructions for flashing the CHIP for those who dare. Compare that to the process of booting to an alternate Linux distribution or BSD on the Pi and you'll see that there really is no comparison.

GPIO

At least for the maker movement, one of the main appeals of the Pi is its GPIO (General Purpose Input/Output) pins. If you've never used GPIO pins, you've at least seen them. They're the pins along the side of the board that allow the Pi to interact with other electronic devices, whether it's an LED light, an LED array, an off-board microcontroller, thermal sensors, light sensors, or anything else you can imagine.

The CHIP has GPIO pins, too. In fact, the GPIO pins are what attach the CHIP to the PocketCHIP board and they provide the screen output and keyboard input. You might think that means the CHIP's GPIO pins are occupied when in PocketCHIP form, but amazingly the clever folks over at The Big Thing thought of that and mapped new GPIO pins along the top of the PocketCHIP case, providing you with programmable GPIO pins regardless of how you're using it.

https://opensource.com/sites/default/files/gpio.jpg" style="width: 520px; height: 293px;" title="GPIO image" typeof="foaf:Image">

I haven't done any serious work with the CHIP's GPIO pins yet, but during testing, I found them to be a little more versatile than those on the Pi. For instance, I was using the Pi for an art project last year that triggered an array of LEDs and, in the meantime, played a sound clip. Unfortunately, playing a sound on the Pi interferes with the GPIO subsystem; the LEDs would light up, but erratically, and the sound was often distorted (depending on how I played it). The answer ultimately was to off board the LED control to an Arduino triggered by the Pi, and play the sound from the Pi. So far, on the CHIP, I can get no such distortion. My caveat here is that I no longer have access to the number of addressable LEDs that I was using on the Pi, so it might be possible to break the CHIP's spirit eventually. But I've been impressed with just how much the CHIP can do all at the same time, without interference.

However, the Pi does have more GPIO libraries than the CHIP does, so depending on what you're trying to achieve, you may still prefer a Pi or an Arduino. Luckily, the Adafruit libraries have been ported to the CHIP, so for many of the common electric components available online, you have ported libraries ready for you to use.

Additionally, porting most Python code written for a Pi to a CHIP is simple. Pin numbers need to be changed in your code, and there's no need to specify a pin mode as you do on the Pi, but everything else in your code stays exactly the same (as long as you import RPi.GPIO as GPIO and CHIP_IO.GPIO as GPIO).

Speaking of great board design, the battery and power system on the PocketCHIP is as modern and convenient as you could possibly want. The battery is internal insofar as it's located on the inside of the plastic casing. It can be swapped out as needed, because the case comes apart pretty easily, but that's too much work. The great thing about the PocketCHIP is that The Next Thing expertly engineered it to receive power from either its on-board LiPo battery or from its USB port, if you plug in a mobile phone power pack or plug it into a USB charger in a car, airplane, or at home.

The PocketCHIP acts just like a laptop or mobile phone when it comes to making sure you've got a charge. If you're running low on power, plug your PocketCHIP into a USB charger or a power pack. If you need to get up and go, unplug the power and run off internal battery. All of this happens seamlessly, without interruption.

Compare that to the Pi, and you'll understand why this is exciting. There may be solutions I'm not aware of, but for a reliable battery power flow on the Pi, my research shows that a LiPo interface must be used between the USB power pack and the Pi. As far as I know, there's no way to attach a LiPo battery to the Pi, much less charge a battery through one of the its USB ports.

People have created several Pi hacks to extend battery functionality, and that's one of the Pi's strengths. It is exactly what it claims to be, an educational device that emphasizes and encourages homemade hacks to make it into something bigger and better. It's not prepackaged and magical, it's raw and ready to be worked on.

The PocketCHIP has three ports:

• USB
• Micro USB
• Audio (plus analogue video)

Next Thing has an HDMI adapter for CHIP. It's a sort of "hat" (in Pi terminology) that plugs into the GPIO pins and provides an HDMI output. With that many pins, putting it on or taking it off is not easy. I got one for free as a Kickstarter reward. I've used it once and already some of the pins are bent just from me trying to take the thing off. In short, I wouldn't recommend it as a peripheral. If you get one, attach it and leave it attached (but then you have a CHIP and not a PocketCHIP).

The Raspberry Pi has many more ports:

• 4 USB
• Micro USB (power)
• Audio
• Analog video
• HDMI
• Ethernet

That's a huge difference, and for many people this could be a deal breaker. For example, I have yet to even bother using my CHIP as a dedicated server, while I've got a Raspberry Pi and a Banana Pi in two different countries hosting websites. I could do it with a CHIP, but I doubt I'll ever bother getting the USB-to-Ethernet dongle I'd need to make it work the way I would expect.

On the other hand, I have yet to take a Pi to a coffee shop for an afternoon of coding.

When you boot the PocketCHIP, it boots to a custom launcher screen that shows its six default applications.

https://opensource.com/sites/default/files/launcher.png" title="PocketCHIP launch screen" typeof="foaf:Image" width="480" height="272">

You can customize this launcher screen by modifying a JSON file hidden away in /usr/share, but it's a hack. The PocketCHIP team obviously didn't account for modifying the launcher screen, although they have stated in their forum that a better solution is in development. Rather than spend time hacking the launcher screen, I mostly use either the Terminal to launch applications I've installed with apt, or else use the launchers from /usr/share/applications directly in the included File Manager.

The important point is that applications are plentiful. You've got a tiny screen to work with, and not all applications were designed for that, but they're available, so you can install what you want, configure those that need an allowance for the small screen, and use what you need to use.

The problem is that the PocketCHIP is an embedded system. It has limited storage space and no built-in solution to install applications to an external device. If you know enough Linux to hack around that, then you can avoid running out of space for applications, but be aware of this if you can't be bothered to do it.

One of the most heavily promoted applications on the PocketCHIP is Pico-8, a closed source game engine. I lobbied for this application to not be pre-installed when it was introduced as a "bonus" during the Kickstarter campaign, but I was apparently either in the minority or else the deal had already been sealed. You can uninstall the proprietary Pico-8 with apt remove chip-pico-8 and save 2.5MB while also purging the PocketCHIP of a closed source app. Replace it with the excellent open source alternative, Love, with apt install love, and then hack the launcher screen to remove the PICO-8 entry.

The Pi has the advantage here. Not only does it not ship with closed source applications, but you get to pick the amount of storage you use, so you can install everything you need, plus your user data.

The Raspberry Pi and the PocketCHIP are difficult devices to classify. Are they low-power and low-cost headless servers? Are they smart TV back ends? Are they controllers for robotics projects? Are they retro arcade game emulators? Are they hiptop computers?

They're all of these things.

If you are after a mobile computing experience, then the PocketCHIP is a well-designed, expertly engineered, single-board computer that is ready to go. In a way, buying one of these is similar to buying a System76 Linux laptop—you buy the luxury of not having to think about the hardware. You have everything you need, and everything just works. Any hacking you do will be on code, not on hardware.

The Pi is a little more raw. If you want it to be a mobile solution, you have to build that yourself. As a server, however, it's ready to go instantly.

I heartily recommend both.

Stay tuned for the Opensource.com Raspberry Pi series starting March 13!