Easing embedded software development with EDA tools

Anthony Pellerin

January 30, 2017

Anthony PellerinJanuary 30, 2017

For those in the industry this won’t come as a surprise. Embedded systems empower every aspect of modern life. Within those systems there are now hundreds of millions of lines of code, each of which has been optimised for a specific hardware platform and debugged to ensure reliability, security and safety. Developing embedded software is rapidly becoming the single largest risk and cost in product development, so choosing the right tools for the job is now fundamental to success.

The Software Development Paradigm
Embedded software programming was once a matter of manually transposing an intention expressed using mnemonics into machine code (normally represented using hexadecimal or binary values) and putting those values into a persistent storage device, readable by a microprocessor. Things have changes a lot in the last 40 years or so.

The third generation of programming languages saw high-level, platform-independent languages emerge and, with them, productivity increase. With abstraction came the ability to manage complexity which, as a result, has increased in line with processing performance. The two have provided mutual motivation ever since.

Today, developing embedded software is still platform-dependent but the balance of that dependence is changing. Increasingly higher levels of abstraction mean code is more transportable but is still reliant on the underlying hardware features. Uniquely in the embedded domain, the intrinsic link between hardware and software remains as important today as it ever has, but overall system functionality now relies more heavily on the software.

This makes software development the single most important or, at least, influential element of product development. Without embedded software, no end product would function, and without the ability to develop embedded software efficiently and reliably the overall cost of product development would become untenable, threatening innovation and progress.

The System-Level View
Software can broadly be categorised as high-level or low-level; high-level can be written to execute on a system (such as PC or Server) after the system has been fully developed, while low-level software is written to create the system. Embedded software is where the operating system, middleware (such as communication protocols and drivers) and the application code come together to interact directly with the underlying hardware (see the next section for more details), while high-level software is more dependent on the operating system and can be largely hardware-agnostic.

Developing a system architecture requires an appreciation of these two domains and how they must inevitably interact. It also requires an understanding of how software in the two domains is developed.

A relatively new trend within high-level software development involves fast and frequent iterations. This so-called Agile approach to software development is intended to accelerate development by quickly evolving a software platform against requirements that can also change or evolve in parallel with development.

Where Hardware meets Software
One of the unique things about embedded software is the level to which it is able to interact with the hardware platform. Despite considerable efforts to consolidate embedded systems around a common architecture, the industry remains fragmented, meaning systems are invariably bespoke. Microcontrollers based on the ARM Cortex-M family of cores are numerous, with most semiconductor manufacturers holding IP licenses for at least one of the cores. However, despite this proliferation there are still many alternative architectures available. Even ARM-based devices from different manufacturers feature numerous variations.

This means that not only is it possible for embedded software to interact with the underlying hardware, it is a fundamental feature of embedded systems. The interaction between hardware and software in embedded systems is normally referred to as firmware, because of the way the two influence each other and the overall system behaviour.

The fragmented nature of the embedded industry means developing firmware is an iterative process but one that is much less agile than higher-level software. A major part of that process is verification and, inevitably, debugging.

As the cost of software development increases it threatens to become a real barrier to entry. To address this, some manufacturers are now adopting a Software-as-a-Service approach to development tools. There is an increasing number of development tools that can now be accessed over the internet. This approach isn’t new; the first computer networks pioneered the concept of centralised processing accessed using ‘dumb’ terminals — the thin client is today’s equivalent.

Tool Selection Criteria
Managing complexity is a fundamental feature of Engineering Design Automation (EDA) tools; tools that allow features and functions to be described at a high level and then automatically translated into a low-level, deployable design. A major part of system-level design is now focused not on the hardware but the software development process, so tools that can help automate and manage that process are increasingly useful.

For some systems, simple tools are still best. This may mean that a word processor or spreadsheet application is all a Project Manager may need. For more complex systems, there are now tools available to meet these demands.

Many of these tools are intended to manage the entire development process, from requirements to production; Product Lifecycle Management, or PLM tools, as they are known.

Specific technologies have evolved to support this, such as the Unified Modelling Language (UML), a vendor-driven standard managed by the Object Management Group (www.omg.org) which allows software to be modelled before any code is written, to evaluate the perceived needs and expectations against actual results.

Entity Relationship Diagrams (ERD) are a method for showing, graphically, the relationship between entities and are often used in the development of databases. Tools that integrate these technologies now targeting electronic product development include Visual Paradigm and Enterprise Architect; both are visual modelling tools and make use of UML. Some UML tools are now also capable of generating software from high-level requirements captured in this way.

Operating Systems
Processors targeting embedded applications are now much more powerful than they were even five years ago. They range from 8- to 64-bit architectures and while 8-bit devices are still used in some ‘simple’ applications, it is increasingly common (and cost-effective) for 32-bit or even 64-bit devices to be specified in embedded designs.

One of the benefits of more capable processors is their ability to run an operating system. Many operating systems focused on embedded systems are real-time and highly optimised, but still offer the opportunity for customisation. Non real-time operating system may be used when the application is not so deeply embedded and often the operating systems chosen are Windows Embedded Compact (or Windows CE) or Linux.

Both of these operating systems are configurable; Microsoft’s Platform Builder is an Integrated Development Environment (IDE) for customising Windows CE, while the popular Linux distribution, Yocto, is supported by an Application Development Toolkit that provides the same functionality. In this context, Yocto could, to some extent, be considered to be a fully featured operating system that requires some high level configuration at implementation and while ‘hardware agnostic’ is readily portable to a range of processors able to run a Linux distribution. To further support this configurability and portability, Buildroot is an open-source project for building embedded Linux systems using a cross-compilation toolchain that can target a specific embedded processor. While the latter comes with less features, it has the advantage of a faster ramp-up phase.

Continue to page 2 >>

This article originally appeared on Embedded's sister site, EDN Europe: "Managing the complexity of embedded software development through design automation tools."


< Previous
Page 1 of 3
Next >

Loading comments...