Friday, May 18, 2012

First off, thanks to the wonderful folks over at Adafruit and Engadget for checking out the Amber! It’s been great hearing all the thoughts, feedback, and questions so far. While Mike and I get some of the projects and walkthroughs all documented, I’ll be posting them over the next week. In the meantime, some behind-the-scenes action, and a preview of what’s on deck…

Many of the questions about Liquidware Amber revolve around a couple common themes, which I’ll do my best to explain here:

What exactly is this “Amber” again?

It’s an easily customizable Android tablet. It originated as a tool that a few of us here used in a variety of projects to get things going a little quicker. I think of it as an “80% finished” device…which means that it works for a variety of different applications that make up the last 20% percent of the project, such as peripheral sensors, wireless connectivity, and the finished form factor.

I don’t understand why I shouldn’t just go get an iPad.

I actually did buy a tablet, for tablet purposes – the Acer Iconia A500. I liked that it was Android, that it had accessible, removable, upgradable microSD storage, and that it had a USB host port.

As much as I’d like to say I would, I don’t use Liquidware Amber to read ebooks and PDFs in bed, or to sit in the park and watch Hulu. I don’t need to customize a tablet for that. Any number of mass market consumer tablets would fit the bill way better, and cost a lot less (unfortunately, I’m not building millions of Ambers, and I don’t own massive overseas factories to do everything for me fast and ridiculously cheap!).

However, if I needed a 7” touchscreen enabled interface for something like my own a special ATM that dispensed only Monopoly cash (that I’m only building 100 units of), the Amber would save me a ton of time. I have a customizable Android tablet ready, dual USB hosts and other GPIO that allows me to focus on integrating functional parts, rather than trying to build everything from scratch.

It’s a little bit of an experiment in rapid prototyping, but more on that next time…

Okay…where can I see the Amber in action?

I’m in the process of putting up more Amber projects and tutorials, but a couple things I have handy along with my Amber are my Linux laptop, a good USB Type B-mini cable, and Android Debug Bridge (adb).

This pretty much allows me to test out peripherals with the Amber, write my own drivers, test out my own apk’s and compile custom kernels. I’m starting to compile a lot of the very basic adventures in Android applications on the Amber over on the new Antipasto HW wiki page.

I’ll also be writing up a better tutorial on getting the toolchain going. I’ve learned the hard way how important that is…and how much I’d rather not sit around installing packages when I should be busy integrating my prototype!

Also, here’s a sneak peek at some of the projects that I’ll be uploading as I get to them this week:

Wednesday, May 16, 2012

One of the most common questions I get is, “Can I build my own Android tablet for [my project]?”

That’s also something that I spend a disproportionate amount of time working on. Now, rather than starting from scratch, I’m starting from the level of say, ripping the case off my tablet and rooting it. It’s not as violent as it sounds. The point is, I need something about 80% of the way to a tablet.

Conversely, I could build my way back up from something like a BeagleBoard, but in many cases, it’s much more of a prototype than I really need.
After a while, we had an “80%-finished”, 7” Android tablet that came in very handy as a starting point for custom tablet-related projects. I like to think of it as a “foundational technology”, but since that’s quite a mouthful, we decided to call it the Amber. This is the part where it looks like a tablet…
…And this is the part where it looks very…80%-finished.

The whole idea being that I want a starting point far enough along, so I don’t need to build everything from scratch, but not so far along that it’s a pain to customize.

The Amber is a 7” projected capacitive tablet driven by a 1 GHz, ARM Cortex-A9 OMAP3730 from Texas Instruments. We’ve customized a version of Android Gingerbread 2.3.4 to run on the Amber, and its 2 USB host ports offer high-speed USB and serial communications to a pretty wide range of devices. WiFi, Ethernet, cellular, and battery configurations are available as part of the Enhanced or Pro versions of the Amber.

I’ll be uploading more shots and tutorials of cool (and hopefully useful) things I’ve worked on with the Amber and Android development. Meanwhile, here’s a couple videos of the Amber in action:

Tuesday, May 15, 2012

Intel’s Core 2 Duo was one of the first mainstream desktop uses of a dual-core microprocessor (2005-6), and Nvidia’s Tegra 2 was an early dual-core appearance in mobile devices (2010).

Embedded development typically follows the progression of mainstream computing, with an approximate 5 year lag. Approximate, because dual-core ARM Cortexes (Cortices?) and Intel Core 2 Duos are quite different, and designed for different applications.

Even 5 years ago, though, personal desktop computers were quite powerful, and that power is now available for an incredible variety of dedicated or mobile applications.

As embedded technology becomes increasingly powerful, development efforts have had to accelerate to take advantage of these advances before they become obsolete.

Reconfigurable Computing

“Reconfigurable” can mean a couple different things. In one sense, you can talk about reconfigurable processor architecture – at the silicon level. National Instruments recently published its 2012 Embedded Systems Outlook, which presents the spectrum of silicon available to embedded systems developers:

However, “reconfigurable” can also refer to the design components involved. At the microcontroller level, Parallax and Arduino play host to a number of functional, modular components – reconfigurable for any variety of applications. With Texas Instruments’ line of high-performance embedded OMAP-family of microprocessors, the BeagleBoard platform provides a single-board computer base for assembling a custom handheld prototype.

The idea is off-the-shelf hardware is designed in such a way that the work is shifted to integration, and piecing the parts together – rather than building everything from scratch (more on that next time).

Toolchain Consolidation

Anyone who designs and develops embedded systems can tell you what its like at the start of a new project. Which version of which OS do we need to be compatible with? Is there anything from the lower levels that we’ll need access to in the final application? I happen to do a lot of work with Android, and getting each of these pieces in line for a new project is an effort in itself!

During the early design and prototyping stages, there’s also a great deal of component selection, each of which has its own drivers that probably need to be integrated into your kernel. And if you’re starting from a clean machine, get ready to spend a few days installing your favorite Linux packages, editors, compare programs, and kernels.

Much like the LAMP stack that goes into building a web server, I’ve built my own stack that comes in very handy when I start developing, then I saved it onto a VMWare slice that runs off an external hard drive (also known as the Android V-IDE). It’s similar to this, but I’ll update it every month or so with any new or useful packages that make my life easier. For the Windows users out there (I’ll confess I’m still hanging on), the other hack is to have a dedicated Linux netbook sitting around. Everything gets compiled on a remote server, but for testing different versions of an Android APK, it’s invaluable.

What are some of your favorite strategies to hit the ground running? Post a comment or e-mail me – justin at liquidware dot com