Cross-board and cross-vendor embedded development with PlatformIO


Ivan Kravets, PhD, Researcher and Software Architect, explains how PlatformIO is a cross-platform code builder and the missing library manager.


We live in a time where the wall between the hobbyist and microcontroller (MCU) world has been completely broken. Just a few years ago, no one could have imagined that MCUs would go on to become popular with people who are not familiar with electronics. Nowadays, you don’t need to have deep knowledge in PCB design, assembly language or become buried under MCU application notes to get your first experience with embedded world.

Moreover, vendors have realized that there is a need to decrease entrance threshold and to propose alternatives to existing professional development kits. It was at this point when popular prototype boards (like the Atmel based Arduino) were conceived. Comfortable board form-factor, rich peripheral and huge community of enthusiasts gave rise to a new trend, which can be called “Embedded Boards for Everybody.”

Still, there is a problem related to programming instruments. It’s excellent that MCU vendors have spent quite a bit of efforts to create rich HDKs/SDKs and comfortable IDEs which allow the performing of hardware debugging and tracing. However, all of these features are of interest mostly for those who have already decided which specific MCU they will use for the project. So, at this point the market has generated another demand: to make cross-MCU development easy. This is where Arduino and its burgeoning community have played an important part: cross-platform processing-based Arduino IDE; simple and easy-to-use wiring-based framework with high-level API; incredible count of shields (sensors, actuators, etc.), and a lot of different libraries which cover significant part of hobbyist tasks. These have all made embedded development much easier. Yet, while Arduino enables development for varying MCUs, it is still a commercial product. As a result, it is inherently restricted to Arduino boards.

Saving time for the task in hand

It doesn’t come as a big surprise today when an interesting embedded project is invented by people who have not had any earlier professional experience with MCUs. I feel that this phenomenon can easily be explained with my motto: “Creativity comes from talent and never from knowledge.” Talented people and those with ideas are interested in quick prototype instruments which don’t require big efforts to use them. Many of these people prefer to concentrate on the task in hand, and don’t want to install too much of additional software, play with confused manual or get used to new additional IDE… So far so good, as many of vendor IDEs do address these issues.

However, what if for your next project, you need some board or MCU which aren’t supported by your favorite vendor? With devices becoming increasingly smaller, wireless and battery-powered, this is occurring more frequently. Then, all of a sudden, you have a problem: development platforms from the different vendors tend to recommend their own IDEs and approaches. Subsequently, you’re likely to have several IDEs installed, each with its own requirements (to make things worse, these requirements sometimes conflict with each other), and with an ongoing switching back and forth. Ouch! It’s not before long that this quickly becomes a major headache, and ironically, headache is exactly what these development platforms aim to avoid.

Developer, meet PlatformIO. PlatformIO, meet developer.

Here is where PlatformIO comes in, an open-source cross-platform code builder and library manager (available on GitHub). After many months of development, we have finally released PlatformIO 1.0 which has been recommended for production use.

I admit that, as one of the authors behind PlatformIO, I cannot be 100% objective when speaking about it, but I’ll try.

PlatformIO allows users to:

  • Decide which operation system they want to run development process on (You can even use one OS at home and another at work.)
  • Choose which editor to use for writing the code (It can be pretty simple editor or powerful favorite IDE.)
  • Focus on the code development, significantly simplifying support for the different development platforms, boards and MCUs.

Cross-platform code builder

platformio-embedded-development

PlatformIO is independent from the platform, in which it is running. In fact, the only requirement is Python, which exists pretty much everywhere. What this means is that PlatformIO projects can be easily moved from one computer to another, as well as that PlatformIO allows for the easy sharing of projects between team members, regardless of operating system they prefer to work with. Beyond that, PlatformIO can be run not only on commonly used desktops/laptops but also on the servers without X Window System. While PlatformIO itself is a console application, it can be used in combination with one’s favorite IDE or text editor such as Arduino IDE, Eclipse, Visual Studio, Vim or Sublime Text.

Alright, so PlatformIO can run on different operating systems. But more importantly, from development perspective at least, is a list of supported boards and MCUs. To keep things short: PlatformIO supports over 100 embedded boards (all boards which are supported by Arduino IDE) and all major development platforms including Atmel AVR and Atmel | SMART, among many others.

How it works

Without going too deep into PlatformIO implementation details, work cycle of the project developed using PlatformIO is as follows:

  • Users choose board(s) interested in project configuration file – “platformio.ini.”
  • Based on this list of boards, PlatformIO downloads required toolchains and installs them automatically.
  • Users develop code and PlatformIO makes sure that it is compiled, prepared and uploaded to all the boards of interest.

Cross-board code and continuous integration

As aforementioned, PlatformIO supports cross-board code development: multiple boards can be selected in a single project, and PlatformIO will apply all respective environments and will compile the code against each of boards within the project. And for the icing on the cake, this feature can be easily integrated with Continuous Integration System (such Jenkins, Travis CI and Circle CI). It should help to ensure that, at any point, a code at least compiles on all target boards, thereby eliminating costly, time-consuming and error-prone process of fixing these cross-platform issues at later stages, when your team members have already forgotten what the code was about.

The missing library manager

platformio-library-manager

With an overall trend heading towards open-source, embedded development is no exception. Indeed, there are countless embedded libraries already available today, such as high-level communication with sensors, actuators or even full-fledged IoT implementations. Nevertheless, every time you need something like it, there is a big underlying question around where to finding this specific library, and how to make it work with your environment.

To address this problem, PlatformIO Library Manager provides an ecosystem for library writers and library users. Using library manifest file (library.json), writers have an ability to describe library. This manifest is not only about such things as authors, description, keywords, and version, but first and foremost about technical information, ranging from location of source code and examples to CVS repository and dependencies. This manifest file is generic enough to be used by other library managers (if somebody else wants to write them).

For the library users (aka developers), PlatformIO provides two ways for searching for libraries. The first way is via Command Line Interface, the other is Web 2.0 Library Search with functionality such as library categories, different framework and platform filters, and advanced search syntax with boolean operations.

PlatformIO Library Manager can be integrated into the most popular IDEs and is capable of extending their functionality, including all-important automated updates of installed libraries. For instance, Arduino IDE benefits of using PlatformIO Library Manager are summarized in the following table:

Table

Conclusion

As noted above, as an author, I cannot be objective when speaking about PlatformIO. However, I am sure that for any kind of cross-board and cross-MCU development PlatformIO provides substantial benefits. PlatformIO takes the hassle out of installing all the tool chains you need, and allows you to build your code for many boards with a single command. PlatformIO Library Manager not only helps you to find and install libraries, but has an option to keep them up to date as well.

And as PlatformIO is an open-source project, you shouldn’t care about price or vendor lock-in. So, what are you waiting for? Give it a try (and if you don’t like it, you’ll get back that zero bucks you’ve paid for it, some restrictions apply, batteries not included).

UPDATE: PlatformIO 1.2.0 is now available. To explore the release history, you can head here.

3 thoughts on “Cross-board and cross-vendor embedded development with PlatformIO

  1. Pingback: Cross-board and cross-vendor embedded development with PlatformIO - Internet of Things | Wearables | M2M | Industry 4.0

  2. Pingback: From Web Developer to Embedded One: Interview with Ivan Kravets, The Guy Behind PlatformIO. Part I - IT Hare on Soft.ware

  3. Pingback: Cross-board and cross-vendor embedded development with PlatformIO | Ivan Kravets: "Creativity comes from talent and never from knowledge”

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s