Embedded systems are everywhere, from household appliances to industrial machinery. At the heart of these systems is embedded firmware, the special software that makes hardware components work and do what they are supposed to do. Understanding embedded firmware development is key to creating efficient, reliable, and secure embedded systems that meet the demands of modern applications.

 

What is Embedded Firmware Development?

Embedded firmware development is the process of designing, programming, and implementing software that runs on hardware devices in embedded systems. Firmware is special software that controls hardware and makes the system work as intended. Unlike regular software, firmware is tied to hardware, so it’s part of devices like microcontrollers, IoT devices, and industrial equipment.

 

Embedded Software vs. Firmware

While often used as synonyms, there is a difference. Embedded software is the broader category of software that runs on embedded devices, firmware is more specific, it’s software that is tightly coupled with hardware and is stored in non-volatile memory.

• Embedded software is application-specific code that does high-level tasks in devices like smart appliances or industrial machines. It can be updated or replaced and is written to do functionality beyond hardware-level control.

• Firmware is low-level, permanent software that controls hardware operations. Found in components like microcontrollers or BIOS chips, the firmware provides the foundation instructions so the hardware works as intended. Firmware updates are rare and critical.

 

Embedded Software vs. Firmware

 

Embedded Firmware Development Fundamentals

 

Firmware Architecture Components

Firmware architecture is influenced by factors like processor type, memory availability, performance requirements, and real-time constraints. While developing firmware you should get familiar with the following terms:

1. Bootloader: This is the first code to run when the device is powered up. It initializes the hardware, sets up the environment for the OS, and loads the main firmware into memory. The bootloader is critical for system startup and can also facilitate firmware updates.

2. Kernel: The core module, the kernel manages system resources, schedules processes, and handles memory. It ensures communication between hardware and software components and system stability and performance.

3. Hardware Abstraction Layer (HAL): HAL provides a standard interface between the hardware and the higher-level software components. It abstracts hardware specifics so the firmware can be more portable and adaptable to different hardware platforms.

4. Device Drivers: These modules enable communication between the OS and hardware peripherals like sensors, actuators, and communication interfaces. Device drivers translate general input/output commands into device-specific operations so the hardware works properly.

5. Application Layer: This layer is the main functionality of the embedded system, it implements the specific tasks and operations for which the system is designed. Applications talk to the underlying layers to do their job.

6. Real-Time Operating System (RTOS): In systems with real-time requirements an RTOS is used to manage task scheduling and ensure critical operations are executed within a defined time frame. It provides deterministic behavior for time-critical applications.

7. Communication Protocols: These are standardized rules for data exchange between the embedded system and external devices or networks. Implementing protocols like UART, SPI, I2C or TCP/IP enables reliable and structured communication.

8. Security Modules: With growing concerns about cybersecurity modern firmware architectures include security features like encryption, authentication mechanisms, and secure boot to prevent unauthorized access and tampering.

9. Power Management Unit (PMU): The PMU manages the power consumption of the system, it implements power-saving strategies which is very important in battery-powered or energy-efficient devices.

A good firmware architecture puts all these aspects together so the embedded system works efficiently, reliably, and maintainable throughout its life.

 

Embedded Firmware Development Mind Map

 

Hardware Platforms and Hardware Components

To do firmware development you need to understand and select the right hardware platforms and components. At the heart of any embedded system is either a microcontroller unit (MCU) or a microprocessor unit (MPU). Both have a central processing unit (CPU) to execute instructions but they differ in integration and usage:

• MCUs are self-contained with built-in flash memory, RAM, and peripherals. Good for small systems with limited resources.

• MPUs rely on external memory and peripherals. MPU is usually part of SoM (System on Module) which is then connected to CB (Carrier Board). How it exactly works is a topic for a separate article though. MPUs are good for complex systems running a full operating system like Linux. For embedded systems you often go with custom Linux images build for example with Yocto Project.

For firmware development, you will also need:

1. Development Boards or Evaluation Kits: Dev boards give you access to the features of an MCU or MPU and a way to test and prototype designs. Evaluation kits on the other hand are enhanced versions of development boards with extra tools to analyze and validate performance.

2. Debugging Tools: For firmware development, these include in-circuit debuggers, JTAG programmers, or SWD tools to interact with the code on the target hardware.

Choosing the right hardware and tools will make firmware development and project execution much smoother.

 

NXP i.MX 8 is a popular target hardware platform for many embedded applications

 

Programming Languages Used in Firmware Development

Firmware engineers usually rely on selected programming languages to efficiently interact with target hardware while meeting the constraints of embedded systems. When developing firmware, the choice of language depends on the complexity of the firmware applications and the hardware platform.

 

1. C: Mostly for historical reasons it is the most popular language for firmware engineers, offering precise control over hardware, minimal overhead, and portability. It is ideal for creating efficient, low-level firmware code.

2. C++: Adds object-oriented features, suitable for complex firmware applications requiring abstraction and scalability. Usually at Scythe, we go with C++ development in most of our projects.

3. Assembly: A core choice for low-level programming languages, used in performance-critical tasks or highly constrained systems.

4. Rust: Emerging for its strong safety features, reducing risks in critical systems. Rust gets quite a lot of attention recently among software developers.

Mastering these languages equips developers with the technical skills needed to create code optimized for resource-limited environments.

 

Embedded Firmware Development Process and Design

The firmware development process is quite similar to general embedded software development and involves several steps to get a reliable and efficient system. There are of course unique procedures that you wouldn’t do in the context outside firmware programming.

 

1. System Requirements Engineering

This is the first step where the project goals and constraints are defined:

• Define the system functionality: What the embedded system should do? (e.g. control a motor, read sensor data, communicate over a network)

• Specify performance requirements: What is the expected speed, accuracy, and response time?

• Identify resource constraints: How much memory, processing power, and energy is available?

• Define safety and reliability requirements: What are the safety considerations? (e.g. fault tolerance, fail-safe mechanisms)

• Get input from stakeholders: Involve all relevant parties (engineers, designers, customers) to ensure the requirements are correct for the project.

 

2. Hardware Components and Software Architecture Design

This stage involves creating a high-level design of the software system:

• Modular design: Break down the system into smaller modules with well-defined interfaces.

• Cybersecurity precautions: Investing time in this topic at the beginning of the firmware development process is key to preventing serious issues.

• Inter-process communication: How the system components will communicate with each other (e.g. using message queues, shared memory).

• Choose an operating system (if applicable): Choose a Real-Time Operating System (RTOS) or go bare-metal (no OS).

 

3. Embedded Development – Coding

This is where the actual coding happens. Few tips to make sure firmware development goes smooth:

• Coding standards: Follow coding conventions and best practices to improve code readability and maintainability.

• Test early and often: Write unit tests for each module and integrate it into the development process.

• Use version control: Use tools like Git to track code changes and for collaboration and rollbacks.

• Code reviews: Have other developers review the code to find issues and improve quality.

 

Tips for smooth Firmware Development

 

4. Firmware Testing and Debugging

Testing is crucial to ensure the firmware is reliable and correct:

• Unit testing: Test individual software modules in isolation.

• Integration testing: Test the interaction between different system components.

• System testing: Test the overall system performance and functionality.

• Hardware-in-the-loop (HIL) testing: Simulate real-world conditions to test the system behavior.

• Debugging: Use debuggers, logging, and other tools to find and fix issues.

 

5. Deployment

This stage involves copying the compiled firmware to the target device:

• Firmware flashing: Use specialized tools to write the firmware to the device’s memory (e.g. using JTAG, UART, or over-the-air).

• Bootloaders: Implement bootloaders to manage the firmware update process.

• Verification: Verify the firmware is installed correctly and the system is working as expected.

 

6. Maintenance

Support and updates are needed to keep the system working and fix any issues that may arise:

• Bug fixes: Fix software bugs and security vulnerabilities.

• Feature enhancements: Add new features or improve existing functionality.

• Firmware updates: Release new firmware versions with bug fixes, security patches, and feature enhancements.

• Technical support: Support users and system administrators.

 

Embedded Firmware Security

Embedded firmware security is critical as vulnerabilities at this level can compromise the entire system and lead to unauthorized access, data breaches, or device malfunction. A lot depends here on the proper architecture design at the beginning. A fully embedded firmware security approach includes:

• Secure Boot: Only load trusted firmware during system startup. This involves verifying digital signatures against a root of trust to prevent malicious or tampered firmware from being executed.

• Firmware Updates: Implement secure over-the-air (OTA) updates to patch vulnerabilities. Use cryptographic validation to ensure only legitimate updates are applied and prevent unauthorized changes.

• Encryption: Encrypt sensitive data stored or transmitted by the firmware.

• Code Reviews: Regular code audits to find and fix security issues. Combine thorough reviews with automated tools to find vulnerabilities before deployment.

At Scythe we often build embedded software for medical devices, so are used to the fact that security considerations play a crucial role not only in the medical sector but across various industries. Recently EU introduced the Cybersecurity Resilience Act (CRA), so there is broad agreement that security should belong to industry standards. The topics of CRA, regulatory compliance, and legal aspects of software development will be extended in future episodes.

 

Embedded Firmware Security approaches

 

Summary

Embedded firmware is the base of embedded systems, where hardware devices work correctly and efficiently. By knowing the basics and following best practices in design, testing, and security, developers can build firmware that meets the requirements of today’s technology. For IoT, automotive or industrial applications, embedded firmware is part of the digital world.