Showing posts with label autodoc. Show all posts
Showing posts with label autodoc. Show all posts

Thursday, December 7, 2017

AutoBSP Gets Your Geppetto Board Booted

What is AutoBSP

AutoBSP is a new service offered to Geppetto designers that accelerates board bring-up by customizing a boot configuration file -- a device tree -- for every design.

Quick, What Is a Device Tree?

Device trees are logical maps of the hardware connected to a processor. Linux bootloaders can make use of them to help multiplex GPIO pins, assign addresses to external devices, deliver device settings to kernel modules, and control the SoC’s power-up sequence.

Device tree source (DTS) code is compiled into binaries -- or device tree blobs (DTBs) -- and added to the boot partition of a device’s disk image. The bootloader then reads this DTB and configures the SoC and the operating system with help from its contents.

The SoC, its application-specific processors, programmable power systems, and connected devices are broken down into a tree of nodes. Each node contains vital information about its configuration, voltage levels, GPIO assignments and interrupt vectors. These are used by the kernel and drivers to bring up, operate and expose them to the userspace.

Why Should You Care?

One SoC, many devices: Just a few NXP i.MX 6 boards

In an ecosystem where, for any given SoC, there may be tens of SBCs, compute modules, or expansion boards, board bring-up can be an incredibly difficult challenge. The inclusion of device tree support in the Linux kernel facilitates the process by adding a flexible abstraction layer between the firmware and the hardware, removing the hardware description from the kernel.

Device drivers can be written to glean variables, parameters, and logical addresses for the various hardware components and chip features it needs to operate from the device tree; Regulators can be programmed and sequenced; Chip features can be activated and disabled.

Your Geppetto Board is Unique to You

Let’s say you’ve just designed and ordered a custom board using the Geppetto interface. You have included a Linux-ready COM and a particular collection of sensors, ports and devices that suit your application. That board will be in your hands in a few weeks, tested and ready to go. Gumstix will offer our own flavour of Yocto Linux through our storefront, as well as developer documentation, spec sheets, and other helpful resources.

With almost 200 modules available in the Geppetto library and more added regularly, there are endless possible arrangements that your design might take and it’s possible that you’ll want it running some flavour of Linux. It’s our goal to offer you as much support and information as possible to help get your platform up and running as fast as we can get it in your hands.

AutoBSP is Unique to Your Geppetto Board

Normally, someone would have to manually create a device tree to bring up the components on your board, meticulously adding, tweaking and debugging each node until all of the devices work as expected. AutoBSP delivers a working, compiled device tree specific to your design on demand.

This means that, as soon as the product is in your hands it will be ready to run, saving hours of development and testing. AutoBSP is one more way that Gumstix is accelerating your time to market by getting your prototype designs ready for development as fast as we can deliver the hardware.

SoC and Compute Module Support

Most Linux-ready COM connector and Processor modules are supported by AutoBSP, and the rest are on their way. Here’s some detail:

What AutoBSP Can Do:

AutoBSP will currently build DTBs for boards designed for the majority of platforms available in Geppetto. The following COMs and SoCs are currently supported:

  • Gumstix Overo and Overo STORM COMs
  • Gumstix DuoVero COMs
  • Toradex Colibri iMX6 COMs
  • Toradex Colibri iMX7 COMs
  • TechNexion PICO iMX6 COMs
  • Raspberry Pi 2/3 and Raspberry Pi CM/CM3
  • AM335x (Pepper) SBCs
  • AM437x (Poblano) SBCs
  • SCM-iMX6 (Cobalt) SBCs

What AutoBSP Will Do:

Just like Geppetto, AutoBSP is constantly expanding to accommodate the needs of its users. Expect support to grow as new SoC modules are added to Geppetto. Some additions are already underway.

  • BeagleBone Black
  • Arduino-supported MCUs
  • 96Boards CE (Dragonboard 410C)

Wait, Did You Say Raspberry Pi?

That’s right. When you design a Raspberry Pi HAT, or an RPCM expansion board, AutoBSP will deliver a DTB overlay specific to your board. That’s one file to configure I2C devices, assign GPIOs, and activate SoC features. If you’ve gone and purchased a Gumstix Pi HAT and you’re looking to get started quickly on your next maker project, the AutoBSP-generated dt-overlay will help you skip much of the trial-and-error setup procedure you deal with for other HATs and get you coding as fast as possible.

Copy AutoBSP’s DTBO file to your Raspberry Pi boot partition’s ‘overlays’ directory and change the ‘dtoverlay=’ string in ‘config.txt’ to match and the Linux kernel will ‘see’ your board and its devices when it starts up.


At Gumstix, we are constantly looking for ways to make our lives easier. The benefit is that we pass these helper services, or their benefits, along to our clients. It started with the COM. Gumstix pioneered the idea in 2003 with the Verdex and Verdex Pro - a Linux-ready compute device the size of a stick of gum. This enabled hardware developers to test, prototype and deploy their designs more easily, encapsulating the compute power in a single, replaceable module.

We carried the idea forward ten years later when Geppetto was born. We further modularized the concept of the computer by introducing hardware as feature modules on a virtual board. Start with a COM connector, drop in USB, Ethernet, and any of the ~150 modules in the Geppetto library to build your own development board, prototype or production device. Click 'Complete Design' and Geppetto generates the CAD files for you and sends them to our engineers for review.

Geppetto now takes advantage of all of the back-end data that Geppetto uses to render your board as well, providing extra resources for engineers and developers. Through the 3D preview feature, users can export the 3D rendering of their device to an STL file.

AutoDoc delivers valuable signal and connection data on the fly before your design is even ordered. It includes links to reference manuals, feature outlines, signal descriptions and their associations, and much more.

Now, AutoBSP goes a step further and gives you the files you need to get Linux up and running. With a featured Yocto image from Gumstix and an AutoBSP DTB, you will have your board running in minutes instead of days.

You can expect to see more of these types of services to crop up from time to time as we discover new ways of making your life easier.

Just One More Reason

AutoBSP is just one more reason why Geppetto is THE design-to-order tool for IoT, embedded, and robotics hardware. Test-drive Geppetto today at and create your next innovation.

Friday, July 14, 2017

AutoDoc: We Automated Product Documentation

Geppetto's AutoDoc

Gumstix has announced this week that Geppetto users can now download documentation for their designs that is generated from the current state of their project.  The addition of the AutoDoc button marks the public release of a tool we've been using internally for some time.  As one of the content curators of this application, I'm excited to share it with everyone because it's a bigger deal than it sounds.

Hardware Documentation

I'm one of those people who find it satisfying to produce usable technical documentation - to describe the operation and setup of a platform in a legible, accurate and eloquent way.  I have always felt that written tech materials either skimp on details or skimp on readability, and I strive to find a balance of both.

For hardware, one of the documents engineers find most helpful is the schematic - a block diagram of the ICs and passive elements that are interconnected in a design.  Firmware programmers, on the other hand, are less reliant on these drawings.  Instead, they need to know the bus names, addresses, GPIO indexes, and features  of the devices connected to the SoC they are programming.
Both need access to technical reference manuals, a layout overview, and connection maps.

AutoDoc cover page for one of my designs
Geppetto's purpose is to provide an avenue for board development that does not require in-house electrical engineers, providing a piece of hardware that could pass directly into a developer's hands.  In my opinion, this is the epitome of the startup use-case.

Why AutoDoc?

Because Geppetto completes the layout, BOM, and fabrication steps for your design, you can have a board in your hands really fast.  That doesn't leave a lot of time for someone like me to sit down and write out a detailed description of your design and its components, so we developed a method of generating written design specs solely from the data later used to generate your board.  We have been able to provide this kind of documentation for some time and it has helped many clients get their applications up and running fast.

With the data in these files, developers can configure drivers, write interface software, and begin testing code before the board has even shipped.  By exposing access to this resource to you before you complete your design, you don't even need to order your boards before you get started. Clicking on the AutoDoc button gives you the pin-outs and signals as they are currently saved.  I feel like it's empowering you with ownership of your design at the earliest possible time.

...And I don't have to sit there and write it all out.

Board layout diagram and a module description

Why it Works

If you don't know what LaTeX is, you should.  It is essentially a programming language for documents.  Look at this way:  When you write a document in MS Word or Google Docs, you have to struggle with the complexity of its "What You See is What You Get" (WYSIWYG) interface.  This is nice for letters, memos, and most resumees, but when it comes to technical documentation, it becomes a fight.  Also, it's not particularly portable.  When you create a document in Google and download it as a .docx file, it definitely doesn't look the same.  Margins change, images move or disappear entirely, fonts are lost or mutilated...  A mess.

Tables, captions, title pages, pagination and indenting:  All these things can be hard-coded into a document with LaTeX.  It will look right every time you compile it.  It will look right when someone else compiles it.

So if we treat documentation as source, then we can script it.  We can apply templates to it. We can make the result deterministic and incrementally improve its quality and content.  And this is what we did with AutoDoc.  There is now no temporal or financial expense in creating a useful reference manual for custom designed Geppetto boards  Enjoy.

What's Next?

I like how Geppetto automates things.  Seeing what it delivers always makes me smile.  So what else can we automate.  Lots!  What else do you need, as firmware developers?  As project managers?  As startup companies?  You can look forward to more of it from Geppetto.