The Transformation of Embedded Development

The market for embedded systems has traditionally been a stronghold of low-level programming, where efficient resource utilisation and precise hardware control were paramount. For decades, development was characterised by intensive use of C, C++ and, frequently, assembly language, running directly on microcontrollers (MCUs) or microprocessors (MPUs) with minimal operating systems or none at all (bare-metal). However, the past 20 years have witnessed a profound transformation, with the balance shifting towards abstraction, robust operating systems and development platforms that prioritise functionality and the user interface.

The Landscape Before the Turn of the Millennium: The Era of Fine-Grained Control

In the early 2000s, a typical embedded developer spent a significant amount of time handling interrupts, programming peripheral registers, optimising clock cycles and managing memory manually. Real-time operating systems (RTOSs) such as uCOS-II, VxWorks and FreeRTOS (which was gaining traction) already existed, but adoption was selective, reserved for critical applications in which latency was a determining factor. Object-oriented programming (OOP) in C++ was still an emerging practice in embedded development, constrained by the limited resources of the most common MCUs and the lack of robust development environments.

Milestones and Key Drivers of the Evolution:

The transition was not abrupt; it resulted from a convergence of technological advances and changing market demands. Understanding this evolution requires a look at the progression of processors and their manufacturers, which set the pace of embedded development:

1. The Pioneers of Embedded Systems: Zilog, Motorola and STMicroelectronics (1970s–2000s)

2. • In the early decades of embedded development, microprocessors such as the Zilog Z80 (launched in 1976), with its simple 8-bit architecture, were ubiquitous across a vast range of devices, from industrial control systems to video games. Programming was primarily in assembly language because of memory limitations and the need for fine-grained hardware control.
   • Subsequently, the Motorola 6800 family (from 1974 onwards), followed by the Motorola 68k (MC68000, 1979) and its successors, offered 16-bit and 32-bit architectures, paving the way for more complex systems and facilitating the use of high-level languages such as C. These processors became mainstays of workstations, telecommunications systems and industrial controllers.
   • Manufacturers such as STMicroelectronics (STM), with microcontroller families such as the STM ST6 (8-bit) and, later, the STM32 (based on ARM Cortex-M), began offering more highly integrated solutions with on-chip peripherals that reduced board design complexity. Programming remained predominantly in C, with close control of the underlying hardware.
   • The PowerPC architecture, developed by the Apple-IBM-Motorola alliance in the 1990s, also found a niche in high-performance embedded systems, particularly in automotive and networking applications, thanks to its robustness and processing capability.

3. Rapid Growth in Computing Power and Falling Costs (Mid-2000s–Present):

4. • Moore’s Law continued its inexorable advance. MCUs and MPUs became exponentially more powerful, with more RAM, flash memory and integrated peripherals, while their prices plummeted. This made it feasible to run more complex operating systems.
   • The introduction of architectures such as ARM Cortex-M for microcontrollers (from 2004 onwards) and ARM Cortex-A for microprocessors (from 2005 onwards, with the Cortex-A8 in 2007) provided the standardisation and scalability needed for manufacturers such as Broadcom, Qualcomm, NXP and STMicroelectronics itself, with its STM32MP1 series, to offer a broader range of devices.

5. The Consolidation of Embedded Operating Systems (Mid-2000s–Present):

6. • Embedded Linux: This was undoubtedly the most important catalyst. The open-source nature of Linux, its vast community, its robust networking stack and its support for a wide range of architectures (including ARM, MIPS and PowerPC) made it the preferred choice for devices requiring connectivity, user interfaces and complex applications. Projects such as OpenEmbedded and the Yocto Project (gaining momentum from 2010 onwards) greatly simplified the creation of custom Linux distributions for embedded systems, abstracting away the complexity of the bootloader, the kernel and the root filesystem.
   • Embedded Android/AOSP: Although initially designed for smartphones, the flexibility of the Android Open Source Project (AOSP) made it attractive for devices such as kiosks, industrial control panels and smart appliances, particularly when a rich, familiar user interface was required.
   • Advanced and Open-Source RTOSs: FreeRTOS, for example, grew enormously in popularity thanks to its permissive licence and integration into popular IDEs, simplifying task management and inter-task communication without the complexity of a general-purpose operating system.

7. The Rise of Prototyping Platforms: The Raspberry Pi and NVIDIA Jetson Revolution (2012 Onwards):

8. • The arrival of the Raspberry Pi in 2012 marked a decisive turning point. For the first time, a low-cost single-board computer (SBC), priced at approximately US$35 at launch, was available with an ARM processor (the ARM1176JZF-S in the first Pi), the ability to run Linux (the Debian-based Raspbian) and all the basic interfaces (USB, Ethernet, HDMI and GPIOs). This enabled developers, hobbyists and even students to prototype complex ideas without having to understand the intricate details of the hardware at register level.
   • Subsequent models, such as the Raspberry Pi 2 (2015, with ARM Cortex-A7), the Raspberry Pi 3 (2016, with 64-bit ARM Cortex-A53) and the Raspberry Pi 4 (2019, with ARM Cortex-A72), continued this trend, delivering increasing processing power and resources and reinforcing the view that a full operating system and a high-level programming environment were the way forward. The Raspberry Pi 5 (2023, with ARM Cortex-A76) is the culmination of this evolution, with performance comparable to an entry-level PC.
   • The arrival of NVIDIA with its Jetson platforms (for example, the Jetson TK1 in 2014), specifically designed for parallel computing and AI acceleration at the edge, revolutionised high-performance embedded systems. These boards combine ARM CPUs with powerful NVIDIA GPUs, enabling developers to deploy deep learning and computer vision models directly on the device, with a software environment (Linux for Tegra/JetPack) that greatly simplifies the process.
   • Other platforms, such as BeagleBone (Texas Instruments) and various boards based on SoCs from MediaTek or Rockchip, also helped establish the “computer on a board” paradigm.

9. The Importance of Object-Oriented Programming and High-Level Frameworks (Early 2010s–Present):

10. • As operating systems became available, embedded development widely adopted the programming paradigms used with general-purpose operating systems. C++ gained ground as the dominant language for business logic and interaction with the operating system, enabling more modular, reusable and maintainable software architectures.
    • Frameworks such as Qt became extremely popular for graphical user interface (GUI) development in embedded systems with displays. Their cross-platform capabilities and extensive libraries of widgets and functionality dramatically simplified the creation of rich user experiences.
    • Other languages, such as Python, also made significant inroads, particularly at the application layer and in rapid prototyping, thanks to their ease of use and the vast range of available libraries.

The Impact on Development and the Market, and a Nostalgic Look Towards the Future

The transition to platforms running operating systems has had a multifaceted impact:

• Faster Product Introduction (Time-to-Market): Developers can focus on application logic and the user experience, rather than reinventing the wheel with low-level drivers or thread management.
• Democratisation of Development: Lower barriers to entry for new developers encourage innovation and product diversification.
• Greater Functional Complexity: Today’s embedded devices can execute AI/ML algorithms, handle complex networking protocols, integrate cloud services and offer sophisticated GUIs that were previously inconceivable without high-end hardware.
• Simplified Security and Updates: Operating systems provide more robust security layers and software update mechanisms, which are essential in a connected world.
• Cost Implications: Although per-unit hardware costs have fallen, software development costs (owing to greater system complexity) and the need for more powerful processing resources may be higher for certain projects.

For hardware engineers who once relished every detail of clock cycle optimisation or direct manipulation of the registers in a Z80 or a 6800, this evolution may feel bittersweet. The beauty of extracting the utmost from every byte of memory and every processor instruction, an almost esoteric art form, has given way to managing library dependencies and configuring containers. Yet this is an advance to celebrate rather than a loss to mourn. The future of embedded systems no longer lies primarily in the intricate balance between silicon and bare-metal programming, but in the vast domain of software. Specialists in firmware and software development have gained ground, and they are shaping the connected, intelligent world we inhabit. The frontier has shifted, and the battle is now being fought at higher levels of abstraction, where functionality and innovation take centre stage.