Who knew designing RTOS-based embedded systems could be so easy?

The embedded industry is on a bit of a collision course. Market projections for the IoT are huge (IDC predicts annual compound growth of 15.6% through 2020), bringing many new developers to the embedded industry. However, most of them aren’t experts in embedded software. At the same time, even longtime embedded developers are facing new challenges like connectivity and pressure to develop very light yet high-performance embedded systems. The need to develop projects by “grabbing” files and putting them in an IDE one-by-one is simply not sustainable.

A couple of years ago, I experienced this situation myself. I wanted to use Micrium software for a home project. The project needed to use the RTOS kernel, TCP/IP stack and file system. So, I opened my favorite IDE and started to incrementally build up my system. I started from an empty project (while (1) loop), added the RTOS, compiled and ran with a simple task, etc. Of course, throughout the process, compiler/linker errors popped up and I had to spend time resolving issues like missing C files, missing headers, missing paths, incorrect compile options, etc. In short, what should have taken a couple of hours ended up taking a few evenings. It turned out the application, at least in my case, was the easy part.

As I went through the tedious process of creating this project, I told myself, “There must be a better way! We can’t keep making our customers go through this; we must make their lives much simpler, regardless of whether they’re designing simple or complex products.”

This process made me think about how nice it would be to have a tool that would allow a designer to:

  • Select an evaluation board
  • Pick their favorite toolchain (compiler, assembler, linker, debugger)
  • Select the desired modules (RTOS, TCP/IP and file system) along with a default configuration
  • Have main() initialize each module in the proper sequence
  • Press a button to export to the selected IDE
  • Compile without errors or missing files and paths
  • And most importantly, run an application within 5-10 minutes!

Micrium has long been a proponent both of educating the embedded industry and simplifying our customers’ lives. The µC/Probe™ visualization tool stands out as a key example of this, but I knew we needed to go even farther. While we haven’t historically been a tools company (which my engineers were sure to remind me of), I knew we could build this vision and deliver a tool embedded designers may not even know they need.

As could have been predicted, developing this new tool was a huge and complex project. We’ve even enhanced the Micrium OS embedded software so that customers will reap the most benefits of the new tool.

Called “Platform Builder,” the tool eliminates the complexity of building projects using the Micrium OS. In other words, all that’s left for you to add is the application code … as it should be.

Platform Builder Screenshot

Platform Builder eliminates the complexity of building projects using Micrium OS.

So What Is Platform Builder?

Platform Builder is a Java-based application that runs on a PC and “knows” CPUs, MCUs, evaluation boards, RTOSs, software stacks, drivers, etc., using files called master configuration descriptors (MCDs). MCDs are JSON-based files, and specify interdependencies between the different pieces.

For example, if you tell Platform Builder you want to create a Giant Gecko-based project using the Micrium OS kernel on an EFM32GG-STK3700 evaluation board (based on a Giant Gecko), then Platform Builder will know:

  • What MCU is on the board (Silicon Labs’ EFM32GG990F1024)
  • What resources are available
  • What files are needed for the kernel, board support package and startup code
  • To create a main() source file and add initialization code (in the proper sequence)
  • Etc.

For the EFM32GG-STK3700, Platform Builder knows there are no Ethernet ports on the board, and thus would not allow you to add TCP/IP to your project.

MCDs are typically created by Micrium engineers, but can easily be created by users so they can use Platform Builder with their own boards. This would allow developers to reuse their board-specific code with other projects. In Platform Builder, there are pre-existing MCDs for each CPU, MCU, board etc. and we (or the user) will be able to add more over time.

Platform Builder supports a growing number of CPU/MCU manufacturers, CPUs/MCUs, evaluation boards and toolchains:

  • CPU/MCU manufacturers: Atmel, NXP, Renesas, Silicon Labs, ST, TI
  • MCUs: AT91SAM9, EFM32, EFR32, K70, RM48x, RX63, RX65, STM32F4, STM32F7, Zynq-701x
  • Evaluation boards for the above MCU manufacturers
  • Toolchains: ARM, GNU, IAR, Renesas

Platform builder does all this while avoiding errors. This makes it easier for customers to create projects—even “what if?” projects. And most importantly, customers can concentrate on their value-added software and not be bogged down by infrastructure code.

While it is reassuring to get an embedded project up and running quickly, there’s no substitute for having documentation to help you understand what you’re doing. It will also help developers understand the APIs that are offered by the Micrium OS. That said, Platform Builder will remove some of the frustration you get when starting a project so you can concentrate on the important stuff in your RTOS-based design.


Questions or Comments?

Have a question or a suggestion for a future article?
Don't hesitate to contact us and let us know!
All comments and ideas are welcome.