Migrate STM32 Projects from System Workbench for STM32 to Atollic TrueSTUDIO Using the Automatic Project Importer

Posted by Magnus Unemyr on Feb 1, 2017 5:01:11 PM

Migrating projects from one embedded IDE to another can be a time-consuming task. But an automated project importer can make the migration a breeze. No need to postpone the move due to the migration efforts anymore!

Moving an STM32 project from one IDE to another can include difficulties on many levels. But with the Atollic TrueSTUDIO project importer, STM32 projects can be imported from System Workbench for STM32 very easily indeed. Read this blog post to learn more!


An embedded project is stiched-into a particular IDE in several different ways, even if that isn't necessarily apparent at first sight. There are several reasons for this.

If you migrate a project between completely different compilers (for example, from the GNU GCC compiler to a proprietary compiler), you may have to worry about things like:

  • Different compiler grammar or language-standard support
  • Different #pragmas or inline assembly syntax
  • Different runtime library behavior
  • Different command-line and build options
  • Different linker configuration file grammar
  • Different makefile grammar
  • Different power-on-reset start-up code behavior
  • Etc

Migrating from one GCC-based tool to another removes almost all of these difficulties. This, for example, is the case when moving an STM32 project from the System Workbench for STM32 IDE to the Atollic TrueSTUDIO IDE.

This is a great thing, as it becomes easy to upgrade from a basic and free ECLIPSE/GNU tool to a professional-grade embedded IDE with features like a stack depth analyzer, kernel-aware RTOS debugging, SWV event/data tracing, ETM/ETB/MTB instruction tracing, hard fault crash analyzis, live variable watch, etc.

But even if it is relatively easy to move an embedded project from one GCC-based IDE to another, there are still issues to consider. In particular, the IDE project configuration settings comes to mind.

Dependent on what IDE you wrap around the GCC compiler, it has different GUI options to configure the tool itself and the build system. Consider, for example, compiler options that are defined in the GUI using checkboxes or dropdown lists. While all GCC-based IDE's can use the same gcc command line options, various IDE's present them to the developer in a different way in the IDE GUI.

Most IDE's have their own configuration settings format that are stored in an IDE-specific project configuration file. This is obviously the case with proprietary IDE's, like the IDE's from Segger, Keil, or IAR.

Migrating a project from one ECLIPSE/GCC IDE to another ECLIPSE/GCC IDE removes this final problem too, right? Surely all ECLIPSE-based IDE's use the same file format for the project settings and should therefore be compatible with each other?

Not really.

It is true that all ECLIPSE-based IDE's are using the same (XML-based) project file format. And so, some of the basic IDE settings are in fact compatible across different ECLIPSE-based IDE's.

The problem is, all embedded ECLIPSE-based IDE's have extended the basic functionality to make the IDE fit for embedded use and to provide differentiation; and these extensions need to store their settings too. These are non-standard and incompatible across different ECLIPSE-based IDE's.

The integration of the GNU GCC compiler - and the corresponding settings - is one such area. The integration of JTAG debug probes (for example, ST-LINK or Segger J-LINK) is another. Proprietary debug functionalities, like SWV or ETM/ETB/MTB tracing also need proprietary configuration GUI's that must store their settings in the project configuration file too. The list goes on.

The short story is that even though all ECLIPSE-based IDE's are based on the same project file format, they are in practice not compatible with each other, as they all have their own extensions to it.

And so, moving an STM32 project from System Workbench for STM32 to Atollic TrueSTUDIO is very easy in terms of source code file compatibility, as they are both based on the GNU tools. We get:

  • GCC -> GCC migration for the C/C++ source code files
  • LD -> LD migration for the linker configuration file
  • GAS -> GAS migration for the assembler files
  • MAKE -> MAKE migration for the build system
  • NEWLIB -> NEWLIB migration for the runtime library

In short, no or minimal changes are needed to the source code files; either being C/C++, assembler, linker or makefiles.

And since both System Workbench for STM32 and Atollic TrueSTUDIO are ECLIPSE-based IDE's, the IDE configuration settings should in theory be easy to migrate too. But for the reasons outlined above, this isn't really the case.

This is there the automatic project importer comes in.

Atollic TrueSTUDIO can import complete System Workbench for STM32 projects, and auto-convert the ECLIPSE project setting files as well. In other words, Atollic TrueSTUDIO understand the System Workbench for STM32 project settings file, and map the System Workbench for STM32 settings to the corresponding Atollic TrueSTUDIO ones.

While there are occasional settings that can't be converted as they don't have a corresponding setting in Atollic TrueSTUDIO, all the basic ones that are normally needed to successfully build the project are converted.

The net result is that it becomes super-easy to import STM32 projects that are currently developed in System Workbench for STM32. This includes large collections of example projects and reference code from various suppliers (e.g. STM32Cube firmware examples).

The project importer is included in TrueSTUDIO starting with v7.1. You access it from the File, Open Projects from File System... menu command (you can download TrueSTUDIO here).

If you are currently using System Workbench for STM32, or want to try some example projects developed for it, give the Atollic TrueSTUDIO project importer a go.

With TrueSTUDIO Pro, you get advanced capabilities like live variable watch view, SWV event- and data tracing, ETM/ETB/MTB instruction tracing, a hard fault crash analyzer, a build analyzer, a stack usage analyzer, kernel-aware RTOS debugging, and much more!


Read this free whitepaper and learn more on ARM Cortex-M development and debugging:

Read our ARM development  whitepaper!


Topics: Atollic TrueSTUDIO, Project migration