It is currently a very strong trend in the embedded industry to standardize on ARM Cortex devices, the GNU gcc compiler (with its accompanying gdb debugger), and the Eclipse IDE. I call the ARM, GNU and ECLIPSE combo “AGE”.
What are the driving factors for this strong trend? And what are the benefits for embedded developers to jump on the ARM Cortex, GNU gcc/gdb and Eclipse train? In my opinion, there are many benefits that provide embedded developers with great advantages.
If we start on the processor side, it is easily understood that the multitude of different incompatible processor cores previously used in the embedded industry was highly inefficient. Each semiconductor vendor had to design their own processors, with is proprietary instruction set architecture (ISA) themselves. The tool and middleware ecosystem for each vendor was small, since each tool market was an isolated island with relatively few customers. Therefore, few microprocessor architectures enjoyed a strong software and tool ecosystem. It also created a lock-in effect not proving flexibility to embedded developers, also giving them weak possibilities for price or delivery time negotiations.
With the standardization on ARM Cortex processor cores; many semiconductor manufacturers develop essentially the same processors. Examples are the Cortex-M cores; where many suppliers offer largely similar microcontroller devices, for example STMicroelectronics STM32, Freescale Kinetis, SiLabs EFM32, NXP LPC, Atmel SAM, etc. There might be small differences in terms of pinout, peripheral module setup and memory layout, but they are largely identical in many key characteristics. That provides customers with second source supply, a competitive market with price and negotiation possibilities, and a unified tool ecosystem offering much better software options.
On the IDE side of things, ECLIPSE has become the de-facto standard for embedded IDE’s, with many low-cost and free tool solutions available. There are also high-end commercial solutions available, for example Atollic TrueSTUDIO supporting ARM Cortex devices, such as STM32, Kinetis, EFM32 and LPC. ECLIPSE is immensely more powerful and flexible compared to traditional proprietary IDE’s, thanks to its background as a general purpose PC tool. That is also its drawback, as ECLIPSE is not fit for embedded development as-is. That is not a problem however, as Atollic and other tool vendors have added features specific for embedded development, such as:
- Project wizards
- Embedded JTAG probe integration and debug launching
- ETM/ETB instruction tracing and SWV/SWO/ITM event- and data tracing
- Cortex-M crash analyzers
- Kernel-aware RTOS debug solutions
- SFR register viewers
- MISRA-C coding standards checkers
- Target support for thousands of devices, boards and JTAG probes
And so there are ready-made low-cost as well as high-end professional embedded IDE’s based on ECLIPSE available for ARM Cortex developers. Furthermore, ECLIPSE can be extended by 3rd party Eclipse plugins that adds many other types of capabilities. Do you need some functionality not offered by Eclipse or any 3rd party Eclipse plugin? Write your own!
With an embedded IDE based on Eclipse, ARM Cortex developers gets a supremely powerful and flexible development platform; with cross-platform support; second-source support as well as upgrade paths from low-cost tools to high-end professional tool solutions. As ECLIPSE is an open IDE developed by an open community, there is also no vendor lock-in. And it is indefinitely extensible. Many large corporations standardize on ECLIPSE for these reasons.
On the compiler and debugger side, the GNU gcc compiler and GNU gdb debugger has become very popular for ARM Cortex development. The GNU gcc compiler is rock solid, of very high quality, and producing very compact code. And again, the GNU compiler is developed and supported by many companies and organizations, offering an open solution with no vendor lock-in.
Moving from one gcc based tool to another requires no source code changes. In contrast, moving from a proprietary compiler to another compiler typically requires many changes to the source code files:
- Assembler file syntax
- Linker file syntax
- Makefile syntax
- Compiler #pragmas
- Inline assembly syntax
- Command line options (for script builds, etc.)
- Compiler specific behavior (such as structure packing, bitfields, etc.)
- Compiler warnings
It is therefore of my opinion that standardization on ARM Cortex devices, using tools based on the ECLIPSE IDE and the GNU compiler and debugger is a very compelling one. This provides embedded developers with a unified technology market, with many competing vendors, offering both second source opportunities, price negotiation possibilities, and no vendor lock-in.
Finally, the ARM Cortex processor cores are very scalable from Cortex-M0 and Cortex-M0+ on the low end, via Cortex-M3, Cortex-M4 and Cortex-M7 on the middle end, up to the Cortex-R cores for real-time DSP processing and the Cortex-A cores for application processors. The GNU tools and the ECLIPSE IDE are both of high quality, have very powerful features, and almost indefinitely flexible.
I think the embedded industry is finally coming of AGE!
If you want to read more on ARM Cortex development using ECLIPSE IDE and the GNU tools, read this white paper: