Showing posts with label gumstix. Show all posts
Showing posts with label gumstix. Show all posts

Friday, March 17, 2017

Gumstix Pi Compute Boards are CM3-Ready

If you follow me on twitter (@gstixguru), you might know that I recently ordered an RPi CM3.  Lots of people have been contacting us to find out how well our Pi Compute boards support the new, faster module, so I found a bit of time to play around with it.  I'd worked with the original CM on our dev board for my GPS and RTK project a year ago with great success, and was looking forward to getting back to the Pi Compute boards.

First Steps

As always, my first step was to flash a brand new image onto the CM's eMMC.  I downloaded the latest Raspbian Jessie Lite ISO and mounted my CM on a Gumstix Pi FastFlash.  Next, I ran rpiboot, plugged the board into my USB hub and CROSSED MY FINGERS!

RPi CM3 on a FastFlash getting flashed. Pardon the clutter.
So what happened next?  Exactly what should:  the eMMC was mounted to my file system like any unpartitioned flash drive would be.  So I dd'ed the image, moved the module over to the Gumstix Pi Compute Dev Board and got ready to Pi.

First Boot

At first, all I wanted was proof of life.  That and I was sure the default wpa supplicant and network interfaces config would not get me on the WiFi network.  So I screen'ed in and powered up the board.  And yes, the console came to life, spewing forth those familiar Linux startup messages.  No kernel panic, no errors, no problem.  So far so good. Raspbian Lite was up and running.  Oh, all the things I should test: GPIOs, I2C, SPI....  BORING!

Let's start with USB (Oh, and get the WiFi up and running while we're at it; screen is not my friend and SSH makes me smile:).  The WiFi dongle goes into the port and lsusb shows a list of devices.  And there it is.

Bus 001 Device 002: ID 148f:5370 Ralink Technology, Corp. RT5370 Wireless Adapter

Beautiful.  I fix up /etc/network/interfaces and add the office WiFi network to wpa_supplicant.config and shut it down.  Time to set this asside and get back to my other tasks.

Day 2

Before ditching the USB console connection, I have to go into raspi-config and enable the SSH host, and reconfigure the daemon:

sudo rm /etc/ssh/ssh_host_*
sudo dpkg-reconfigure openssh_server
After a restart, ssh works fine.

Let's got straight up the food chain to the camera!  That's what I want to see!  I want to get that Sony IMX219 taking stills and recording videos.  I want to see those LVDS signals in action.  The CSI-2 camera connector is by far my favorite feature of the dev board.  So while I was in raspi-config, I made sure to enable the camera as well.

Here's my Frankenberry Pi camera rig, ready to go, I hope.
So I hooked it up, fired up the module and... nothing.  Did I forget something?  Of course I did! I needed the device tree overlay blob for the camera.  Oops.  OK, so I grab the binary, -- I get the one for both camera and display, just because I can -- copy it to the boot partition and restart.

And did it work?  See for yourself:
Me and my clipboard.
Edit: Here's me trying to pretend I'm not being recorded by the Pi Camera:


I also took a few minutes and got the USB-Ethernet board fired up, and yes, everything works great.
I am very happy.  Stay tuned!  I have a Raspberry Pi DSI display around here somewhere and I want to get that up and running too.

Wednesday, February 15, 2017

There is Nodana...


For those of you who don't know about the 96Boards open-specification hardware platform, it's a design spec for single-board computers (SBCs) that enables SoC vendors to provide their hardware in a standard form factor for increased compatibility.  It's also an engaged community working together to develop applications, software, and mezzanine cards for this ecosystem.

96Boards now has 3 different specifications for 3 classes of application.  There's Consumer Edition (CE), with standardized breakouts for both high-speed and low-speed signals, USB ports, HDMI, and so on.  There's also the Enterprise Edition (EE), which is more for server and networking applications.  It's a larger and more free-form design, with a low-speed header, USB and Ethernet, minimum 1 GB DRAM or expandable SODIMM slots, and optional 1 - 16 x PICe.  Finally there's the brand new IoT Edition (IE) spec.  It's designed to be tiny in order to fit anywhere.

All of these specifications have variants that allow hardware developers to add extra bits to their boards, making this a very flexible way of standardizing the important parts of SBCs.

The big benefit is that you can unite developer communities accross platforms.  The mezzanine card or maker project developed for board A will be compatible with board B, and vice versa.  With support from Linaro, providing a common Linux ecosystem for these boards, not even software compatibility should get in your way.

My honest opinion is that this open specification is very cool.

Gumstix is a 96Boards Partner

Yep, we're in cahoots with the folks at 96Boards and Linaro to bring you compliant hardware.  The release of the AeroCore 2 for Dragonboard 410C was only the start.  At the same time, we added the 96Boards Mezzanine Connector module to Geppetto D2O's library so that users can design their own mezzos for other applications.  If you don't know what Geppetto is, you can learn more by going to the Meet Geppetto page, read my earlier posts, or go straight to and give it a try.

I did a demo for 96Boards OpenHours, hosted by Mr. Robert Wolff (@sdrobertw) and actually flew my MAV, using a Dragonboard and the AeroCore 2 live in my office -- complete with a visit from the "demo demon".  The whole thing's on YouTube.

...Only Joule

So for those of you who don't know, a little compute module was released last year with quite a lot of juice hidden under its heat dissipator. The Intel® Joule™ module delivers unprecedented compute power in a tiny package.  From its two 100-pin Hirose connectors pour USB 3.0, MIPI LVDS,  PCI Express, HDMI, and a lot of what you already expect from COMs and SoCs.  It also houses its own WiFi and Bluetooth hardware.  All with the power of a quad-core processor akin to the Core-I7s you find in your desktop PCs.

Surprise, surprise, Geppetto's got that too!  You can go in and build your own host board using the Intel module and harness most of what it has to offer.

So a Square Peg and a Round Hole Walk Into a Bar...

On one hand you have this fantastic open spec hardware platform [round hole].  In the other, this epic compute module [square peg].  "those will never fit together," you might say (in fact, one 96Boards community member did).  Well, we gumstixians are very resourceful.  And the spec doesn't restrict the SoC's architecture to ARM, that's just the expectation.  So what did we do?  We took all of the components that make the 96Boards Consumer Edition spec great, we wired it up to the Joule connectors, (tested it), gave it a name, and unleashed it on the unsuspecting masses.

And that is how the Nodana 96Boards Consumer Edition (96BCE) for the Intel Joule module came to be.  Here it is:

Gumstix Nodana Features

The Black Sheep

That's right, all you doubters.  Now you can test your 96Boards projects on a powerful 64-bit multi-core Intel chip.  It's the first of its kind -- the first non-ARM 96Boards device.  Take it for a spin and tell me about what you do with it.  You can order it at

x86 IoT Fun

Psst!  We are also taking the IE spec to this dimension.  Our Radium 96BIE board complies with the 96Boards IoT Edition specification and runs the Intel® Curie™ module.  A 32-bit Quark processor  in bed with an ARCv2 MCU, a 6-axis internal measurement unit (IMU) and an independently programmable Bluetooth controller. Check it out at

Monday, September 19, 2016

A New Board and New COM Connector in Geppetto: TechNexion PICO-IMX6

Some of you may be wondering why I haven't posted any updates with respect to my RTK project.  Well, truth be told, it's been pretty busy here at Gumstix.  The release of Intel's new 64-bit IoT compute module at IDF, and our recent induction as manufacturing partner with 96Boards, gave me a steady flow of work.  And now we've released a new development board for the TechNexion PICO-IMX6 COM.

NXP's i.MX6 SoC has a fantastic selection of features - from 1080p HDMI to Gigabit ethernet, PCI express to image processing - and TechNexion has done a fantastic job of breaking out these features in a compact, low-profile compute module, complete with on-board WiFi and Bluetooth, an Edison-compatible low-speed header and two high-speed expansion headers.

Gumstix has put together a board with a long list of features to help you get going with TechNexion's PICO-IMX6 COMs.  Here's a list of its key features:

  • HDMI connector
  • Dual USB 2.0
  • microSD
  • Gigabyte Ethernet
  • MIPI DSI and CSI2 connectors
  • Audio in/out
  • NewHaven 4.3" cap-touch LCD connector

These and several more features, packed onto an 11x8cm PCB, make this board developer-ready for all kinds of projects such as handhelds, home automation control, tiny workstations or home theatre applications.  It's available now in the Gumstix Store

If you like the Gumstix PICO-IMX6 expansion board but it's missing something, or you just don't need this header or that display for your application, Its Geppetto design is available on the "Designed by Gumstix" tab in GeppettoD2O.  You can re-position, remove and add board modules to match up with your needs.

Wednesday, August 24, 2016

Make Your Own 96Boards CE Mezzanine Board
96Boards is really gaining some traction in the embedded world. Its open specification, software support, and community make it an appealing platform for hardware developers, programmers and makers alike.  Part of the specification for the Consumer Edition boards is a mezzanine connector.  This allows users to expand the hardware capabilities of their 96Boards-compiant SBC.  So where do these mezzanine boards come from?

Commercial Mezzanine Boards

Several expansion boards already exist and are available for purchase from online vendors such as ARROW.  These boards are meticulously crafted by hand by a team of engineers and can take a considerable amount of time from conception to market and may not be ideal for your needs.  It would be good to be able to design your own board to meet your project specifications.  For example Gumstix has released the AeroCore 2 for Dragonboard 410C.  But what if you need additional sensors or another UART port or two?  Soldering in wires and adding breadboards is one way of doing this, but it's messy and cumbersome... Especially for drone applications.

Enter Geppetto D2O

What if I told you that you could just take the board, stretch it out and drop in some new hardware?  That would be nice, wouldn't it?  Well, when you import a design into your workspace from our existing ones, that's exactly what you can do.  And, of course, you can always start a design from scratch.

Geppetto D2O (Design to Order) allows you to design or customise an expansion board with a familiar-feeling drag-and-drop interface.  A long list of modules can be placed wherever you need them on your design and
connecting them to the other modules on your board is easy with Geppetto's context menu system.

The Geppetto workspace
Gumstix will even build and test your board for you, ensuring that your design is mechanically sound and ready to go.  A $1999 set-up fee and a few weeks later and your design is in your hands.

Aside from Gumstix's own Overo and DuoVero COMs, connectors for many 3rd party COMs and some on-board SOCs and microcontrollers are available as well.  Alongside the release of the new AeroCore 2 board, which, by the way, was itself designed in Geppetto, we have added a 96Boards-compliant mezzanine connector to the Geppetto module library.

It has never been easier to create your own expansion boards.  If you're looking for the shortest path to market or just want to design your "ultimate IoT development board," make sure you check this out.

Making the AeroCore 2 for 96Boards

Like I said earlier, the Aerocore 2 for Dragonboard 410C was designed in Geppetto by our engineers. All of the hardware on the board comes from the modules in Geppetto's library and the process is easily reproduced.  In fact, I think I'll just walk you through it right now.  How about I make my own version of the design from scratch?  It won't take long.

Step 1: Go to Geppetto

Geppetto is entirely online.  There is no need to install any software, configure settings, or hassle with any of the plethora of problems that CAD software can cause.  If your browser works, Geppetto works.

When Geppetto finishes loading, which only takes a few seconds, your workspace comes up.  This is where you design your board.  There are a few tutorial videos if you want a detailed look at the Geppetto interface.  For now I'm going to focus on building my own AeroCore 2 for 96Boards.

Step 2: Add the Connector

Grab the mezzanine connector for 96Boards from the "COM Connectors" tab in the column to the right.  It snaps to the bottom edge of the board.  This makes sure that the USB and HDMI ports on the host board are accessible.  The default board size is a little small for the module and can be resized as you would a window on your desktop.  Once the connector fits on the board you will notice that the board outline and the connector module are  both red.  That is because there are unmet reqirements.

Step 3: Satisfy Requirements

Almost every module that you place on the board will either require or provide certain signals and
buses.  The only exceptions to this rule are mechanical elements, such as mounting holes.
When you hover over a module, its requirements are displayed in a menu that pops up beside the module.  If you click on it, a list of modules that will satisfy that reqirement will appear in the library. Once you've placed a compatible module on the board, you can connect the modules by clicking on them in turn.  As soon as the requires are satisfied, the board and modules turn green.

Yes, it's a big game of "red light, green light." My kids love that one.  Make everything green and the board will work.  So far, all we can do is boot the board with a 16V battery for power.  Time to add some features.

Step 4: A Microcontroller

Some boards require a microcontroller to, say, manage sensor output or control some servos.  In the case of the AeroCore 2,  an ARM Cortex-M4 MC does more than that.  It actually runs a PX4 compatible autopilot software suite for drone control.

The COM connections for 96Boards are mounted on the underside of the board so modules can be placed within its shadow, as long as they don't overlap with the green footprint.  So in order to save space, I'm going to squeeze the M4 in there.  I can rotate the module by right-clicking it and selecting "rotate" from the context menu.  Double-clicking modules also rotates them.

The M4 requres 3.3V so we need to add a regulator in order to power it from the battery.  The regulator could also take 5V from the host board, but we'll be multiplexing that source with the battery later.

Step 5: The Meat

Now that the compute devices are placed, it's time to add the sensors, headers and connectors that make up the AeroCore 2.  If you watch the animation to the left, you can see the board come to life.  With each module added, all of the requires are provided and all of the modules turn green.  This only took me about 30 minutes to do, and with a little extra time and patience, I could re-arrange the board to match the design for the AeroCore 2 for Dragonboard exactly.  The only thing my design lacks is the LTE modem.  That one we added in after the Geppetto design was completed, squeezing it in over other module footprints.
You can see from the pictures below that my design (below) is pretty good, compared to the original design (above).
The Gumstix Aerocore 2 for Dragonboard 410C

My Aerocore 2 for 96Boards

But don't take my word for it, get started now! Go to and start designing your own board for free.

Tuesday, August 16, 2016

Big News From the Intel Developer Forum

The Big News

Intel just announced a new compute module for IoT, pro makers, hardware startups.  It's a big deal and Gumstix brought Geppetto to the party.
The Intel Developers Forum is in full swing in San Fransisco and during the keynote demonstration, the Intel® Joule™ module was introduced to the world.  This thing is a powerhouse!  It boasts a quad-core x86-64 processor at 1.7GHz, 4GB RAM, and up to 16GB on-board storage.  this, plus UEFI-capable bios, 1080p HDMI, two-lane PCI Express 2.0, and USB 3.0 and 2.0 give this tiny 20x40mm compute module the power of your massive desktop workstation.  In fact, you can see the Gumstix Workstation for Intel® Joule™ in action at our booth at the IDF!

Gumstix and Geppetto there for Intel® Joule™

That's right! We are there!  A connector module for Intel®'s new compute module is already available for your Geppetto board design and we are demonstrating it for you right at ground zero.  We have already designed six boards for the Intel® Joule™ and have brought some of them with us to show you.  Now, I won't be there but I and my partners in crime will be introducing Geppetto and the Intel® Joule™ module connector to booth visitors via telepresence.

All six of our boards are available in our store.  Take a look at the current selection:
The Gumstix boards for the Intel® Joule™ module 

If You're There, Come Visit Us.  If You're Not There, Come Visit Us

We want to show you what Geppetto can do.  The boards we brought with us were Designed by Gumstix in Geppetto and you can design your own right there in a few minutes.  The whole team is there to help you out and answer your questions.  If you don't happen to be there, go check out and give it a shot yourself.

Intel, the Intel logo and Intel Joule are trademarks of Intel Corporation or its subsidiaries in the U.S. and/or other countries. 

Friday, July 22, 2016

More on the Areocore 2 for Dragonboard 410C

 As you could probably tell from my earlier post, I'm pretty excited for  the new Aerocore 2 board.  I just posted a short video showing off the board's features and performance that you really should watch if you have any interest in MAVs, drones or swarms.  This board's got some awesome capabilities.

Check out the video and see for yourself:

Friday, July 8, 2016

Remote Data Collection Board Chapter 2: Geppetto Design Process

So let's go through the steps it took to design my board.  Geppetto D2O is a web application so there is no download or software configuration steps, just straight to the design process.

First, click on that link or the one at the top of the page.  The app will load and you will see your workspace:

Geppetto Workspace
That column on the right hand side has all the modules that are available to add to your board.

Making the RDC Board

First, here are the main modules I'm going to use:

Processor: TI Sitara AM4378

  • bootable uSD card reader
  • 8GB eMMC
Power: 5V barrel connector

  • USB type-A host 
  • USB micro-B console port
Network: NimbeLink Skywire LTE modem connector

  • 9-axis IMU (gyro, mag, accel)
  • humidity
  • barometer
  • camera (on-board tiny caspa)
  • 5-pin Pre-GO GPS connector 
  • 4-pin ADC
  • I2C
  • UART
  • SPI
  • 20-pin GPIO
There will definitely be other bits and pieces to add.  A reset button and power light, to name a couple.  Anyway let's get started.

Placing and Connecting Modules

A sensible place to start is the processor.  You can find the TI Sitara AM4378 module under the "Processors" tab in the right-hand column.  That section also has a couple other ARM microcontrollers and processors on there.  Just drag
Drag-n-drop your modules
and drop it onto your board the way you would an icon on your desktop.  This module is taller than the default board size but you can resize it just like any desktop window.

What I like to do next is to satisfy all of the module's dependencies before moving on to the next main module on my list.

With the connections option selected in Geppetto's toolbar, when I hover over a placed module, a list of required signals appears.  If I click on a red signal, that right-hand column is filtered to only display those modules that provide that signal.

AM4378 module's required signals
In order to supply a 5V signal to the processor module, I am going to use a 5V power multiplexer for reasons I'll explain later.

Once I place the power muxer on the board, the 5V signal on the CPU module turns yellow.  Yellow means that this signal can be provided by a module on the board.  Now when I click on it, a matching signal appears next to the power muxer, which I can click on to complete the connection.

I'll add the uSD reader, a 1.7mm 5V barrel connector and a USB micro-B connector.  I needed to add a 3.3V regulator to correctly power the uSD reader and a USB-UART interface adapter to connect to the proccessor's console.  You'll notice, connecting the USB-UART module to the processor, a little penguin head appears next to UART0.  This is the "Tux Approved" icon.  That means that if you connect to UART0, the console connection will work out of the box.  Otherwise, you might need to edit your boot sequence accordingly. 

Also I connected the muxer to the barrel connector AND the USB micro-B, again, for reasons I'll explain in a second.  As I connect the required signals between my modules, the modules turn green.  When all modules are green the board's border turns green too.
All my modules are green

Now it's time to add our LTE modem.
This one's under the "Network" tab.  Adding this module to our board is tricky in the case of our board.

I've been promising to tell you why we need a power muxer and this is it.  Nimbelink's specifications for current on their  modems is high to account for increases in power usage when signal quality is poor.  I'm sure you've noticed that when your smartphone's signal drops below two bars, your battery drains much faster.

Now this is supposed to be a REMOTE data collection device so we want it to be able to run off of solar panels and backup batteries.  So if the weather conditions are not condusive to providing enough power to the board, we want to continue collecting data. So once the reserve battery is depeleted, let's just run the processor and sensors off of the trickle of power the photovoltaic cells are providing.

To do this I'll hook the 5V signal directly to the barrel connector while everything else uses the power muxer.  The muxer will automatically switch to whichever source is providing the most power.

Another new task required for connecting the modem is choosing between multiple options.  It can communicate with the CPU either by USB or UART, so the signals pop-up has a "choose  >" item.  Hover over that and you see these two options.  In this case I want to use USB.  Overall, I need two USB host devices because I want to use a USB WiFi dongle for testing later.  That and some external sensors may require a USB connection.
Not enough USB host connections

But what's this?  The AM4378 module only provides ONE USB host?  No problem.  We'll just add an on-board 3-port USB hub. 

And that's about as difficult as placing and connecting modules can get.

I'll skip over the addition of the sensors and headers and go straight to layout.

Arranging Modules

The next step in my workflow is layout.  I like to get everything on the board first and put the puzzle together later.  That's one thing that's great about Geppetto.  Doing this in, say, Eagle is not a trivial process.  Here we can just move them arround and not worry about traces, vias, etc. This is my design now:
My arranged board

Once I clean it up, drop the eMMC I forgot about and add some mounting holes, it looks like this:

Saving and Previewing

Now that I have my design the way I want it, I don't want to lose it.  In order to save you need an account, but I'm sure you can set that up after clicking the login button on the top-right corner of the page.

When you click the save button, you'll be asked to provide a title and description.  When you click next, there will be a short wait while Geppetto thinks, then, and this is really cool, you'll see a 3D render of your board.

This design image can even be exported to an STL file, which is handy for making enclosures for it.

The final step in the Geppetto workflow is ordering, but for now, we'll stop here.  My imaginary company needs to approve the design before we commit to it.

NEXT TIME: Ordering and preparing for software development

Wednesday, July 6, 2016

Remote Data Collection Board Chapter 1: Starting in Geppetto

As the final stage of my RTK project quickly approaches (waiting for a clear day), My next project is taking shape.  I am designing my first expansion board in Geppetto, ordering it, and developing an RDC program for it.

What is Geppetto?

Geppetto is a unique online service with which you can lay out and connect together hardware modules, COMs and on-board processors on a virtual PCB.  The drag-and-drop "Green Means Go" interface make it easy to place and connect all of the features on your board.

Couple that with the fact that Gumstix will manufacture, test, and ship your board to you in three weeks, and you've got the ultimate design-to-order expansion board CAD tool.  It will cost you a $1999 setup fee for your first Geppetto order.

We use Geppetto in-house as well.  Gumstix's recent expansion boards and single-board computers (SBCs) have been designed in Geppetto and are available to the community to kickstart your designs.

Check out for more info.

What I Am Doing

My Imaginary Company

Here's my use case scenario.  Let's say I run a company that monitors the potential for wildfires in a given area.  In order to do so, I must acquire a multitude of environmental data: temperature, humidity, pressure, etc.  I need a compact and self-contained device that can easily be deployed in the field.  As usual, I will also need to access these data nodes from anywhere.  What I need is a PCB that incorporates as much of this functionality on-board as possible because connecting hardware with wires is messy and unreliable.

OK so how do I go about a proof of concept?  Eventually, I'll want to go to high-volume production as my business grows, but for now I want to avoid paying engineers to make me a board.  Fortunately, Joe Tech, the intern on the firmware engineering team, heard about Geppetto from one of his profs and tells me all about it.

I check it out and start playing around.  After about 45 minutes or so,  I've got a board with most of the sensors I need, on-board storage and cell modem capabilities.  I added a few communication headers in order to add the remaining sensors for my application.

After a few tweaks and the stamp of approval from my senior engineer, I order the board.  Three weeks later, it arrives and my firmware team starts testing their software.


I'm going to go through the whole design and development process.  I'll design my board in Geppetto, get the thumbs up, order it, and start developing right away.  I'll keep you posted as the design moves through the hands of the Gumstix engineers and will develop some code to poll the sensors and transmit the data over the Internet.

In the spirit of the use case above, the board will focus on ambient environmental data, like temperature, barometric pressure, etc.

We'll be taking this board to production and selling it in the Gumstix store when it's finished so if you're in the business of collecting data remotely and need a board that will get you going, keep an eye on me and I'll let you know when it's ready.

UP NEXT: The finalized Geppetto design

P.S. I recently opened a twitter account, @gstixguru.  Follow me for updates on my projects and cool new hardware in the tech industry.

Thursday, June 30, 2016

RTK Rover Project Chapter 4: Final Stages

Well it's time to wrap up the RTK project.  My rover is driving nicely. I now have a Pre-GO, Pre-GO PPP, WiFi antenna, 4x AAA battery pack and my motors connected to my Gumstix BBB Rover cape, And my Gumstix Pi Compute Dev Board is rigged with my Pre-GO PPP SMA and antenna, as well as its own battery pack.  I have not, sadly, finished my automated driving software, but that's going to be a little time-consuming, so I'll stick with what I've got.

The Plan

I am going to simultaneously track my rover with RTK, PPP and standard GPS as it circumnavigates one of the tennis courts.  I'll be steering it from my laptop, logging the raw datastream from the two GPS modules with the BBB and the RTK solution data by way of the RTKLIB Windows tools on my laptop.
Then I'll plot the data and share it in my next post.

Sadly, the skies aren't co-operating today so I'll have to put the experiment on hold until the weather clears.

The Hardware

Now that I have everything assembled for the final experiment, here's a manifest of the primary components I used and where you can get them:

This is what it looks like all put together:

There's only one GPS header on the Rover cape so I had to solder the cable for the second Pre-GO directly to the BBB connector header.  Now it looks like this:

The Software

You can check out the git repository at:

I'm only using RovCtl for this experiment, but I intend to finish my automation software somewhere down the road.


 I have to admit I've been testing my rover control software a bit more than necessary.  Honestly, how can you resist driving a little robot all over the
office, chasing co-workers to the coffee machine, etc.  For kicks, I taped a camera to the bot and recorded my shenanigans.

I think the BBB's batteries were running low.  There were a couple of moments when there was noticeable lag between command and response, but I still managed not to hit anything too hard.  With a full charge and some clear weather, we'll have this experiment wrapped up in no time.

Check out the video above to see how it did.

Up Next: Results!

Wednesday, June 29, 2016

AeroCore 2 for Dragonboard 410C: DragonDrones?

I'm taking a bit of a break from RTK and robots today because I'm pretty excited about a board we recently released.  I've always been interested in UAVs and drones, and have wanted to build one out of the derelict UAV frames we have lying around the office here.  Well, I may get my chance in the near future.  The AeroCore 2 expansion board for the Dragonboard 410C is now available and is a major upgrade from its Overo and DuoVero counterparts.

AeroCore 2

Innovation in UAV Flight Control

The AeroCore 2 was originally released Fall 2015 for the Gumstix Overo and DuoVero COMs to replace the original AeroCore, adding Spektrum DSM-2 RC connectivity, more communication headers, and GPIOs, and moving GPS off-board with Gumstix the Pre-GO family of boards (which I am currently playing with in my other posts).  The AeroCore family of expansion boards were developed in conjunction with graduate students from Stanford University's Aero/Astro program.  Its small dimensions make it ideal for micro aerial vehicles.

On-Board Autopilot

The AeroCore 2 design includes an on-board ARM Cortex-M4 microcontroller running NuttX RTOS.  It not only manages I/O data in real time, it's also compatible with PX4 autopilot software for fully automated flight.

Higher Level Thinking

The inclusion of a powerful processor in a drone allows for in-flight decision-making, such as low-latency obstacle avoidance, computer vision-based navigation, or swarm applications.  AeroCore 2 boards are designed to connect to Overo and DuoVero COMs, with ARM Cortex-A9 processors capable of these compute-intensive tasks.

Now for Dragonboard 410C

The new AeroCore 2 for Dragonboard 410C, as I mentioned earlier, adds some really cool features to an already spectacular platform.

A New SBC 

The Dragonboard 410C from Arrow is more than a COM, it's a single-board computer that has been built to match the 96Boards CE specs.  With a Qualcomm Snapdragon 410 processor, 1GB RAM and on-board eMMC storage, this credit card-sized SBC is a force to be reckoned with.

The Dragonboard is designed to connect to expansion boards.  Much like the BeagleBone Black has capes and the Arduino has shields, Any board designed to mate with the 96Boards spec can be connected to the Dragonboard.

A compatible connector module has been added to our repertoire of COM
connectors and we've begun designing boards for the 410C.

We started with the AeroCore 2 design.

What's New For AeroCore 2

As good as any design may be, there's always room for improvement.  This includes the tried and true AeroCore 2.  Two exciting new features were added to this iteration that continue to expand the board's functionality.

First, a CSI-2 camera connector was added.  This is a fast communication channel capable of driving HD cameras like the Raspberry Pi camera.

The other big deal is the NimbeLink Skywire 4G LTE modem connector.  Remote control doesn't get much more remote than that.

Designed by Gumstix in Geppetto

Even though you could order the board from the Gumstix store for around $150, your startup/research project/product may require different or additional features. Geppetto is an amazing tool for creating your own custom boards, or for modifying existing ones.  It's a drag-and-drop web interface that allows you to place hardware, from an ever-growing library of headers, connectors, ports, sensors and more, on your design, order it from Gumstix (for a $1999 set-up fee) and receive the final, tested, board in about three weeks.  For more information, go to:

Board designs from Gumstix engineers are freely available and you can clone them to your workspace and change them however you want.  You can get started with the AeroCore 2 for Dragonboard 410C by following this link.

Friday, June 17, 2016

RTK Rover Project Chapter 3: Rover

Well, I've taken a short break from RTKLib this week.  I spent my time preparing My BeagleBone Black and Gumstix BBB Rover cape for the arrival of my bot.  Sure enough, it arrived mid-week.  It's a substantial kit:

The Build

Unwrapping and assembling things is one of my favorite activities.  In short order, I had assembled the mechanical components and my rover was ready for the electronics.

 As an added touch, and because I absolutely hate these screw connectors, I jury-rigged this double-pitch right-angle pin connector for my PWM/analog input. And yes, that's yellow electrical tape holding the motor controller down.  I wasn't willing to wait for the recommended double-sided foam tape.  Seems to be working fine.  I might just add some mounting holes for it after this project's done.

The Code

I took some time to put together some test code and the start of a PWM library to get some wheels turning.  I haven't had the patience to comment it, but it's here.  Before hooking it up to the robot, I tested it out with some LEDs:

 Yep, they dim in response to my input.  I think it's time.  Of course the square wave output from the PWM has to be converted into an analog signal.  The manual for the Sabretooth 2x12 motor controller recommends a 10kOhm resistor and a 0.1uF capacitor like this:

No problem.

And the Test

Complete success.  Time to get data from the IMU and integrate my code into the RTKRover code.

NEXT TIME: Data, data, data.

Friday, June 10, 2016

RTK Rover Project Chapter 2: The Early Development Stages

I am working diligently on my RTK project and have hashed out a lot of the details.  I've made progress in software, my hardware is on the way, and some of the specifics have been hashed out.  Here's my progress.


RTKLIB is not a trivial API.  Coding an automated base-station / rover application from scratch would take more time than I can dedicate to this project.  So I have taken the two apps that pertain to my needs and have begun making modifications to them.

First off, I need a background communication channel for instructions from the base station and data from the rover.  The easiest way to do this, of course, is to set up a TCP socket.  Str2str, an app that takes the data stream from your GPS device, converts it into a universal format and redirects it, uses sockets to stream GPS data between rover and base, but its use is obfuscated away in the depths of the library and isn't configured for secondary data structures. Likewise with rtkrcv, the rover-based workhorse that interprets the SNR data to get a hyper-accurate fix.

What I've done using a very straightforward abstraction layer for the standard gnu-sockets library, Simple Sockets, is built a back-channel for data from the rover's IMU, as well as its precise coordinates (which I am well aware I could get for free from rtkrcv, but would have to cherry pick. Besides, I may as well retransmit it to where I want it since I need the second socket port anyway) to the base station, and for waypoints for the rover.

I also removed the console for rtkrcv. This won't be necessary as the base station will issue all the required commands to the rover.

The next step is to make this whole thing ARM-compatible and set up some makefiles.  The makefiles are easy, even if my format is a little naive.  I don't have a lot of experience in writing them so they're fairly verbose and don't use much in the way of macros or regular expressions.  Now that the build process is nicely automated, I need it to cross-compile.

There were a few compatibility issues, but most of them were solved by installing or updating glibc.  The worst transgressor of all was Simple Socket's use of vsprintf() to collect and format a list of arguments into text.  The problem is the function requires a list of arguments of arbitrary length.  something along the lines of:

foo(char* format,...)

I replaced vsprintf() with sprintf() and so far it hasn't broken anything (fingers crossed).

Now it's cross-compiling and running on both the BeagleBone Black and RPCM.  Next step is getting motor control and IMU data working.


A couple weeks ago, I ordered this robot chassis and this motor driver from The chassis was on backorder so my shipping date got pushed back but I got an email this morning and my equipment is en route.  I also grabbed some 4-cell AA battery cases and barrel connectors from DigiKey for my two boards and I have some NiMH and LiPo cells to choose from here in the office from previous AeroCore 2 tests, which will work well for powering the robot's motors.  I've considered adding IR proximity sensors for obstacle avoidance, but that's just icing so I'm going to skip it, at least for now.

The Plan

Here's what our autonomous robot will do. It will receive waypoints from the base station and, using the magnetometer, it will navigate to that waypoint.  As it moves, It will transmit its coordinates, including altitude, to the base station along with its heading and pitch from the IMU.

A motivated individual (potentially myself later) would be able to generate an accuarte 3D mapping of the terrain the robot traverses.  Kind of sounds like a good surveying technique.

Up next: robot and data test!

Friday, May 20, 2016

RTK Rover Project Chapter 1: RTK and RTKLIB

Not long ago I posted about getting the Pre-GO PPP GPS modules up and running on BeagleBone Black with our Gumstix BBB Rover cape.  Now that I have them working on both this and the Gumstix Pi Compute Dev Board, it's time to take the GPS fun to the next level.  So what can we do with two incredibly accurate GPS modules running on tiny devices?  How about Real-Time Kinematics?

RTK eliminates the jitter experienced by solitary GPS receivers using differential techniques.  It requires a base station with known co-ordinates and a mobile reciever. By using the difference in signal-to-noise (SNR) ratios and phase for common satellites, RTK algorithms can cancel out atmospheric effects that can pollute geopositioning results.  I won't go into incredible detail here since Navipedia has a great wiki on the subject.
This image shows the GPS/GNSS data in pink and the RTK results in green of a rover driving around in a  6-meter circle.

So why do we care about RTK?  It's primarily used for surveying, but there are many situations when a robotic rover may want to track its path, report its exact position or navigate to a given waypoint with a high level of accuracy.  That's what I'm excited about.  I'm going to rig an automated robot with a BBB and Rover cape, use my RPCM rig as a base station and use the GPS data to control the rover.

First we have to get some RTK software up and running.  There aren't a lot of options for this in the open-source world, but the biggest name is RTKLIB.  It's not only an open source library, but it also includes a complete set of GUI and CLI apps to get you started.

Sadly, the GUI elements are written for Windows, so there's no chance of using them on the Pi Compute dev board, and I'll have to monitor operations from my laptop.  But the str2str and rtkrcv command line programs are the two most important elements of the software suite for my needs. these applications, and eventually their source code, will be the backbone of the RTK project.  The easiest way to compile these for ARM Linux is to download the source code onto your BBB and Raspberry Pi and compile them natively.  I ran into a little linking problem after I cross-compiled the applications on my PC and tried to run them on the COMs.  In the end, it was just far less hassle to go native.

Having set a precedent with the Gumstix Pi Compute Pre-GO PPP project, I felt I had to build a fancy box for my Gumstix BBB Rover.

I got the COMs equipped with their expansion boards, Pre-GO PPPs and antennas and wrapped up in a nice package.  With the RPCM being my base station, I used a Pre-GO PPP SMA so I could use a more sensitive antenna.  This will get me a more accurate fix on the rover's position.  The antenna I'm using is the Dominator AA.161 from Taoglas.  The BBB Rover has an on-board TI WiLink8 WiFi and Bluetooth modem that requires a u.FL antenna, and I'm using the Pre-GO PPP with the built-in antenna.

With the binaries and data files on the boards, I started experimenting, streaming data from the COMs to my laptop and trying to get a fix.  I tried a myriad of config files and, after some digging, I put together this file. The commands therein are transmitted to the u-blox NEO-7P on the PPP boards and instruct them to transmit tuples that are normally blocked across the UART channel.  These strings carry the phase data of the satellite signals which RTKNAVI, the GUI I use on my laptop, uses for RTK solutions.

After some trial and error, I began to see SNR data.  It looked something like this:

The top graph is the data from the BBB, and the bottom from the RPCM.  Each bar represents the SNR from a satellite.  In order to get a solution, the two computers have to be able to get a strong fix (shown as a colored bar) on several common satellites.  Unfortunately, the window in the office only provides half a constellation.  Not nearly enough for RTK... Barely enough for a single fix.
My little computers are getting their fix.  Tux is helping.

 Clearly, I need to get outside.  That'll have to wait until next week.  In the meantime, I'm all set up, apart from a battery pack for the BBB, to do some real testing.

NEXT TIME: The great outdoors, differentially.

Monday, May 16, 2016

Gumstix Pi Pre-GO PPP Project Chapter 5

I took my equipment to the tennis court yesterday and gathered some data.  When I arrived, I was saddended to discover that the two main courts were occupied so I went to the last one. Ten minutes at each of the eight corners I'd mentioned before  gave me quite a bit of data.  When I plot it on Google Earth, it looks like this:

OK so something's wrong.  First off, the orientation Google's image is clearly incorrect. Secondly, there's that tree!  It's covering the entire back-right corner!  I might be able to go again some other time, but let's make some observations first.  Looking at the inner corners, [LBS, RBS, LFS, RFS], the dimensions are reasonably correct.

What it looks like to me is that the court sits on a slope, which I hadn't considered to be a major source of error.  I had assumed that the courts would be level but, having been there for some time, they have most likely sunk in places and bubbled in others.  I may have had more luck had I acquired access to Wimbledon,  but the fact of the matter is I'm trying to measure exact distances with chunks of metal free-falling high above the earth and no fixed point of reference on a surface with random elevations.

Here is my conclusion for this project:  The Pre-GO PPP works beautifully with the Raspberry Pi Compute Module through the Gumstix Pi's UART breakout connection. It is able to measure GPS position with decimetre-level accuracy and sub-decimetre jitter.  However, measuring distances with sub-metre-level accuracy is next to impossible using GPS coordinates alone.

There are many reasons.  First off, environmental factors, such as trees and bridges will drastically increase dilution of precision.  Reason number two is explained above.  Lastly,  I can't seem to get enough court time to collect all my data points.

Clearly, a new strategy must be employed.

Up next: BBB Rover and RTK

Thursday, April 28, 2016

The Gumstix Pi Pre-GO Project Chapter 4: Tennis Anyone?

I went to find the survey marker from and discovered that it was directly under a bridge.  It's also in the middle of a road.  I think that the coordinates they're publishing are not as accurate as I would like.  Strangely, there does not appear to be any more markers in the near vicinity of the office.  In the absence of an accurately located marker, I'm going to try and measure the dimensions of a tennis court with GPS data.   
So far, I have been very impressed with the Pre-GO PPP's performance.  I took it out for another field trip recently and had very nice 0-8 cm diameter groupings.  HDOP has been consistently near and below 1.0.  Geodetic engineers and surveyors would be pleased as punch.
I intend  to define the outer bounds of the court and the service lines within.  If I draw a 11x24m box with an 8.2x13m box smack in the middle, the test will be a success.  These measurements are based on the regulation court dimensions outlined in the image to the right.  I'm also considering measuring the accuracy of the altitude measurement.  The net is 1.6m high and if I can get that measurement from the base of the net post to the top, that will be an interesting data point as well.
The difficulty I have faced with my setup has not been the hardware itself.  This has performed perfectly throughout my experiments.  The issue has been with logging and interpreting the data.  I have been using my cellphone as an ad-hoc network router to ssh in to my Pi and during one experiment, the connection between my laptop and my GPS rig kept dropping out.  As a patchwork solution to this issue, I have added a physical connection to the RPi's system console: Just a short USB microB-to-A I can connect to with an extender cable.  If the WiFi drops out, I can just plug in.

Added to this is the fact that, in general, GPS modules spit data out once per second.  The Pre-GO PPP is no exception which means that, for a 1-hour test, there are 3600+ records to process. I'm using Python to interpret and plot the data but it still takes time.
Up next: RESULTS!